IBM - Guia Do Curso - Fundamentos Do IBM InfoSphere DataStage v11.5

®
Guia do curso
Fundamentos do IBM InfoSphere
DataStage v11.5
Código do curso KM204 ERC 1.0
Treinamento IBM
Prefácio
Novembro de 2015
AVISOS
Estas informações foram desenvolvidas para produtos e serviços oferecidos nos EUA.
A IBM pode não oferecer os produtos, serviços ou recursos discutidos neste documento em outros países. Consulte seu representante local da
IBM para obter informações sobre produtos e serviços atualmente disponíveis na sua área. Qualquer referência a um produto, programa ou
serviço da IBM não tem intenção de afirmar ou inferir que somente aqueles produtos, programas ou serviços da IBM podem ser usados. Qualquer
produto, programa ou serviço de funcionalidade equivalente que não infrinja nenhum direito de propriedade intelectual da IBM pode ser usado no
lugar deles. Entretanto, a avaliação e a verificação da operação de qualquer produto, programa ou serviço não IBM são de responsabilidade do
usuário. A IBM pode possuir patentes ou solicitações de patentes pendentes que se relacionem ao objeto descrito neste documento. A posse
deste documento não garante ao usuário nenhuma licença a essas patentes. Consultas sobre licença devem ser enviadas, por escrito, para:
IBM Director of Licensing
IBM Corporation
North Castle Drive, MD-NC119
Armonk, NY 10504-1785
Estados Unidos da América
O parágrafo a seguir não se aplica ao Reino Unido ou a qualquer outro país onde tais provisões sejam inconsistentes com a lei local: A
INTERNATIONAL BUSINESS MACHINES CORPORATION FORNECE ESTA PUBLICAÇÃO "NO ESTADO EM QUE SE ENCONTRA" SEM
GARANTIA DE NENHUMA ESPÉCIE, SEJA EXPRESSA OU IMPLÍCITA, O QUE INCLUI, MAS A ELAS NÃO SE LIMITA, GARANTIAS
SUBENTENDIDAS DE NÃO INFRAÇÃO, COMERCIALIZAÇÃO OU OPORTUNIDADE PARA UM PROPÓSITO PARTICULAR. Alguns estados
não permitem renúncia de responsabilidade de garantias expressas ou implícitas em determinadas transações; sendo assim, esta declaração
pode não se aplicar a você.
Esta informação pode conter imprecisões técnicas ou erros tipográficos. As informações deste documento são periodicamente mudadas; tais
mudanças serão incorporadas em novas edições da publicação. A IBM pode aprimorar e/ou mudar o(s) produto(s) e/ou programa(s) descritos
nesta publicação a qualquer momento, sem aviso prévio.
Todas as referências a websites não pertencentes à IBM, nesta publicação, são feitas por mera conveniência e não servem, de forma alguma,
como endosso desses websites. Os materiais destes websites não fazem parte dos materiais deste produto da IBM, e a sua utilização é
responsabilidade do cliente.
A IBM pode utilizar ou distribuir qualquer informação que você forneça, da maneira que considerar apropriada, sem que nenhuma obrigação
incorra a você. As informações referentes a produtos não IBM foram obtidas dos fornecedores desses produtos, seus anúncios publicados ou
outras fontes publicamente disponíveis. A IBM não testou esses produtos e não pode confirmar a exatidão de desempenho, a compatibilidade, ou
qualquer outra afirmação referente a produtos não IBM. As perguntas sobre os recursos de produtos não IBM devem ser endereçadas aos
fornecedores desses produtos.
Essas informações contêm exemplos de dados e relatórios usados em operações diárias de negócios. Para ilustrá-los da forma mais completa
possível, os exemplos incluem o nome de pessoas, empresas, marcas e produtos. Todos esses nomes são fictícios e qualquer similaridade a
nomes e endereços usados por empresas reais é mera coincidência.
MARCAS COMERCIAIS
IBM, o logotipo IBM e ibm.com, InfoSphere e DataStage são marcas comerciais ou marcas registradas da International Business Machines Corp.,
registradas em várias jurisdições no mundo todo. Outros nomes de produtos e serviços podem ser marcas comerciais da IBM ou de outras
empresas. Uma lista atual das marcas registradas da IBM está disponível na Web em "Copyright and trademark information" em
www.ibm.com/legal/copytrade.shtml.
Adobe e o logotipo da Adobe são marcas registradas ou marcas comerciais da Adobe Systems Incorporated nos Estados Unidos e/ou em outros
países.
Linux é uma marca registrada da Linus Torvalds nos Estados Unidos e/ou em outros países.
Microsoft, Windows e o logotipo do Windows são marcas comerciais da Microsoft Corporation nos Estados Unidos e/ou em outros países.
UNIX é uma marca registrada do The Open Group nos Estados Unidos e em outros países.
© Copyright International Business Machines Corporation 2015.
Este documento não pode ser reproduzido em sua totalidade ou em partes sem a permissão prévia por escrito da IBM.
Direitos restritos para usuários do governo dos EUA – Uso, duplicação ou divulgação restritos pelo documento GSA ADP Schedule Contract com a IBM
Corporation.
© Copyright IBM Corp. 2005, 2015 P-2

Os materiais do curso não podem ser reproduzidos na íntegra ou em parte sem a prévia permissão por escrito da IBM.
Prefácio
Conteúdo
Prefácio ............................................................................................................... P-1
Conteúdo............................................................................................................ P-3
Visão geral do curso ......................................................................................... P-14
Convenções do documento .............................................................................. P-15
Recursos de treinamento adicional .................................................................. P-16
Ajuda de produtos IBM ..................................................................................... P-17
Unidade 1 Introdução ao DataStage.............................................................. 1-1
Objetivos da unidade .......................................................................................... 1-3
O que é o IBM InfoSphere DataStage? .............................................................. 1-4
O que é o Information Server ............................................................................. 1-5
Backbone do Information Server ........................................................................ 1-6
Console da web do Information Server............................................................... 1-7
Arquitetura do DataStage ................................................................................... 1-8
DataStage Administrator .................................................................................... 1-9
DataStage Designer ......................................................................................... 1-10
DataStage Director ........................................................................................... 1-11
Desenvolvimento no DataStage ....................................................................... 1-12
Repositório do projeto do DataStage ................................................................ 1-13
Tipos de tarefas do DataStage ......................................................................... 1-14
Elementos de design de tarefas paralelas ........................................................ 1-15
Paralelismo de pipeline .................................................................................... 1-16
Paralelismo de partição .................................................................................... 1-17
Particionamento de três nós ............................................................................. 1-18
Design de tarefa versus execução ................................................................... 1-19
Arquivo de configuração ................................................................................... 1-20
Exemplo: Arquivo de configuração ................................................................... 1-21
Ponto de verificação ......................................................................................... 1-22
Soluções de ponto de verificação ..................................................................... 1-23
Resumo da unidade ......................................................................................... 1-24
Unidade 2 Implementação ............................................................................. 2-1
O que é implementado ....................................................................................... 2-4
Implementação: tudo em uma máquina.............................................................. 2-5
Implementação: DataStage em uma máquina separada .................................... 2-6
Servidor de metadados e DB2 em máquinas separadas .................................... 2-7
Inicialização do Information Server ..................................................................... 2-8
Início do Information Server no Windows ........................................................... 2-9
Início do Information Server no Linux ............................................................... 2-10

Prefácio
Verificação se o Information Server está em execução .................................... 2-11

Janela de login do console da web ................................................................... 2-12
Demonstração 1: Login no Information Server Administration Console ............ 2-15
Unidade 3 Administração do DataStage ....................................................... 3-1
Console da web do Information Server – administração..................................... 3-4
Janela de login do console da web ..................................................................... 3-5
Gerenciamento de usuário e grupo .................................................................... 3-6
Criação de um ID do usuário do DataStage ....................................................... 3-7
Atribuição de funções do DataStage .................................................................. 3-8
Credenciais do DataStage .................................................................................. 3-9
Mapeamento padrão das credenciais do DataStage ........................................ 3-10
Login no DataStage Administrator .................................................................... 3-11
Guia Projects do DataStage Administrator ....................................................... 3-12
Guia General do DataStage Administrator ....................................................... 3-13
Variáveis de ambiente ...................................................................................... 3-14
Variáveis de relatório do ambiente ................................................................... 3-15
Guia Permissions do DataStage Administrator ................................................. 3-16
Inclusão de usuários e grupos .......................................................................... 3-17
Especificação de função do DataStage ............................................................ 3-18
Guia Logs do DataStage Administrator ............................................................ 3-19
Guia Parallel do DataStage Administrator ........................................................ 3-20
Demonstração 1: Administração do DataStage ................................................ 3-23
Unidade 4 Trabalho com metadados ............................................................ 4-1
Login no Designer .............................................................................................. 4-4
Área de trabalho do Designer ............................................................................. 4-5
Janela Repository............................................................................................... 4-6
Importação e exportação .................................................................................... 4-7
Procedimento de exportação .............................................................................. 4-8
Janela Export ..................................................................................................... 4-9
Procedimento de importação ............................................................................ 4-10
Opções de importação ..................................................................................... 4-11
Metadados de origem e destino ....................................................................... 4-12

Prefácio
Procedimento de importação do arquivo sequencial ........................................ 4-13

Importação de metadados sequenciais ............................................................ 4-14
Janela de importação sequencial ..................................................................... 4-15
Especificação do formato ................................................................................. 4-16
Edição de nomes e tipos de coluna .................................................................. 4-17
Janela de propriedades estendidas .................................................................. 4-18
Definição de tabela no repositório .................................................................... 4-19
Demonstração 1: Importação e exportação de objetos do DataStage .............. 4-22
Demonstração 2: Importação de uma definição de tabela ................................ 4-27
Unidade 5 Criação de tarefas paralelas ........................................................ 5-1
O que é uma tarefa paralela? ............................................................................. 5-4
Visão geral do desenvolvimento de tarefa .......................................................... 5-5
Paleta de ferramentas ........................................................................................ 5-6
Inclusão de estágios e links ................................................................................ 5-7
Sequência de exemplo de criação de tarefa ....................................................... 5-8
Criação de uma nova tarefa paralela .................................................................. 5-9
Arraste de estágios e links da paleta ................................................................ 5-10
Renomeação de links e estágios ...................................................................... 5-11
Estágio Row Generator .................................................................................... 5-12
Dentro do estágio Row Generator .................................................................... 5-13
Guia Row Generator Columns.......................................................................... 5-14
Propriedades estendidas .................................................................................. 5-15
Estágio Peek .................................................................................................... 5-16
Propriedades do estágio Peek.......................................................................... 5-17
Parâmetros da tarefa ........................................................................................ 5-18
Definição de um parâmetro da tarefa ............................................................... 5-19
Uso de um parâmetro da tarefa em um estágio................................................ 5-20
Inclusão de documentação de tarefas .............................................................. 5-21
Documentação da janela Job Properties .......................................................... 5-22
Propriedades do estágio Annotation ................................................................. 5-23
Compilação e execução de uma tarefa ............................................................ 5-24
Mensagens de erros ou êxito ........................................................................... 5-25
DataStage Director ........................................................................................... 5-26
Opções de execução ........................................................................................ 5-27
Estatísticas de desempenho ............................................................................ 5-28
Visualização de status do Director ................................................................... 5-29
Log da tarefa, visualizada do Designer ............................................................. 5-30

Prefácio
Detalhes da mensagem.................................................................................... 5-31

Outras funções do log da tarefa ....................................................................... 5-32
Monitor do Director ........................................................................................... 5-33
Execução de tarefas da linha de comando ....................................................... 5-34
Conjuntos de parâmetros ................................................................................. 5-35
Criação de um conjunto de parâmetros ............................................................ 5-36
Definição dos parâmetros................................................................................. 5-37
Definição de arquivos de valores ...................................................................... 5-38
Carregamento de um conjunto de parâmetros para uma tarefa ....................... 5-39
Uso de parâmetros do conjunto de parâmetros ................................................ 5-40
Execução de tarefas com parâmetros do conjunto de parâmetros ................... 5-41
Demonstração 1: Criação de tarefas paralelas ................................................. 5-44
Unidade 6 Acesso a dados sequenciais ....................................................... 6-1
Como dados sequenciais são manipulados ....................................................... 6-4
Recursos do estágio Sequential File .................................................................. 6-5
Exemplo de formato de arquivo sequencial ........................................................ 6-6
Design de tarefa com estágios Sequential File ................................................... 6-7
Propriedades do estágio Sequential File ............................................................ 6-8
Guia Format ....................................................................................................... 6-9
Guia Columns................................................................................................... 6-10
Leitura de arquivos sequenciais usando um padrão do arquivo ....................... 6-11
Vários leitores................................................................................................... 6-12
Gravação em um arquivo sequencial ............................................................... 6-13
Links de rejeição .............................................................................................. 6-14
Links de rejeição de origem e destino .............................................................. 6-15
Configuração da propriedade Reject Mode ...................................................... 6-16
Estágio Copy .................................................................................................... 6-17
Exemplo de estágio Copy................................................................................. 6-18
Mapeamentos do estágio Copy ........................................................................ 6-19
Demonstração 1: Leitura e gravação em arquivos sequenciais ........................ 6-20
Trabalho com nulos .......................................................................................... 6-32
Especificação de um valor para nulo ................................................................ 6-33
Exemplo de sequência de caracteres vazia...................................................... 6-34
Visualização de dados com nulos .................................................................... 6-35
Demonstração 2: Leitura e gravação de valores nulos ..................................... 6-36
Estágio Data Set .............................................................................................. 6-43
Tarefa com um estágio Data Set de destino ..................................................... 6-44

Prefácio
Utilitário Data Set Management ........................................................................ 6-45

Dados e esquema exibidos .............................................................................. 6-46
Estágio File Set ................................................................................................ 6-47
Demonstração 3: Trabalho com conjuntos de dados ........................................ 6-48
Unidade 7 Algoritmos de particionamento e coleta ..................................... 7-1
Paralelismo de partição ...................................................................................... 7-4
Particionamento de estágio ................................................................................ 7-5
Ambientes de hardware do DataStage ............................................................... 7-6
Algoritmos de particionamento ........................................................................... 7-7
Coleta ................................................................................................................. 7-8
Coleta de algoritmos ........................................................................................ 7-10
Algoritmos de particionamento sem chave versus com chave .......................... 7-11
Particionamento Round Robin e Random ........................................................ 7-12
Particionamento Entire ..................................................................................... 7-13
Particionamento Hash ...................................................................................... 7-14
Particionamento Modulus ................................................................................. 7-15
Particionamento Auto ....................................................................................... 7-16
Requisitos de particionamento para registros relacionados .............................. 7-17
Exemplo de desbalanceamentos de partição ................................................... 7-18
Ícones do link de particionamento/coleta .......................................................... 7-19
Mais ícones de particionamento ....................................................................... 7-20
Especificação de um algoritmo de particionamento .......................................... 7-21
Especificação de um algoritmo de coleta ......................................................... 7-22
Arquivo de configuração ................................................................................... 7-23
Exemplo de arquivo de configuração................................................................ 7-24
Inclusão de $APT_CONFIG_FILE como um parâmetro da tarefa .................... 7-25
Edição dos arquivos de configuração ............................................................... 7-26
Compilação de tarefa paralela .......................................................................... 7-27
OSH gerado ..................................................................................................... 7-28
Exemplos do mapeamento de estágio a operador ........................................... 7-29
Pontuação da tarefa ......................................................................................... 7-30
Visualização da pontuação ............................................................................... 7-31
Demonstração 1: Particionamento e coleta ...................................................... 7-34

Prefácio
Unidade 8 Combinação de dados.................................................................. 8-1

Combinação de dados........................................................................................ 8-4
Estágios Lookup, Join, Merge ............................................................................ 8-5
Recursos do estágio Lookup .............................................................................. 8-6
Tipos de consulta ............................................................................................... 8-7
Exemplo do estágio Lookup com correspondência de igualdade ....................... 8-8
Estágio Lookup com uma correspondência de igualdade ................................... 8-9
Definição da chave de consulta ........................................................................ 8-10
Especificação das colunas de saída ................................................................. 8-11
Ações de falha de consulta .............................................................................. 8-12
Especificação de ações de falha de consulta ................................................... 8-13
Estágio Lookup com link de rejeição ................................................................ 8-14
Comportamento do estágio Lookup .................................................................. 8-15
Saída do estágio Lookup .................................................................................. 8-16
Demonstração 1: Uso do estágio Lookup ......................................................... 8-17
Tarefa do estágio Range Lookup ..................................................................... 8-26
Intervalo no link de referência........................................................................... 8-27
Seleção da coluna de fluxo .............................................................................. 8-28
Editor de expressão de intervalo ...................................................................... 8-29
Intervalo no link de fluxo ................................................................................... 8-30
Especificação da consulta de intervalo ............................................................. 8-31
Editor de expressão de intervalo ...................................................................... 8-32
Demonstração 2: Consultas de intervalo .......................................................... 8-33
Estágio Join...................................................................................................... 8-39
Tarefa com estágio Join ................................................................................... 8-40
Propriedades do estágio Join ........................................................................... 8-41
Guia Output Mapping ....................................................................................... 8-42
Comportamento do estágio Join ....................................................................... 8-43
Saída da junção interna.................................................................................... 8-44
Saída da junção externa esquerda ................................................................... 8-45
Saída da junção externa direita ........................................................................ 8-46
Junção externa integral .................................................................................... 8-47
Estágio Merge .................................................................................................. 8-48
Tarefa do estágio Merge .................................................................................. 8-49
Propriedades do estágio Merge........................................................................ 8-50
Gráfico de comparação .................................................................................... 8-51
O que é um estágio Funnel? ............................................................................ 8-52
Exemplo do estágio Funnel .............................................................................. 8-53
Propriedades do estágio Funnel ....................................................................... 8-54

Prefácio

Demonstração 3: Uso dos estágios Join, Merge e Funnel ................................ 8-57
Unidade 9 Estágios de processamento de grupo ........................................ 9-1
Estágios de processamento de grupo ................................................................ 9-4
Classificação de dados....................................................................................... 9-5
Alternativas de classificação .............................................................................. 9-6
Classificação em estágio .................................................................................... 9-7
Ilustração de classificação estável ..................................................................... 9-8
Guia Properties do estágio Sort.......................................................................... 9-9
Especificação de chaves de classificação ........................................................ 9-10
Opções do estágio Sort .................................................................................... 9-11
Criação de coluna de mudança de chave ......................................................... 9-12
Classificações da partição ................................................................................ 9-13
Estágio Aggregator........................................................................................... 9-14
Tarefa com estágio Aggregator ........................................................................ 9-15
Tipos de agregação .......................................................................................... 9-16
Tipo de agregação Count Rows ....................................................................... 9-17
Guia Output Mapping ....................................................................................... 9-18
Guia Output Columns ....................................................................................... 9-19
Tipo de agregação Calculation ......................................................................... 9-20
Métodos de agrupamento ................................................................................. 9-21
Method = Hash ................................................................................................. 9-22
Method = Sort................................................................................................... 9-23
Remoção de duplicatas .................................................................................... 9-24
Tarefa do estágio Remove Duplicates .............................................................. 9-25
Propriedades do estágio Remove Duplicates ................................................... 9-26
Demonstração 1: Estágios de processamento de grupo .................................. 9-29
Design de tarefa de bifurcação-junção ............................................................. 9-39
Unidade 10 Estágio Transformer ................................................................... 10-1
Objetivos da unidade ........................................................................................ 10-3
Estágio Transformer ......................................................................................... 10-4
Tarefa com um estágio Transformer................................................................. 10-5
Por dentro do estágio Transformer ................................................................... 10-6
Elementos do estágio Transformer ................................................................... 10-7

Prefácio
Restrições ........................................................................................................ 10-9

Exemplo de restrições .................................................................................... 10-10
Definição de uma restrição ............................................................................. 10-11
Utilização do editor de expressão ................................................................... 10-12
Links Otherwise para integridade de dados .................................................... 10-13
Exemplo de link Otherwise ............................................................................. 10-14
Especificação da ordenação do link ............................................................... 10-15
Especificação da restrição do link Otherwise.................................................. 10-16
Demonstração 1: Definição de uma restrição ................................................. 10-17
Derivações ..................................................................................................... 10-24
Destinos de derivação .................................................................................... 10-25
Variáveis de estágio ....................................................................................... 10-26
Definições da variável de estágio ................................................................... 10-27
Criação de uma derivação .............................................................................. 10-28
Definição de uma derivação ........................................................................... 10-29
Derivação IF THEN ELSE .............................................................................. 10-30
Funções de sequência de caracteres e operadores ....................................... 10-31
Manipulação de nulo ...................................................................................... 10-32
Nulos não manipulados .................................................................................. 10-33
Processamento de nulo anterior ..................................................................... 10-34
Link de rejeição do estágio Transformer ......................................................... 10-35
Demonstração 2: Definir derivações ............................................................... 10-36
Processamento de loop .................................................................................. 10-44
Funções usadas no processamento de loop .................................................. 10-45
Exemplo de processamento de loop .............................................................. 10-46
Tarefa de exemplo de processamento de loop ............................................... 10-47
Por dentro do estágio Transformer ................................................................. 10-48
Demonstração 3: Processamento de loop ...................................................... 10-49
Processamento de grupo ............................................................................... 10-55
Exemplo de processamento de grupo ............................................................ 10-56
Resultados da tarefa ...................................................................................... 10-57
Lógica do Transformer ................................................................................... 10-58
Loop através de linhas de entrada salvas ...................................................... 10-59
Resultados da tarefa de exemplo ................................................................... 10-60
Lógica do Transformer ................................................................................... 10-61
Depurador de tarefa paralela .......................................................................... 10-62
Definição de pontos de interrupção ................................................................ 10-63
Edição de pontos de interrupção .................................................................... 10-64
Execução de uma tarefa paralela no depurador ............................................. 10-65
Inclusão de colunas na lista de observação ................................................... 10-66

Prefácio
Demonstração 4: Processamento de grupo em um Transformer ................... 10-67

Ponto de verificação ....................................................................................... 10-85
Soluções de ponto de verificação ................................................................... 10-86
Resumo da unidade ....................................................................................... 10-87
Unidade 11 Funções de repositório .............................................................. 11-1
Busca rápida .................................................................................................... 11-4
Resultados localizados ..................................................................................... 11-5
Janela Advanced Find ...................................................................................... 11-6
Opções Advanced Find .................................................................................... 11-7
Uso dos resultados localizados ........................................................................ 11-8
Realização de uma análise de impacto ............................................................ 11-9
Início de uma análise de impacto ................................................................... 11-10
Resultados no formato de texto ...................................................................... 11-11
Resultados no formato gráfico ........................................................................ 11-12
Exibição do gráfico de dependência ............................................................... 11-13
Exibição do caminho de dependência ............................................................ 11-14
Geração de um relatório HTML ...................................................................... 11-15
Visualização do fluxo de dados no nível da coluna ........................................ 11-16
Localização da origem de uma coluna ........................................................... 11-17
Resultados exibidos ....................................................................................... 11-18
Descoberta da diferença entre duas tarefas ................................................... 11-19
Início da comparação ..................................................................................... 11-20
Resultados da comparação ............................................................................ 11-21
Salvamento em um arquivo HTML ................................................................. 11-22
Comparação de definições de tabela ............................................................. 11-23
Demonstração 1: Funções de repositório ....................................................... 11-26
Unidade 12 Trabalho com dados relacionais ............................................... 12-1
Importação de definições de tabela relacional .................................................. 12-4
Importação do esquema Orchestrate ............................................................... 12-5
Importação do ODBC ....................................................................................... 12-6
Estágios Connector .......................................................................................... 12-7
Leitura de tabelas do banco de dados .............................................................. 12-8
GUI do estágio Connector ................................................................................ 12-9
Painel Navigation ........................................................................................... 12-10
Propriedades da conexão ............................................................................... 12-11

Prefácio
Propriedades de uso – Generate SQL............................................................ 12-12

Propriedades de uso – transação ................................................................... 12-13
Propriedades de uso – Session e Before / After SQL ..................................... 12-14
Gravação em tabelas de banco de dados ...................................................... 12-15
GUI do DB2 Connector................................................................................... 12-16
Propriedades de gravação do Connector ....................................................... 12-17
Objetos de conexão de dados ........................................................................ 12-18
Objetos de conexão de dados ........................................................................ 12-19
Criação de um novo objeto de conexão de dados .......................................... 12-20
Carregamento da conexão de dados.............................................................. 12-21
Demonstração 1: Leitura e gravação em tabelas relacionais.......................... 12-22
Vários links de entrada ................................................................................... 12-32
Tarefa com vários links de entrada e links de rejeição ................................... 12-33
Especificação das propriedades do link de entrada ........................................ 12-34
Propriedade Record ordering ......................................................................... 12-35
Especificação do link de rejeição .................................................................... 12-36
Demonstração 2: Estágios Connector com vários links de entrada ................ 12-37
SQL Builder .................................................................................................... 12-49
Guia Locator da definição de tabela ............................................................... 12-50
Abertura do SQL Builder ................................................................................ 12-51
Janela SQL Builder ........................................................................................ 12-52
Criação de uma coluna calculada ................................................................... 12-53
Construção de uma cláusula WHERE ............................................................ 12-54
Classificação dos dados ................................................................................. 12-55
Visualização do SQL gerado .......................................................................... 12-56
Demonstração 3: Construção de SQL usando o SQL Builder ........................ 12-59
Unidade 13 Controle da tarefa ....................................................................... 13-1
O que é uma sequência de tarefas? ................................................................. 13-4
Fundamentos para criar uma sequência de tarefas .......................................... 13-5
Estágios de sequência de tarefas ..................................................................... 13-6
Exemplo de sequência de tarefas .................................................................... 13-7
Propriedades de sequência de tarefas ............................................................. 13-8
Propriedades do estágio Job Activity ................................................................ 13-9
Acionador do Job Activity ............................................................................... 13-10
Estágio Execute Command ............................................................................ 13-11
Estágio Notification Activity ............................................................................ 13-12
Estágio User Variables ................................................................................... 13-13

Prefácio
Referência à variável de usuário .................................................................... 13-14

Estágio Wait for File ....................................................................................... 13-15
Estágio Sequencer ......................................................................................... 13-16
Estágio Nested Condition ............................................................................... 13-17
Estágios de loop ............................................................................................. 13-18
Manipulação de atividades que falham........................................................... 13-19
Estágio Exception Handler ............................................................................. 13-20
Ativação da reinicialização ............................................................................. 13-21
Desativação do ponto de verificação para um estágio.................................... 13-22
Demonstração 1: Compilação e execução de uma sequência de tarefas ....... 13-25

Prefácio
Visão geral do curso

Visão geral do prefácio
Este curso habilita os administradores de projeto e desenvolvedores de ETL a adquirir
as qualificações necessárias para desenvolver tarefas paralelas no DataStage. A
ênfase está nos desenvolvedores. Somente funções administrativas relevantes aos
desenvolvedores do DataStage são discutidas integralmente. Os alunos aprenderão a
criar tarefas paralelas que acessam dados sequenciais e relacionais, e que combinam
e transformam os dados usando funções e outros componentes de tarefa.
Público-alvo
Administradores do projeto e desenvolvedores de ETL responsáveis pela extração e a
transformação de dados usando o DataStage.
Tópicos abordados
Os tópicos abordados neste curso incluem:
 Introdução ao DataStage
 Implementação
 Administração do DataStage
 Trabalho com metadados
 Criação de tarefas paralelas
 Acesso a dados sequenciais
 Algoritmos de particionamento e coleta
 Combinação de dados
 Estágios de processamento de grupo
 Estágio Transformer
 Funções de repositório
 Trabalho com dados relacionais
 Controle de tarefas
Pré-requisitos do curso
Os participantes devem ter:
 Não há pré-requisitos

Prefácio
Convenções do documento
As convenções usadas neste guia seguem os padrões do aplicativo Microsoft
Windows, onde aplicável. Além disso, as seguintes convenções são observadas:
 Negrito: O negrito é usado em soluções passo a passo de demonstrações e
exercícios para indicar um elemento de interface do usuário que está
selecionado ativamente ou um texto que deve ser digitado pelo participante.
 Itálico: Usado para fazer referência a títulos de manuais.
 LETRAS MAIÚSCULAS E MINÚSCULAS: Todos os nomes de arquivos, de
tabelas, de colunas e de pastas aparecem neste guia exatamente da mesma
forma que aparecem no aplicativo.
Para manter as letras maiúsculas e minúsculas consistentes com este guia,
digite o texto exatamente conforme mostrado.

Prefácio
Recursos de treinamento adicional

 Acesse IBM Analytics Product Training and Certification no website da IBM para
obter detalhes sobre:
 Treinamentos ministrados por instrutores em sala de aula ou on-line
 Treinamentos no seu próprio ritmo que se ajustam às suas necessidades e
agenda
 Caminhos de treinamento e programas curriculares abrangentes que o
ajudam a identificar os cursos que são adequados para você
 Programa de certificação IBM Analytics
 Outros recursos que aumentarão o seu sucesso com o software IBM
Analytics
 Para a URL relevante para seus requisitos de treinamento descritos acima,
marque:
 Portfólio do Information Management:
http://www-01.ibm.com/software/data/education/

Prefácio
Ajuda de produtos IBM

Tipo de Quando usar Localização
ajuda
Orientada à Você está trabalhando no produto e Produto IBM - Link de ajuda

tarefa precisa de ajuda específica
orientada à tarefa.
Manuais Você deseja usar mecanismos de Start/Programs/IBM

para procura para localizar informações. Product/Documentation
impressão É possível imprimir páginas
(.pdf) selecionadas, uma seção ou o
manual inteiro.
Use os manuais on-line de passo a
passo (.pdf) se desejar saber como
concluir uma tarefa, mas preferir ler
sobre como fazer isso em um
manual.
Os manuais on-line de passo a
passo contêm as mesmas
informações que a ajuda on-line,
mas o método de apresentação é
diferente.
IBM na Web Você deseja acessar algum dos

itens a seguir:
 IBM - Treinamento e certificação  http://www-01.ibm.com/
software/analytics/training-
and-certification/
 Suporte on-line  http://www-947.ibm.com/
support/entry/portal/
Overview/Software
 Website IBM  http://www.ibm.com

Prefácio

Unidade 1 Introdução ao DataStage
Introdução ao DataStage
IBM InfoSphere DataStage v11.5
© Copyright IBM Corporation 2015

Os materiais do curso não podem ser reproduzidos na íntegra ou em parte sem a permissão por escrito da IBM.
© Copyright IBM Corp. 2005, 2015 1-2

Objetivos da unidade
• Listar e descrever os usos do DataStage
• Listar e descrever os clientes do DataStage
• Descrever o fluxo de trabalho do DataStage
• Descrever os dois tipos de paralelismos exibidos pelas tarefas
paralelas do DataStage
Introdução ao DataStage © Copyright IBM Corporation 2015

O que é o IBM InfoSphere DataStage?

• Projete tarefas para Extraction, Transformation e Loading (ETL)
• Ferramenta ideal para projetos de integração de dados, como data
warehouses, data marts e migrações do sistema
• Importe, exporte, crie e gerencie metadados para uso dentro de tarefas
• Compile, execute e monitore tarefas, tudo dentro do DataStage
• Administre os ambientes de desenvolvimento e execução do DataStage
• Crie tarefas (controle) em lote
 Sequência de tarefas chamada
O que é o IBM InfoSphere DataStage?

O DataStage é uma ferramenta abrangente para criação e manutenção rápidas e
fáceis de data marts e data warehouses. Ele fornece as ferramentas necessárias para
compilá-los, gerenciá-los e expandi-los. Com o DataStage, é possível criar soluções
com mais rapidez e dar aos usuários acesso aos dados e relatórios de que eles
precisam.
Com o DataStage, é possível projetar tarefas que extraem, integram, agregam,
carregam e transformam os dados para o seu data warehouse ou data mart. Para
facilitar seu desenvolvimento, é possível criar e reutilizar componentes da tarefa e
metadados. Depois de compilar a tarefa do DataStage, é possível executar, monitorar
e planejar essa tarefa.

O que é o Information Server?

• Conjunto de aplicativos, incluindo o DataStage, que compartilham um:
 Repositório
 Conjunto de serviços e funcionalidades de aplicativos
− Fornecido pelo componente de servidor de metadados
• Por padrão, um aplicativo chamado "server1", hospedado por uma
instância do IBM WebSphere Application Server (WAS)
− Os serviços fornecidos incluem:
• Segurança
• Repositório
• Criação de log e relatório
• Gerenciamento de metadados
• Gerenciado usando o cliente do console da web do Information
Server
O que é o Information Server

O Information Server (IS) é um conjunto de aplicativos que compartilham o mesmo
repositório e o mesmo backbone de serviços e funcionalidades. Ele é gerenciado
usando clientes do console da web. Aplicativos individuais são gerenciados usando o
próprio conjunto de clientes.
O backbone dos serviços é fornecido por uma instância do WebSphere Application
Server (WAS) que, por padrão, se chama server1. Todos os aplicativos e componentes
individuais no conjunto Information Server usam esses serviços.

Backbone do Information Server
Information Information Information FastTrack DataStage / MetaBrokers

Data Click
Services Governance Analyzer QualityStage
Director Catalog
Metadados Metadados
Serviços de acesso Analysis Services
Servidor de metadados
Repositório
Console da web do Information Server
Backbone do Information Server

Este gráfico mostra o backbone do Information Server. Os aplicativos hospedados
estão na parte superior. Todos eles compartilham os mesmos serviços exibidos no
centro. Todos eles compartilham o mesmo repositório exibido no canto inferior direito.
Eles são gerenciados usando o console da web do Information Server, bem como seus
clientes individuais.
Embora o DataStage e o QualityStage sejam produtos separados com licenças
separadas, o QualityStage está, na verdade, integrado no DataStage como um
conjunto de estágios.

Administração Relatório
Usuários do
InfoSphere

Este gráfico mostra o console de administração do Information Server. Clique na guia
Administration para executar as funções administrativas do Information Server. É
mostrada a pasta em que os IDs do usuário do DataStage são criados. Uma função de
administração do Information Server é necessária para criar IDs do usuário para
qualquer um dos produtos do Information Server.
Também é mostrada a guia Reporting. Os usuários do DataStage podem efetuar login
e criar relatórios usando um dos modelos de relatório do DataStage fornecidos.

Arquitetura do DataStage
• Clientes do DataStage
Administrator Designer Director
• Mecanismos do DataStage
 Mecanismo paralelo
− Executa tarefas paralelas
 Mecanismo de servidor
− Executa tarefas do servidor
− Executa sequências de tarefas
Arquitetura do DataStage
A metade superior exibe os clientes do DataStage. Na metade inferior, há dois
mecanismos. O mecanismo paralelo executa tarefas paralelas do DataStage. O
mecanismo de servidor executa tarefas do servidor do DataStage e sequências de
tarefas. Nosso foco neste curso está nas tarefas paralelas e na sequência de tarefas.
Os clientes do DataStage são:
Administrator
Configura os projetos do DataStage e especifica as funções de usuário do DataStage.
Designer
Cria tarefas do DataStage que são compiladas em programas executáveis.
Director
Utilizado para executar e monitorar as tarefas do DataStage, embora isso também
possa ser feito no Designer.

DataStage Administrator
Variáveis de
ambiente do projeto
DataStage Administrator
Use o cliente do Administrator para especificar os padrões gerais do servidor, incluir e
excluir projetos e definir os padrões e as propriedades do projeto.
Na guia General, você tem acesso às variáveis de ambiente do projeto. Na guia
Permissions, especifique as funções de usuário do DataStage. Na guia Parallel,
especifique os padrões gerais para tarefas paralelas. Na guia Sequence, especifique
os padrões para sequências de tarefas. Na guia Logs, especifique os padrões para o
log da tarefa.
Uma função de administrador do DataStage, definida no console da web do
Information Server, tem autorização integral para trabalhar no cliente do DataStage
Administrator.

DataStage Designer
Menus/barra de ferramentas
Tarefa paralela do
DataStage com o estágio
DB2 Connector
Log da tarefa
DataStage Designer
O DataStage Designer é onde você compila suas tarefas ETL (Extraction,
Transformation, Load). Você compila uma tarefa arrastando estágios da Palette (canto
inferior esquerdo) para a tela. Você traça links entre os estágios para especificar o fluxo
de dados. Neste exemplo, um estágio Sequential File é utilizado para ler dados de um
arquivo sequencial. Os dados fluem para um estágio Transformer, em que várias
transformações são executadas. Então, os dados são gravados em tabelas do DB2 de
destino com base em restrições definidas no Transformer e especificadas para SQL no
estágio DB2 Connector.
Os links que saem do estágio DB2 Connector são links de rejeição que capturam erros
de SQL.

DataStage Director
Mensagens de
log
DataStage Director
Conforme sua tarefa é executada, as mensagens são gravadas no log. Essas
mensagens exibem informações sobre erros e avisos, informações sobre o ambiente
em que a tarefa está em execução, estatísticas sobre os números de linhas
processadas por diversos estágios e muito mais.
O gráfico mostra o log da tarefa exibido no cliente do Director. Para tarefas individuais
abertas no Designer, o log da tarefa também pode ser exibido no Designer.

Desenvolvimento no DataStage
• Definir propriedades globais e do projeto no Administrator
• Importar metadados para o repositório
 Especifica formatos de origens e destinos acessados pelas suas tarefas
• Criar tarefa no Designer
• Compilar tarefa no Designer
• Executar a tarefa e monitorar as mensagens de log da tarefa
 O log da tarefa pode ser visualizado no Director ou no Designer
− No Designer, apenas o log da tarefa para a tarefa aberta no momento está
disponível
 É possível executar as tarefas no Director, no Designer ou na linha de
comandos
 As estatísticas de desempenho aparecem no log e também na tela do
Designer conforme a tarefa é executada
Desenvolvimento no DataStage
Fluxo de trabalho de desenvolvimento: defina as propriedades do seu projeto no
Administrator. Importe os metadados que definem o formato dos dados de que suas
tarefas lerão ou em que gravarão. No Designer, compile a tarefa. Defina as extrações
de dados (leituras). Defina os fluxos de dados. Defina as combinações de dados, as
transformações de dados, as restrições de dados, as agregações de dados e os
carregamentos de dados (gravações).
Depois de construir sua tarefa, compile-a no Designer. Então, é possível executar e
monitorar a tarefa, seja no Designer ou no Director.

Repositório do projeto do DataStage
Pasta incluída pelo

usuário
Pasta de tarefas padrão
Pasta de definições
da tabela padrão
Repositório do projeto do DataStage

Todo o seu trabalho é armazenado em um projeto do DataStage. Antes de poder
realizar qualquer ação que não administração geral, é preciso abrir (anexar a) um
projeto.
Os projetos são criados durante e depois do processo de instalação. É possível incluir
projetos após a instalação na guia Projects do Administrator.
Um projeto é associado a um diretório. O diretório de projeto é utilizado pelo DataStage
para armazenar suas tarefas e outros metadados e objetos do DataStage no sistema
de servidor do DataStage.
Os projetos são autocontidos. Embora seja possível abrir diversos projetos ao mesmo
tempo, eles são ambientes separados. No entanto, é possível importar e exportar
objetos entre eles.
Vários usuários podem trabalhar no mesmo projeto ao mesmo tempo. Contudo, o
DataStage impedirá que vários usuários editem o mesmo objeto do DataStage (tarefa,
definição de tabela e assim por diante) ao mesmo tempo.

Tipos de tarefas do DataStage

• Tarefas paralelas
 Executadas pelo mecanismo paralelo do DataStage
 Capacidade integrada para pipeline e paralelismo de partição
 Compilado no OSH
− Script executável visualizável no Designer e no log
• Tarefas do servidor
 Executadas pelo mecanismo de servidor do DataStage
 Use um conjunto de estágios diferente de tarefas paralelas
 Não há capacidade integrada para paralelismo de partição
 Monitoramento de tempo de execução no log da tarefa
• Sequências de tarefas (tarefas em lote, tarefas de controle)
 Uma tarefa do servidor que executa e controla tarefas e outras atividades
 Pode executar tarefas paralelas e outras sequências de tarefas
 Fornece uma interface comum para o conjunto de tarefas que controla
Tipos de tarefas do DataStage

Este curso foca em tarefas paralelas e sequências de tarefas que controlam lotes de
tarefas. Porém, esses não são os únicos tipos de tarefas que podem ser criados no
DataStage. Cada tipo de tarefa tem a própria tela e conjunto de estágios.
A principal diferença entre tarefas paralelas e de servidor do DataStage é o mecanismo
utilizado para executá-las. As tarefas paralelas do DataStage são executadas usando o
mecanismo paralelo. As tarefas paralelas podem atingir um desempenho muito alto
usando a capacidade do mecanismo para pipeline e paralelismo de partição.

Elementos de design de tarefas paralelas

• Estágios
 Estágios passivos (E e L do ETL)
− Leitura de dados
− Gravação de dados
− Exemplos: Arquivo sequencial, DB2 Oracle, estágios Peek
 Estágios de processador (ativo) (T do ETL)
− Transformar dados (estágio Transformer)
− Filtrar dados (estágio Transformer)
− Agregar dados (estágio Aggregator)
− Gerar dados (estágio Row Generator)
− Mesclar dados (estágios Join, Lookup)
• Links
 "Canos" através dos quais os dados se movem de estágio para estágio
Elementos de design de tarefas paralelas

Você projeta sua tarefa paralela do DataStage usando estágios e links. Os links são
como canais através dos quais os dados fluem. Há duas categorias de estágios. Os
estágios passivos são usados para ler e gravar em origens de dados. Os estágios de
processador (ativos) são usados para executar algum tipo de operação nos dados.
Há muitos tipos diferentes de estágios ativos. Muitos executam funções muito
específicas, como classificação, filtragem e junção de dados. Outros contêm grandes
quantias de funcionalidade, como os estágios Transformer e XML.

Paralelismo de pipeline
Registra de 9.001 1.000 registros em cada segmento
a 100.000.000 8º segmento 7º 6º 5º 4º 3º 2º 1º segmento
Dados operacionais TRANSFORM ENRICH LOAD Data

Dados arquivados Warehouse
Origem Destino
• Os estágios Transform, Enrich, Load são executados em paralelo

• Como uma esteira transportadora movendo linhas de estágio a estágio
 Executa estágios de recebimento de dados enquanto os estágios de envio
de dados estão em execução
• Vantagens:
 Reduz o uso do disco para áreas de preparação
 Mantém os processadores ocupados
• Tem limites de escalabilidade
Paralelismo de pipeline
Nesse diagrama, as setas representam linhas de fluxos de dados através da tarefa.
Enquanto as linhas anteriores estão no processo de carregamento, as linhas mais
novas estão passando pelos processos de transformação e enriquecimento. Dessa
forma, diversas linhas (sete, na imagem) estão sendo processadas ao mesmo tempo,
em paralelo.
Embora o paralelismo de pipeline melhore o desempenho, há limites à sua
escalabilidade.

Paralelismo de partição
• Divida o fluxo de entrada de dados em subconjuntos a serem
processados separadamente por uma operação
 Subconjuntos são chamados partições
• Cada partição de dados é processada por cópias do mesmo estágio
 Por exemplo, se o estágio for Filter, cada partição será filtrada exatamente
da mesma maneira
• Facilita a escalabilidade quase linear
 8 vezes mais rápido em 8 processadores
 24 vezes mais rápido em 24 processadores
 Presume que os dados são distribuídos uniformemente
O particionamento divide um fluxo de dados em subconjuntos menores. Esse é um
segredo da escalabilidade. No entanto, os dados precisam ser distribuídos
uniformemente pelas partições; de outra forma, os benefícios da partição serão
reduzidos.
É importante notar que o que é feito em cada partição de dados é igual. A maneira
como os dados são processados ou transformados é a mesma. Na verdade, cópias de
cada estágio ou operador estão em execução ao mesmo tempo, e em separado, em
cada partição de dados.
Para aumentar a capacidade de desempenho, é possível aumentar o número de
partições (presumindo que seu sistema de computador tenha processadores para
isso).

Particionamento de três nós

Nó 1
subconjunto 1
Estágio
Nó 2
subconjunto 2
Dados Estágio
Nó 3
subconjunto 3
Estágio
• Aqui os dados são divididos em três partições (nós)

• O estágio é executado em cada partição de dados separadamente e em
paralelo
• Se os dados forem distribuídos uniformemente, os dados serão
processados três vezes mais rápido
Particionamento de três nós

Este diagrama mostra como o paralelismo de partição é implementado no DataStage.
Os dados são divididos em vários fluxos de dados que são processados
separadamente pelo mesmo estágio ou operador.

Design de tarefa versus execução
Um desenvolvedor projeta o fluxo no DataStage Designer
... no tempo de execução, essa tarefa é executada em paralelo

para qualquer número de partições (nós)
Design de tarefa versus execução

Grande parte do paradigma de processamento paralelo fica oculta do designer. O
designer simplesmente diagrama o fluxo do processo, como mostra a parte superior
deste diagrama. O mecanismo paralelo, utilizando definições em um arquivo de
configuração, realmente executará processos que estão particionados e paralelos,
como ilustrado na parte inferior.
Uma característica enganosa do diagrama inferior é que ele faz parecer que os dados
permanecem na mesma partição durante toda a tarefa. Na verdade, o particionamento
e o reparticionamento ocorrem estágio a estágio. Haverá momentos em que os dados
se moverão de uma partição para outra.

Arquivo de configuração
• Determina o grau de paralelismo (número de partições) das tarefas
que o utilizam
• Cada tarefa é executada sob um arquivo de configuração
• Cada projeto do DataStage tem um arquivo de configuração padrão
 Especificado pelo parâmetro da tarefa $APT_CONFIG_FILE
 Tarefas individuais podem ser executadas sob arquivos de configuração
diferentes do padrão do projeto
−A mesma tarefa também pode ser executada usando diferentes arquivos de
configuração em diferentes execuções de tarefa
O arquivo de configuração determina o grau de paralelismo (número de partições) de
tarefas que a usam. Cada tarefa é executada de acordo com um arquivo de
configuração. O arquivo de configuração é especificado pela variável de ambiente
$APT_CONFIG_FILE. Essa variável de ambiente pode ser incluída à tarefa como um
parâmetro da tarefa. Isso possibilita que a tarefa use diferentes arquivos de
configuração em diferentes execuções da tarefa.

Exemplo: Arquivo de configuração
Nó (partição)
Nó (partição)
Recursos anexados
ao nó
Exemplo: Arquivo de configuração

Aqui você vê um arquivo de configuração, visualizado no editor Configurations do
Designer. Neste exemplo, há dois nós (partições). Qualquer tarefa em execução neste
arquivo de configuração processará os dados em duas partições paralelas.
Além de especificar o número de partições, o arquivo de configuração também
especifica os recursos utilizados por estágios e operadores em execução na partição.
Por exemplo, o disco utilizável é o disco usado para classificação quando a memória
está esgotada.

Ponto de verificação
1. Verdadeiro ou falso: o DataStage Director é usado para construir e
compilar as tarefas ETL
2. Verdadeiro ou falso: use o Designer para monitorar sua tarefa
durante a execução
3. Verdadeiro ou falso: o Administrator é usado para definir
propriedades do projeto e globais

Soluções de ponto de verificação

1. Falso.
O DataStage Designer é usado para construir e compilar
tarefas.
Use o DataStage Director para executar e monitorar tarefas.
Isso também pode ser feito usando o DataStage Designer.
2. Verdadeiro.
O log da tarefa está disponível tanto no Director quanto no
Designer. No Designer, é possível somente visualizar as
mensagens de log para uma tarefa aberta no Designer.
3. Verdadeiro.

Resumo da unidade
• Listar e descrever os usos do DataStage
• Listar e descrever os clientes do DataStage
• Descrever o fluxo de trabalho do DataStage
• Descrever os dois tipos de paralelismo exibidos pelas tarefas
paralelas do DataStage
Resumo da unidade

Unidade 2 Implementação
Implementação


• Identificar os componentes do Information Server que precisam ser
instalados
• Descrever em que consiste um domínio de implementação
• Descrever diferentes opções de implementação de domínio
• Descrever o processo de instalação
• Iniciar o Information Server
Implementação © Copyright IBM Corporation 2015
Nesta unidade, veremos como o DataStage é implementado. A implementação é um
pouco complexa porque o DataStage agora é um componente entre muitos.

O que é implementado
Um domínio do Information Server, consistindo no seguinte:
• Backbone do servidor de metadados, hospedado por uma instância do
IBM WebSphere Application Server (WAS)
• Um ou mais servidores do DataStage
 Pode estar no mesmo sistema ou em sistemas separados
• Uma instância do gerenciador de banco de dados contendo o banco
de dados do repositório (XMETA)
• Clientes do Information Server
 Console da web
 Clientes do DataStage
• Produtos adicionais do Information Server
 Information Analyzer, Information Governance Catalog,
 QualityStage (parte do DataStage), Data Click, FastTrack
O que é implementado
Aqui está uma lista dos diferentes componentes que são implementados, incluindo
uma instância do IBM WebSphere Application Server (WAS), uma instância do
gerenciador de banco de dados contendo o repositório do Information Server
(XMETA), um ou mais servidores do DataStage e os vários clientes e aplicativos do
componente.
Muitos desses componentes diferentes podem estar em sistemas de computador
diferentes.

Implementação: tudo em uma máquina

• Todos os componentes do
Information Server em um
sistema Backbone do servidor
de metadados (WAS)
• Estações de trabalho do
cliente adicionais podem se Clientes
conectar a essa máquina
Servidor do
Clientes DataStage
Repositório XMETA
Implementação: tudo em uma máquina

O Information Server está disponível para uma variedade de plataformas Windows e
Unix, mas não pode ser misturado (exceto para os clientes).
Os clientes do DataStage são executados somente no Windows. Se o Information
Server estiver instalado em uma plataforma UNIX, os clientes do DataStage deverão
ser executados em um sistema Windows separado.
Vários servidores do DataStage podem ser executados no mesmo sistema ou em
sistemas separados no mesmo domínio. Para simplificar, mostramos apenas um
servidor do DataStage.
Outra complexidade não mostrada aqui é que as tarefas paralelas do DataStage
podem, em determinados ambientes de grade, ser distribuídas entre vários sistemas.

Implementação: DataStage em uma máquina separada
• Componentes do IS em
vários sistemas
Backbone do servidor
 Servidores do DataStage de metadados (WAS)
 Servidor de metadados
WAS e repositório
XMETA
Servidor do
Clientes DataStage
Repositório XMETA
Implementação: DataStage em uma máquina separada

Aqui, o WAS e o repositório estão no mesmo sistema. O sistema de servidor do
DataStage ou os sistemas estão separados. Se vários servidores do DataStage
estiverem no mesmo domínio, eles poderão estar no mesmo sistema ou em sistemas
separados.
Quando há vários sistemas envolvidos, eles devem ser conectados por uma rede de
alta velocidade, de modo que possam se comunicar entre si. Os processos do agente
são executados em cada um dos nós para facilitar a comunicação.

Servidor de metadados e DB2 em máquinas separadas
Backbone do servidor
• Todos os componentes do de metadados (WAS)
IS em sistemas separados
 Servidor do DataStage
 Servidor de metadados
(WAS)
 Repositório XMETA
Servidor do
Clientes DataStage
Repositório XMETA
Servidor de metadados e DB2 em máquinas separadas

Aqui, o repositório foi colocado em um sistema separado do WAS. Essa configuração
pode nem sempre funcionar bem devido ao alto volume de tráfego de rede entre o
WAS e o banco de dados do repositório.

Inicialização do Information Server

• Inicialização do servidor de metadados (WAS) no Windows:
 Selecione o menu IBM WebSphere
 Clique em Start the Server no perfil do InfoSphere
• Início do servidor de metadados em plataformas UNIX:
 Chame o script startServer.sh no diretório
WebSphere/AppServer/profiles/InfoSphere/bin
• Por padrão, os serviços de inicialização são configurados para
execução automática à inicialização do sistema
• Para começar a trabalhar no DataStage, dê um clique duplo em um
ícone do cliente DataStage e efetue login
• Para começar a trabalhar no console da Web do Information Server,
abra uma janela do navegador, insira o endereço do sistema de
serviços (WAS) e efetue login
Inicialização do Information Server

Por padrão, os serviços de inicialização são configurados para serem executados
automaticamente quando o sistema inicia, mas também podem ser iniciados
manualmente. Os dois primeiros marcadores descrevem o processo manual. O banco
de dados do Repositório XMETA deve estar em execução antes de você tentar iniciar
o Information Server.

Início do Information Server no Windows
Inicie o servidor Pasta Profiles do

servidor de aplicativos
Início do Information Server no Windows

É possível configurar o Information Server para iniciar automaticamente junto com o
início do Windows.
Também é possível iniciar o Information Server a partir da linha de comandos do
Windows. Aqui, mostramos o item de menu usado para iniciar o servidor de metadados
(WAS). Para acessar esse menu, clique em IBM WebSphere Application Server >
Profiles > InfoSphere > Start the server.

Início do Information Server no Linux

• Abra uma janela do terminal
• Mude para o diretório AppServer/bin
• Execute o script startServer.sh
Mude para o diretório AppServer/bin
Nome padrão do
servidor de metadados
Início do Information Server no Linux

Este gráfico mostra como iniciar manualmente o Information Server usando a linha de
comandos do Unix.
Também é possível verificar o status do servidor de metadados usando o comando
./serverStatus.sh server1.

Verificação se o Information Server está em execução

• Login no Information Server Administration Console
 Nota: isso não estabelece que aplicativos de componente individual, como
o DataStage, estão em execução
• Para efeturar login no Administration Console:
 Clique no link Administration Console na barra de ativação do Information
Server
− Para efeturar login na barra de ativação: https://edserver:9443/ibm/iis/launchpad
• edserver: Nome do sistema de domínio do Information Server
• 9443: Endereço de porta para comunicação com o servidor de domínio
 Em um navegador da web, insira o endereço IP do console da web do
InfoSphere Information Server: https://edserver:9443/ibm/iis/console/
• No sistema WAS, verifique se o servidor de metadados está em
execução usando o script serverStatus.sh
 Mude para o diretório bin do WAS e execute serverStatus.sh server1
− Por padrão, o servidor de metadados é "server1"
− Efetue login como um administrador do WAS: wasadmin
Verificação se o Information Server está em execução

No cliente, uma maneira fácil de determinar se o Information Server está em execução
é abrir o Information Server Administration Console. Efetue login no Administration
Console em um navegador da web usando o endereço IP mostrado na barra de
ativação do Information Server. A barra de ativação do Information Server contém links
para diversos produtos e componentes do Information Server, incluindo o
Administration Console.
No sistema WAS, use o script serverStatus.sh para determinar se o Information
Server está em execução. Primeiro, mude para o diretório bin do WAS (por exemplo,
/opt/IBM/WebSphere/Appserver/bin no Linux ou c:\IBM\WebSphere\AppServer\bin
em um servidor Windows).

Janela de login do console da web
ID do administrador
do Information Server
Login

Este gráfico mostra como efetuar login no Information Server Administration Console.
Em um navegador da web, digite o endereço:
https://edserver:9443/ibm/iss/console/. Efetue login usando o ID do administrador do
Information Server. O ID do administrador padrão é isadmin.

1. Quais componentes do Information Server constituem um domínio?
2. Um domínio pode conter vários servidores do DataStage?
3. O gerenciador do banco de dados com o banco de dados do
repositório precisa estar no mesmo sistema que o servidor de
aplicativos do WAS?


1. Servidor de metadados hospedado por uma instância do WAS. Um
ou mais servidores do DataStage. Um gerenciador do banco de
dados (por exemplo, DB2 ou Oracle) contendo o repositório XMETA.
2. Sim.
Os servidores do DataStage podem estar em sistemas separados ou
em um único sistema.
3. Não.
A instância do DB2 com o repositório pode residir em uma máquina
separada que não seja o WebSphere Application Server (WAS).

Demonstração 1
Login no Information Server Administration Console
Demonstração 1: Login no Information Server Administration Console

Demonstração 1:
Login no Information Server Administration Console
Propósito:
Nesta demonstração, você efetuará login no Information Server
Administration Console e verificará se o Information Server está em
execução.
Usuário/senha do Windows: student/student
Servidor: http://edserver:9443/
Console: Administration Console
Usuário/senha: isadmin/isadmin
Tarefa 1. Efetue login no Information Server Administration
Console.
1. Se solicitado a efetuar login no Windows, use student/student.
2. No navegador Mozilla Firefox, digite o endereço IP da barra de ativação do
InfoSphere Information Server: http://edserver:9443/ibm/iis/launchpad/.
Aqui, edserver é o nome do sistema de computador Information Server e 9443
é o número da porta usado para comunicar-se com ele.
3. Clique em Administration Console .

Digite ID do usuário/senha do Information Server Administrator: isadmin/isadmin.

4. Clique em Login.
Nota: se a janela de login não aparecer, provavelmente é porque o Information

Server (DataStage) não iniciou. Pode levar mais de cinco minutos para ele
iniciar.
Se não tiver iniciado, examine os serviços do Windows. Há um atalho na área
de trabalho. Verifique se o DB2 - DB2Copy iniciou. Caso não tenha iniciado,
selecione-o e clique em Start. Então, selecione IBM WebSphere Application
Server e clique em Restart.
O DB2 geralmente inicia automaticamente, mas caso isso não ocorra, o
Information Server (DataStage) não iniciará.
Resultados:
Nesta demonstração, você se registrou no Information Server Administration
Console e verificou se o Information Server estava em execução.

Resumo da unidade
• Identificar os componentes do Information Server que precisam ser
instalados
• Descrever em que consiste um domínio de implementação
• Descrever diferentes opções de implementação de domínio
• Descrever o processo de instalação
• Iniciar o Information Server
Resumo da unidade

Unidade 3 Administração do DataStage
Administração do DataStage


• Abrir o console da web do Information Server
• Criar novos usuários e grupos
• Atribuir funções de conjunto e funções de componente a usuários e
grupos
• Dar aos usuários credenciais do DataStage
• Efetuar login no DataStage Administrator
• Incluir um usuário do DataStage na guia Permissions e especificar a
função do usuário
• Especificar os padrões globais e de projeto do DataStage
• Listar e descrever as variáveis de ambiente importantes
Administração do DataStage © Copyright IBM Corporation 2015
Esta unidade analisa os detalhes do cliente do Administrator.

Console da web do Information Server – administração

• Usado para administrar o Information Server
 Gerenciamento de domínio
 Gerenciamento de sessões
 Usuários e grupos
 Gerenciamento de log
 Gerenciamento de planejamento
• Nosso foco está em usuários e grupos
 Como os IDs do usuário do DataStage são criados
• Também analisaremos o gerenciamento de domínio
 Credenciais do DataStage
Console da web do Information Server – administração

Há muitas funções administrativas que podem ser executadas na guia Administration
do Information Server Administration Console. No entanto, nosso foco neste curso está
no gerenciamento de usuários e grupos do DataStage e no que é chamado de
gerenciamento de domínio.
Na prática, você provavelmente não criará IDs de usuário do Information Server. No
entanto, é importante que você tenha alguma compreensão de como isso é feito, para
que possa atuar efetivamente como um desenvolvedor do DataStage.

Endereço do console
de administração
ID do administrador
Login

Para abrir o Administrative Console, insira o endereço do console da web em um
navegador da Internet, seja o Internet Explorer ou o Mozilla Firefox.
O endereço do console está no formato: https://machine:nnnn/ibm/iis/console/
Aqui, machine é o nome do host ou o endereço IP da máquina que está executando o
servidor de aplicativos que hospeda o servidor de metadados.
nnnn é o endereço de porta do console. Por padrão, é 9443.
O ID e a senha de administrador do Information Server são especificados durante a
instalação. O padrão é isadmin. Após a instalação, podem-se especificar novos IDs de
administrador.
Também é possível efeturar login no console da web usando uma função de usuário
não administrador do Information Server. Porém, a função de usuário é limitada. Uma
função de administrador é necessária para criar IDs do usuário.

Gerenciamento de usuário e grupo

• É possível fornecer autorizações a usuários ou grupos
 Os usuários que são membros de um grupo adquirem as autorizações do
grupo
• As autorizações são fornecidas na forma de funções
 Dois tipos de funções
− Funções de conjunto: aplicam-se ao conjunto
− Funções de componente do conjunto: aplicam-se a um produto ou componente específico do
Information Server, por exemplo, o DataStage
• Dois tipos de funções
Administrator: autorizações integrais

User: autorizações limitadas

• Funções do DataStage
 Administrator: autorizações integrais
− Autorizações integrais dentro do cliente do Administrator
− Autorizações integrais de desenvolvedor e operador dentro do Design e do Director
 User: conjunto limitado de autorizações
− As permissões são especificadas no cliente do DataStage Administrator por um
administrador do DataStage
Gerenciamento de usuário e grupo

Podem ser definidas duas funções do DataStage no console da web do Information
Server: administrator, user. Se o ID do usuário for atribuído à função de
administrator do DataStage, o usuário imediatamente vai adquirir a função de
administrador do DataStage para todos os projetos.
Se o ID de usuário for atribuído à função de user do DataStage, as permissões
específicas que o usuário tem no DataStage serão definidas no cliente do DataStage
Administrator por um administrador do DataStage.

Criação de um ID do usuário do DataStage
Guia Administration
Usuários Criar novo usuário
Criação de um ID do usuário do DataStage

Este gráfico mostra a guia Administration do console da web do Information Server. A
pasta Users and Groups foi expandida.
O processo de criar um novo grupo é similar ao de criar um novo usuário. Usuários
designados a um grupo herdam a autorização designada ao grupo.
Para criar um ID do usuário, expanda a pasta Users and Groups e clique em Users.
Então, clique em New User.
O gráfico mostra a lista de usuários já criados, incluindo um administrador do
Information Server (isadmin) e um administrador do WAS (wasadmin).

Atribuição de funções do DataStage
ID do usuário
Funções de conjunto
Função de usuário
do conjunto
Funções do componente
Função de
administrador
do DataStage
Atribuição de funções do DataStage

Neste gráfico, o usuário dsadmin recebe as funções Suite User e DataStage
Administrator. Os usuários de qualquer aplicativo do Information Server devem
receber a função Suite User.
Os campos obrigatórios incluem o ID do usuário e a senha e o nome do usuário.
Outras informações sobre o usuário são opcionais.

Credenciais do DataStage
• Credenciais do DataStage para um ID do usuário
 Exigidas pelo DataStage
 Exigidas além das autorizações do Information Server
• As credenciais do DataStage são dadas a um ID do usuário (por
exemplo, dsadmin) mapeando o ID do usuário para um ID do usuário
do sistema operacional no sistema do servidor do DataStage
• Especificadas na pasta Domain Management > Engine Credentials
 Mapeamentos padrão ou individuais podem ser especificados
Credenciais do DataStage
Para efeturar login em um cliente do DataStage, além de ter um ID do usuário do
DataStage, também é preciso ter credenciais do DataStage. O motivo para isso está
relacionado ao DataStage anterior. Originalmente, o DataStage era um produto
independente que necessitava de um ID do usuário do sistema operacional do servidor
do DataStage. Embora o DataStage agora faça parte do conjunto de produtos
Information Server e use o registro do Information Server, ele ainda tem esse requisito
anterior. Esse requisito é implementado mapeando os IDs do usuário para os IDs do
sistema operacional do servidor do DataStage.
Isso presume que, quando o DataStage foi instalado, o estilo de registro do usuário
selecionado para a instalação foi Internal User Registry. Outras opções são
possíveis.

Mapeamento padrão das credenciais do DataStage
ID do usuário do sistema
operacional no servidor
do DataStage
Mapeamento padrão das credenciais do DataStage

Na guia Engine Credentials, selecione o servidor do DataStage. Clique em Open
Configuration. Nas caixas de texto, especifique um ID do usuário e senha do sistema
operacional no sistema do servidor do DataStage.
Também é possível mapear IDs do usuário do Information Server individuais para IDs
do usuário do servidor do DataStage específicos. Selecione o servidor do DataStage e
clique em Open User Credentials. Mapeamentos individuais fornecem melhor
prestação de contas.
Observe que dsadm neste exemplo não precisa ser um administrador ou usuário do
conjunto. É um ID do usuário do sistema operacional para o qual os IDs do usuário do
DataStage são mapeados.

Login no DataStage Administrator
Nome de host do sistema

de serviços (WAS)
ID de administrador e
senha do DataStage
Nome do sistema de
servidor do DataStage
Login no DataStage Administrator

Este gráfico mostra a janela de login no DataStage Administrator. Selecione o nome do
host (aqui, EDSERVER), o nome do usuário e a senha e selecione o nome do host do
sistema que está executando o DataStage (aqui, EDSERVER).
Lembre-se de que vários servidores do DataStage podem existir em um domínio. Aqui
você seleciona o servidor do DataStage que deseja administrar.
Você pode efetuar login como administrador ou usuário do DataStage. A função user
tem algumas limitações.

Guia Projects do DataStage Administrator

Clique para especificar as
propriedades do projeto
Link para o console da web

Guia Projects do DataStage Administrator

Este gráfico mostra a guia Projects do Administrator. Selecione o projeto que você
deseja configurar e clique em Properties.
Ao efetuar login pela primeira vez, você é levado à guia General.
Observe também que é possível incluir e excluir projetos nessa guia. O projeto
ANALYZERPROJECT mostrado na lista de projetos é um projeto especial criado para
o Information Analyzer, que é outro produto do conjunto Information Server. Esse
projeto e dstage1 foram criados durante a instalação do Information Server.
O DSProject foi criado após a instalação do Information Server clicando no botão Add
nessa guia.
Observe o link no canto inferior direito. É possível usar esse link para abrir o
Information Server Administration Console.

Guia General do DataStage Administrator
Configurações da
variável de ambiente
Guia General do DataStage Administrator

Este gráfico mostra a guia General do Administrator. É onde você obtém acesso às
variáveis de ambiente para o projeto. Clique no botão Environment para exibir as
configurações das variáveis de ambiente.
As páginas a seguir discutem algumas das principais variáveis de ambiente.

Variáveis de ambiente
Variáveis da tarefa paralela Caminho do arquivo de

configuração
Variáveis de ambiente
Este gráfico mostra a pasta Parallel na janela Environment Variables.
Clique no botão Environment na guia General para abrir esta janela. As variáveis
listadas na pasta Parallel aplicam-se a tarefas paralelas.
Em particular, observe a variável de ambiente $APT_CONFIG_FILE. Ela especifica o
caminho para o arquivo de configuração padrão do projeto. Uma tarefa paralela no
projeto vai, por padrão, ser executada sob este arquivo de configuração.
Também é possível especificar suas próprias variáveis de ambiente na pasta User
Defined. É possível enviar essas variáveis para tarefas por meio dos seus parâmetros
da tarefa para fornecer padrões de tarefa no nível do projeto.

Variáveis de relatório do ambiente
Exibir
pontuação
Exibir OSH
Variáveis de relatório do ambiente

Este gráfico mostra a pasta Reporting das variáveis de ambiente. Essas são variáveis
que determinam quanta informação é exibida no log da tarefa. As informações incluem
processos de inicialização, estatísticas de desempenho, informações de depuração e
semelhantes.
As variáveis de ambiente Score e OSH estão destacadas. Essas variáveis fornecem
informações muito úteis para depurar tarefas paralelas do DataStage.

Guia Permissions do DataStage Administrator
Funções do DataStage atribuídas
Incluir usuários do DataStage

Guia Permissions do DataStage Administrator

Este gráfico mostra a guia Permissions.
São listados os usuários e os grupos do conjunto que têm função de usuário ou
administrador do DataStage.
Quando usuários ou grupos do conjunto que têm uma função de administrador do
DataStage são incluídos, eles são automaticamente exibidos aqui e recebem a função
de DataStage Administrator.
Usuários ou grupos do conjunto que têm uma função de usuário do DataStage
precisam ser incluídos manualmente. Para fazer isso, clique no botão Add User or
Group. Então, selecione a função de usuário do DataStage (Operator, Super
Operator, Developer, Production Manager) que esse ID do usuário deve ter.

Inclusão de usuários e grupos
Usuários/grupos disponíveis
com uma função de usuário Incluir usuários do DataStage
do DataStage
Inclusão de usuários e grupos

Clique no botão Add User or Group para abrir essa janela. À esquerda, estão os
usuários e os grupos do Information Server que foram designados à função de usuário
do DataStage no console da web do Information Server. Selecione os usuários a
serem incluídos e clique em OK.

Especificação de função do DataStage
Usuário do DataStage
incluído
Seleção da função do DataStage
Especificação de função do DataStage

Quando um usuário ou grupo tiver sido incluído, é possível especificar a função do
usuário dentro deste projeto do DataStage.
Quatro funções de usuário podem ser atribuídas a um usuário do DataStage:
DataStage Developer, que tem acesso total a todas as áreas do projeto do DataStage.
DataStage Operator, que pode executar e monitorar tarefas do DataStage no cliente
Director.
DataStage Super Operator, que pode abrir o Designer e visualizar as tarefas paralelas
e outros objetos do DataStage no modo somente leitura.
DataStage Production Manager, que pode criar e manipular projetos protegidos. Um
projeto protegido é um projeto que armazena tarefas do DataStage que foram
liberadas para produção.

Guia Logs do DataStage Administrator
Limpeza automática do log

da tarefa do Director Logs
Guia Logs do DataStage Administrator

Este gráfico mostra a guia Logs. Aqui, é possível definir os padrões sobre o log da
tarefa do DataStage.
A opção Auto-purge está destacada. O log da tarefa pode preencher rapidamente.
Se essa caixa estiver marcada, o DataStage automaticamente limpará o log após um
determinado número de execuções da tarefa (aqui, duas) ou um determinado número
de dias.

Guia Parallel do DataStage Administrator
Exibir OSH
Padrões de tipo de coluna
Guia Parallel do DataStage Administrator

Este gráfico mostra a guia Parallel. Use essa guia para especificar padrões de tarefas
paralelas.
Use esta guia para mudar os formatos padrão do projeto para datas e horas.
Aqui, também é possível escolher tornar o OSH visível em projetos do DataStage.
Saiba que essa configuração se aplica a todos os projetos do DataStage, não apenas
ao que está aberto no Administrator. Em geral, essa configuração está ativada. Ao
clicar no botão Compile no DataStage Designer, o diagrama de tarefas da GUI é
compilado em um script OSH que pode ser executado pelo mecanismo paralelo.
Visualizar o OSH às vezes pode fornecer informações úteis sobre como suas tarefas
funcionam, pois fornece uma visão de nível inferior da tarefa.

1. As autorizações podem ser atribuídas a quais dois itens?
2. Quais dois tipos de função de autorização podem ser atribuídas a
um usuário ou grupo?
3. Além da autorização de conjunto para efetuar login no DataStage, do
que mais um desenvolver do DataStage precisa para trabalhar no
DataStage?
4. Suponha que dsuser tenha sido atribuído à função de usuário do
DataStage no console da web do IS. De qual função de permissão
no DataStage Administrator o dsuser precisa para compilar tarefas
no DataStage?


1. Usuários e grupos.
Membros de um grupo adquirem as autorizações do grupo.
2. Funções do conjunto e funções de componente do conjunto.
3. Credenciais do DataStage.
4. Desenvolvedor do DataStage.

Demonstração 1
Demonstração 1: Administração do DataStage

Demonstração 1:
Propósito:
Você criará IDs do usuário do DataStage no console da web do InfoSphere.
Depois, efetuará login no DataStage Administrator e configurará o ambiente
do DataStage.
Barra de ativação do Information Server: http://edserver:9443/ibm/iis/launchpad/
Console: Administration Console
Usuário/senha: isadmin/isadmin
Tarefa 1. Crie um administrador e um usuário do DataStage.
1. Em Information Server Launch Pad, efetue login no Information Server
Administration Console como isadmin/isadmin.
2. No Information Server Administration Console, clique na
guia Administration.
3. Expanda Users and Groups e clique em Users.
Você deve ver pelo menos dois usuários: isadmin é o ID de administrador do
Information Server; wasadmin é o ID de administrador do WebSphere
Application Server. Esses usuários são criados durante a instalação do
Information Server.
4. Marque a caixa de seleção para o usuário isadmin e, no painel direito, clique em
Open User.
Observe o nome e o sobrenome desse usuário.

5. Expanda Suite e Suite Component, se ainda não tiverem sido expandidos.

Observe que as funções de Suite e de Suite Component foram atribuídas a
esse usuário. Role para visualizar mais funções.
6. No painel esquerdo, clique em Users para voltar à janela principal Users.

7. No painel direito, clique em New User.

8. Crie um novo ID do usuário chamado dsadmin com as seguintes informações:

Senha: dsadmin
Nome: dsadmin
Sobrenome: dsadmin
Função do conjunto: Suite User
Função do componente do conjunto: DataStage and QualityStage
Administrator
9. Role para a parte inferior da janela e clique em Save and Close.

Nota: se solicitado a salvar a senha, clique em "Never Remember Password
For This Site".
10. Seguindo o mesmo procedimento, crie um usuário adicional chamado dsuser
com as seguintes informações:
Senha: dsuser
Nome: dsuser
Sobrenome: dsuser
Função do conjunto: Suite User
Função do componente do conjunto: DataStage and QualityStage User
11. Role para baixo e clique em Save and Close.

12. Verifique se dsuser e dsadmin foram criados.
13. Clique em File > Exit para fechar o InfoSphere Administration Console.
Tarefa 2. Efetue login no DataStage Administrator.
1. Clique duas vezes no ícone Administrator Client na área de trabalho do
Windows.

2. Selecione o nome de host e o número da porta edserver:9443, digite

dsadmin/dsadmin nas caixas User name e Password e selecione
EDSERVER como o mecanismo do Information Server.
3. Clique em Login.
Tarefa 3. Especifique os valores da propriedade no DataStage
Administrator.
1. Clique na guia Projects, selecione seu projeto (DSProject) e clique no botão
Properties.

2. Na guia General, selecione Enable Runtime Column Propagation for

Parallel jobs (não selecione a opção de novos links).
3. Clique no botão Environment para abrir a janela Environment Variables.

4. Em Categories, com Parallel expandido, clique em Parallel para selecioná-lo.
Examine o parâmetro APT_CONFIG_FILE e seu padrão. O arquivo de
configuração é discutido em uma unidade posterior.

5. Clique em Reporting para selecionar e, então, assegure-se de que as variáveis

APT_DUMP_SCORE, APT_STARTUP_STATUS e OSH_DUMP estejam
definidas para True.
Dica: pode ser necessário redimensionar a janela Environment Variables e a coluna
Name no painel Details para visualizar os nomes da variável.
6. Clique em OK.
7. Na guia Parallel, habilite a opção para tornar o OSH gerado visível.
Observe os formatos de data e hora padrão. Por exemplo, o formato de data padrão
é "AAAA-MM-DD", que é apresentado pela sequência de formatação mostrada.

8. Na guia Sequence, selecione todas as opções disponíveis.
Tarefa 4. Defina as permissões e os padrões do DataStage.

1. Clique na guia Permissions.
Observe que isadmin e dsadmin (entre outros) já existem como
administradores do DataStage. Isso acontece porque eles foram designados
à função de administrador do componente do conjunto DataStage no
Information Server Administration console. Os administradores do
DataStage têm permissões integrais de desenvolvedor e administrador em
todos os projetos do DataStage.
Por outro lado, dsuser não recebe permissão para desenvolver dentro de um
projeto específico do DataStage, a menos que um administrador do DataStage
explicitamente conceda essa permissão. Assim, não vemos o dsuser aqui.
2. Clique em Add User or Group.

Observe que dsuser está disponível para inclusão.

3. Clique em dsuser para selecioná-lo e depois clique em Add.
4. Clique em OK para retornar à guia Permissions. Selecione dsuser. Na lista

suspensa User Role, selecione a função DataStage and QualityStage
Developer.
5. Clique em OK e depois em Close para fechar o DataStage Administrator.

6. Reabra o Administrator Client e efetue o login de dsuser/dsuser.
7. Selecione seu projeto e clique em Properties.
Observe que a guia Permissions está desativada. Isso acontece porque
dsuser não foi designado à função de administrador do DataStage e, portanto,
não tem autoridade para definir permissões do DataStage.

8. Clique na guia Logs, assegure que Auto-purge of job log esteja selecionado
e defina a ação Auto-purge para até 2 execuções de tarefa anteriores.
9. Clique em OK e feche o Administrator Client.

Resultados:
Você criou IDs do usuário do DataStage no Information Server Administration
Console. Então, você se registrou no DataStage Administrator e configurou o
ambiente do DataStage.

Resumo da unidade
• Abrir o console da web do Information Server
• Criar novos usuários e grupos
• Atribuir funções de conjunto e funções de componente a usuários e
grupos
• Dar aos usuários credenciais do DataStage
• Efetuar login no DataStage Administrator
• Incluir um usuário do DataStage na guia Permissions e especificar a
função do usuário
• Especificar os padrões globais e de projeto do DataStage
• Listar e descrever as variáveis de ambiente importantes
Resumo da unidade

Unidade 4 Trabalho com metadados
Trabalho com metadados
IBM Infosphere DataStage v11.5


• Registrar-se no DataStage
• Navegar no DataStage Designer
• Importar e exportar objetos do DataStage para um arquivo
• Importar uma definição de tabela para o arquivo sequencial
Trabalho com metadados © Copyright IBM Corporation 2015

Login no Designer
• Um domínio pode conter
vários servidores do
DataStage
• Qualifique o projeto
(DSProject) pelo nome do
servidor do DataStage
(EDSERVER)
Sistema do servidor de
domínio
Selecionar projeto
Login no Designer
Este gráfico mostra a janela Attach to Project do Designer, que é usada para efetuar
login no DataStage Designer. O processo é similar a registrar-se no Administrator, mas
aqui você seleciona um projeto específico em um servidor do DataStage em particular.
Neste exemplo, o projeto se chama DSProject. Observe que o nome do projeto é
qualificado pelo nome do sistema de servidor do DataStage em que o projeto existe.
Esse é um qualificador necessário e obrigatório porque vários sistemas de servidor do
DataStage podem existir em um domínio do Information Server.

Área de trabalho do Designer

Repositório Menus Barra de ferramentas
Tela
paralela
Paleta
Log da
tarefa
Área de trabalho do Designer

Este gráfico mostra a janela Designer. Os principais elementos estão destacados.
Aqui, são mostradas quatro áreas principais. A configuração exata dessas áreas é
customizável, mas isso está próximo do layout padrão. No canto superior esquerdo,
está a janela Repository. Ela armazena as tarefas do DataStage e outros objetos que
você cria. Uma dessas tarefas do DataStage é aberta e exibida na tela no canto
superior direito.
Quando uma tarefa é aberta, a janela Palette no lado esquerdo central contém os
estágios que podem ser arrastados para a tela.
Na parte inferior está o log da tarefa para a tarefa aberta e exibida no momento. A
exibição dessa janela é opcional. Clique em View > Job Log para alternar a abertura
dessa janela. É conveniente deixar essa janela aberta para não precisar efetuar login
no Director para visualizar as mensagens de log da tarefa.

Janela Repository
Procurar objetos
no projeto
Projeto
Pasta de tarefas
Pasta padrão
definida pelo
usuário
Pasta de
definições da
tabela padrão
Janela Repository
A janela Repository exibe as pastas dos objetos armazenados no repositório para o
projeto do DataStage ao qual se registrou.
O repositório do projeto contém um conjunto padrão de pastas em que os objetos são
armazenados por padrão. Eles incluem a pasta Jobs, na qual uma tarefa do
DataStage é salva por padrão. No entanto, é possível criar em qualquer nível novas
pastas nas quais armazenar tarefas do repositório e outros objetos. E qualquer objeto
pode ser salvo em qualquer pasta.
Neste exemplo, há uma pasta criada pelo usuário chamada _Training. Nessa pasta,
há subpastas (não mostradas) para armazenar tarefas e definições de tabela
associadas às tarefas.

Importação e exportação
• Qualquer objeto ou conjunto de objetos na janela Repository pode ser
exportado para um arquivo
• Pode exportar projetos inteiros
• Usos:
 Uso para backup
 Às vezes é usado para controle de versão
 Mover objetos do DataStage de um projeto para outro
 Compartilhar tarefas e projetos do DataStage com outros desenvolvedores
• Como as variáveis de ambiente são manipuladas em uma exportação
 Variáveis de ambiente incluídas em tarefas ou conjuntos de parâmetros
serão criadas no novo projeto para o qual forem importadas se ainda não
existirem
− Os valores padrão são definidos na sequência de caracteres vazia
Importação e exportação
Qualquer conjunto de objetos do repositório do projeto, incluindo projetos inteiros,
pode ser exportado para um arquivo. Esse arquivo de exportação pode, então, ser
importado de volta para um projeto do DataStage, seja no mesmo projeto ou em
um projeto diferente.
Importação e exportação podem ser usadas para muitos propósitos, incluindo:
 Realizar backup de tarefas e projetos.
 Manter diferentes versões de uma tarefa ou projeto.
 Mover objetos do DataStage de um projeto para outro. Basta exportar os objetos,
movê-los para o outro projeto e, então, reimportá-los para o novo projeto.
 Compartilhar tarefas e projetos com outros desenvolvedores. Os arquivos de
exportação, quando compactados, são pequenos e podem ser facilmente
enviados por e-mail de um desenvolvedor para outro.

Procedimento de exportação
• Clique em Export > DataStage Components
• Inclua os objetos do DataStage a exportar
• Especifique o tipo de exportação:
 DSX: formato padrão
 XML: permite o processamento do arquivo de exportação por aplicativos
XML, por exemplo, para gerar relatórios
• Especifique um caminho de arquivo no sistema do cliente
• Você também pode clicar com o botão direito sobre objetos
selecionados no repositório para executar uma exportação
Procedimento de exportação
Clique em Export > DataStage Components para iniciar o processo de exportação.
Selecione os tipos de componentes a exportar. É possível selecionar um projeto inteiro
ou um subconjunto dos objetos no projeto.
Especifique o nome e o caminho do arquivo ao qual exportar. Por padrão, os objetos
são exportados para um arquivo de texto em um formato especial. Por padrão, a
extensão é dsx. Como alternativa, é possível exportar os objetos para um documento
XML.
O diretório para o qual você exporta está no cliente do DataStage, não no servidor.
Os objetos também podem ser exportados de uma lista retornada por uma procura.
Esse procedimento é discutido mais adiante no curso.

Janela Export
Clique para
Objetos
selecionar
selecionados
objetos do
repositório
Selecione o
caminho no
sistema do
cliente
Tipo de
exportação
Iniciar
exportação
Janela Export
Este gráfico mostra a janela Repository Export.
Clique em Add para procurar objetos a exportar no repositório. Especifique um
caminho no sistema do cliente. Clique em Export.
Por padrão, o tipo de exportação é dsx. Para a maioria dos propósitos, use esse
formato.

Procedimento de importação
• Clique em Import > DataStage Components
 Ou em Import > DataStage Components (XML), se estiver importando um
arquivo de exportação no formato XML
• Selecione os objetos do DataStage a importar
Procedimento de importação
Um arquivo de exportação (dsx) criado anteriormente pode ser importado de volta
para um projeto do DataStage.
Para importar componentes do DataStage, clique em Import > DataStage
Components.
Selecione o arquivo a importar. Clique em Import all para iniciar o processo de
importação ou clique em Import selected para visualizar uma lista dos objetos no
arquivo de importação. É possível importar os objetos selecionados da lista. Selecione
o botão Overwrite without query para sobrescrever os objetos com o mesmo nome
sem aviso.

Opções de importação
Importar todos os Caminho para
objetos no arquivo importar o arquivo
Selecionar os
itens a importar
em uma lista
Opções de importação
Este gráfico mostra a janela Repository Import. Procure o arquivo na caixa Import
from file. Selecione se deseja importar todos os objetos ou exibir uma lista dos objetos
no arquivo de importação.
Para importações grandes, pode ser útil desativar Perform impact analysis. Isso
adiciona sobrecarga ao processo de importação.

Metadados de origem e destino

• Os metadados, ou "dados sobre dados", descrevem o formato dos
dados, os dados de origem ou os dados de destino
• Para ler linhas de dados de uma origem de dados, o DataStage
precisa receber os metadados que descrevem os dados que ele deve
ler
• O DataStage armazena os metadados como "definições da tabela"
• As definições da tabela podem ser carregadas em estágios de tarefa
• É possível importar definições de tabela para:
 Arquivos sequenciais
 Tabelas relacionais
 Arquivos COBOL
 Muitos outros tipos de origens de dados
Metadados de origem e destino

As definições de tabela determinam os formatos de uma variedade de tabelas e
arquivos de dados. Essas definições podem, então, ser utilizadas e reutilizadas nas
tarefas para ler e gravar nesses arquivos e tabelas.
Por exemplo, é possível importar as definições de formato e coluna do arquivo
Customers.txt. Então, é possível carregá-lo para um Estágio de origem de arquivo
sequencial de uma tarefa que extraia dados do arquivo Customers.txt.
É possível carregar esses mesmos metadados para outros estágios que acessam
dados com o mesmo formato. Nesse sentido, os metadados são reutilizáveis. Pode ser
usado para acessar qualquer arquivo ou tabela com o mesmo formato.
Se as definições de coluna forem similares àquelas que você precisa, é possível
modificar as definições e salvar a definição de tabela com um novo nome.
É possível importar e definir muitos tipos diferentes de definições de tabela, incluindo
definições de tabela para arquivos sequenciais e tabelas relacionais.

Procedimento de importação do arquivo sequencial

• Clique em Import > Table Definitions > Sequential File Definitions
• Selecione o diretório que contém o arquivo sequencial
 Os arquivos são exibidos na janela Files
• Selecione o arquivo sequencial
• Selecione uma pasta do repositório na qual armazenar a definição de
tabela
• Examine as especificações de formato e coluna e edite-as conforme
necessário
Procedimento de importação do arquivo sequencial

Para iniciar a importação, clique em Import > Table Definitions > Sequential File
Definitions. A janela Import Meta Data (Sequential) é exibida. Então, selecione o
diretório que contém os arquivos sequenciais. A caixa Files é, então, preenchida com
os arquivos que você pode importar.
Selecione o arquivo a importar. Então, selecione ou especifique a pasta do repositório
na qual armazenar a definição de tabela.
O DataStage adivinha os tipos de colunas no arquivo sequencial lendo linhas de dados
do arquivo. Você conhece seus dados melhor que o DataStage. Você pode e deve
editar os tipos e comprimentos de coluna conforme necessário para manipular os
dados da maneira adequada.

Importação de metadados sequenciais
Definições
de arquivo
sequencial
Importação de metadados sequenciais

Este gráfico mostra a seleção de menu para importar definições de tabela para
arquivos sequenciais. Clique em Import > Table Definitions e depois selecione
Sequential File Definitions.
Observe que, na lista de menu, há muitos diferentes tipos de importações que podem
ser executados.

Janela de importação sequencial

Selecionar o diretório
que contém o arquivo
Começar a
importação
Selecionar o
arquivo
Selecionar
a pasta do
repositório
Janela de importação sequencial

Este gráfico mostra a janela Import Metadata do arquivo sequencial.
Selecione o diretório no sistema de servidor do DataStage que contém o arquivo
sequencial que você deseja importar. Os arquivos no diretório são exibidos na janela
Files. Na caixa To folder, selecione uma pasta no repositório no qual armazenar a
definição de tabela importada e clique em Import.

Especificação do formato
Selecionar se a
Editar colunas primeira linha tiver
nomes da coluna
Delimitador
Visualizar
os dados
Especificação do formato
Este gráfico mostra a guia Format da janela Define Sequential Metadata.
Na guia Format, especifique o formato incluindo, em específico, o delimitador de
coluna e se a primeira linha contém nomes da coluna. Clique em Preview para exibir
os dados usando o formato especificado. Se tudo parecer estar correto, clique na guia
Define para especificar as definições de coluna.

Edição de nomes e tipos de coluna
Clique duplo para

definir propriedades
estendidas
Edição de nomes e tipos de coluna

Este gráfico mostra a guia Define da janela Define Sequential Metadata.
Os nomes da coluna exibidos vêm da primeira linha de nomes da coluna, se houver. Se
não houver uma primeira linha de nomes da coluna, os nomes da coluna padrão serão
usados. Edite os nomes e os tipos de colunas conforme necessário. O DataStage está
adivinhando seus tipos com base no seu exame de linhas de dados no arquivo. O
DataStage às vezes pode se enganar quanto aos tipos.
Também é possível especificar propriedades estendidas adicionais para quaisquer
colunas. Dê um clique duplo no número à esquerda do nome da coluna para abrir uma
janela na qual especificar essas propriedades estendidas.

Janela de propriedades estendidas
Propriedades paralelas
Categorias de propriedade
Propriedades disponíveis
Janela de propriedades estendidas

Este gráfico mostra a janela de propriedades estendidas. Na guia Parallel, há várias
pastas de propriedades que podem ser adicionadas. Selecione a pasta e selecione a
propriedade específica. Então, especifique o valor que a propriedade deve ter na caixa
de texto ativada.
As propriedades padrão são exibidas na metade superior da janela. É possível mudar
qualquer uma dessas propriedades aqui e na guia Define.

Definição de tabela no repositório
Colunas Formato
Definição de
tabela
armazenada
Definição de tabela no repositório

Depois de a definição de tabela ser importada, ela é armazenada na pasta
especificada durante a importação. Esse gráfico mostra a definição de tabela depois de
ela ter sido aberta na janela Repository para visualização.
Para visualizar a definição de tabela, na janela Repository, selecione a pasta que
contém a definição de tabela. Dê um clique duplo na definição de tabela para abrir a
janela Table Definition.
Clique na guia Columns para visualizar e modificar quaisquer definições de coluna.
Selecione a guia Format para editar a especificação de formato do arquivo. Selecione
a guia Parallel para especificar as propriedades de formato paralelo.

• Verdadeiro ou falso? O diretório ao qual você exporta está na
máquina cliente do DataStage, não na máquina servidor do
DataStage.
• É possível importar definições de tabela para arquivos sequenciais
com formatos de registro de comprimento fixo?


1. Verdadeiro.
2. Sim.
As durações do registro são determinadas pelos comprimentos das
colunas individuais.

Demonstração 1
Importação e exportação de objetos do DataStage
Demonstração 1: Importação e exportação de objetos do DataStage

Demonstração 1:
Importação e exportação de objetos do DataStage
Propósito:
Você usará o DataStage Designer para importar e exportar objetos do
DataStage. Como parte desta demonstração, você criará pastas Repository e
arquivos de objetos do DataStage. Por fim, exportará uma pasta.
Cliente do DataStage: Designer
Usuário/senha do cliente do Designer: student/student
Projeto: EDSERVER/DSProject
Tarefa 1. Efetue login no DataStage Designer.
1. Abra o Designer Client usando o ícone na área de trabalho do Windows.
2. Efetue login no projeto do DataStage com:

 Nome do host da camada de serviços e número da porta: edserver:9443
 Nome do usuário: student
 Senha: student
 Projeto: EDSERVER/DSProject
Tarefa 2. Crie pastas Repository
1. Clique em Cancel para fechar a janela New.
2. No painel esquerdo, abaixo de Repository, selecione seu projeto, DSProject.
3. Clique com o botão direito em DSProject e clique em New > Folder.
4. Crie uma pasta chamada _Training e, sob ela, crie duas novas subpastas:
Jobs e Metadata.

5. No menu Repository, clique em Refresh.

Isso move as pastas criadas para a parte superior da visualização (view).
Tarefa 3. Importe arquivos de objeto do DataStage.

1. No menu Import, clique em DataStage Components.
2. Em Import from file, procure C:\CourseData\DSEss_Files\dsxfiles, selecione
o arquivo TableDefs.dsx e clique em Open.
Dica: comece a navegar clicando em Computer no painel esquerdo.
3. Confirme que Import selected está selecionado.

4. Clique em OK.
5. Clique para selecionar Table Definitions e clique em OK.

6. Clique duas vezes na definição de tabela recém-importada. Você a encontrará
sob a pasta _Training > Metadata. Ela se chama Employees.txt.
Dica: se clicar duas vezes não funcionar, clique com o botão direito e selecione
Properties.
7. Clique na guia Columns.
Observe as definições de coluna e seus tipos.
8. Clique em OK para fechar a janela Table Definition.

Tarefa 4. Exporte uma pasta.
Nesta tarefa, você exporta sua pasta _Training para um arquivo chamado
Training.dsx.
1. Clique com o botão direito em _Training e, em seguida, em Export.
2. Na caixa Export to file, defina o caminho da pasta (usando a opção de
procurar) para C:\CourseData\DSEss_Files\dsxfiles e inclua o nome do
arquivo Training.dsx digitando-o em File name.

3. Clique em Open.
O arquivo Employees.txt agora pode ser exportado com base nas suas
configurações.
4. Clique em Export, clique em OK na mensagem e clique em Close.

Resultados:
Você usou o DataStage Designer para importar e exportar objetos do
DataStage. Como parte dessa demonstração, você criou pastas Repository e
arquivos de objetos do DataStage. Por fim, você exportou uma pasta.

Demonstração 2
Importação de uma definição de tabela
Demonstração 2: Importação de uma definição de tabela

Demonstração 2:
Importação de uma definição de tabela
Propósito:
Você deseja carregar sua definição de tabela para um estágio Sequential File
para que ela possa ser lida. Você primeiro importará uma definição de tabela
para um arquivo sequencial e, então, visualizará uma definição de tabela
armazenada no repositório.
Tarefa 1. Importe uma definição de tabela de um arquivo

sequencial.
1. Em um editor de texto, como o WordPad, abra o arquivo
Selling_Group_Mapping.txt encontrado no diretório
C:\CourseData\DSEss_Files e examine seu formato e seus conteúdos.
Algumas questões a considerar:
 A primeira linha é uma linha de nomes da coluna?
 As colunas são delimitadas ou de largura fixa?
 Se as colunas forem delimitadas, qual é o delimitador?
 Quantas colunas? De quais tipos elas são?
2. No Designer, no menu Import, clique em
Table Definitions > Sequential File Definitions.
3. Na caixa Directory, procure o diretório CourseData > DSEss_Files.
Observe que os arquivos nesse diretório não aparecerão na janela de seleção
porque você está apenas selecionando o diretório que contém os arquivos.
4. Clique em OK.
Os arquivos no diretório DSEss_Files são exibidos no painel Files.
5. Na caixa Files, selecione Selling_Group_Mapping.txt.

6. Na caixa To folder, selecione _Training\Metadata e clique em OK.
7. Clique em Import.
Você especifica o formato geral na guia Format.
8. Especifique se a primeira linha é de nomes da coluna, se esse for o caso.
O DataStage pode usar esses nomes nas definições de coluna.

9. Clique em Preview para visualizar os dados no seu arquivo no formato

especificado.
Se você mudar o delimitador, clicar em Preview mostrará a mudança na janela
Data Preview. Esse é um método para confirmar se você definiu o formato
corretamente. Se parecer confuso, você não especificou o formato
corretamente. No caso atual, tudo parece estar correto.
10. Clique na guia Define para examinar as definições de coluna.
11. Clique em OK para importar a definição de tabela e clique em Close.

12. Depois de fechar a janela Import Meta Data, localize e abra sua nova definição
de tabela na janela Repository. Ela está localizada na pasta especificada na
caixa To folder durante a importação, ou seja _Training\Metadata.
NOTA: se a definição de tabela não estiver em _Training\Metadata no

Designer, procure-a na pasta Table Definitions, para onde as definições de
tabela vão por padrão. Você pode mover a definição de tabela de lá para
_Training\Metadata com a ação de arrastar e soltar.
13. Clique na guia Columns para examinar as definições de coluna importadas.

14. Clique na guia Format para examinar a especificação de formato.

Observe o delimitador e que a opção First line is column names está
selecionada.
15. Clique em OK para fechar Table Definition.

Resultados:
Você usou o DataStage Designer para importar e exportar objetos do
DataStage. Como parte dessa demonstração, você criou pastas Repository e
arquivos de objetos do DataStage. Por fim, você exportou uma pasta.

Resumo da unidade
• Registrar-se no DataStage
• Navegar no DataStage Designer
• Importar e exportar objetos do DataStage para um arquivo
• Importar uma definição de tabela para o arquivo sequencial
Resumo da unidade


Unidade 5 Criação de tarefas paralelas
Criação de tarefas paralelas


• Projetar uma tarefa paralela no DataStage Designer
• Definir um parâmetro da tarefa
• Usar os estágios Row Generator, Peek e Annotation na tarefa
• Compilar a tarefa
• Executar a tarefa
• Monitorar o log da tarefa
• Criar um conjunto de parâmetros e usá-lo em uma tarefa
Criação de tarefas paralelas © Copyright IBM Corporation 2015

O que é uma tarefa paralela?

• Programa DataStage executável
• Criado no DataStage Designer
 Construído usando componentes do DataStage, especialmente estágios
e links
• Construído usando uma interface gráfica com o usuário
• Compila para uma linguagem de script chamada OSH
• É executado usando o mecanismo paralelo do DataStage
O que é uma tarefa paralela?

Uma tarefa é um programa executável do DataStage. As tarefas do DataStage são
projetadas e integradas no Designer. Elas são, então, compiladas e executadas sob
o controle do DataStage. Quando elas são compiladas, o design da GUI é convertido
para o que é chamado de script OSH. No OSH, por exemplo, os estágios são
convertidos para operadores e links são convertidos para conjuntos de dados de
entrada e saída.
O OSH é um código executável que pode ser executado pelo mecanismo paralelo do
DataStage.
Lembre-se de que você pode visualizar o OSH se tiver ativado isso para o projeto no
DataStage Administrator.

Visão geral do desenvolvimento de tarefa

• Importe metadados definindo origens e destinos
 Feita com o Designer usando o processo de importação
• No Designer, inclua estágios definindo extrações de dados e cargas
• Inclua estágios de processamento para definir transformações de
dados
• Inclua links definindo o fluxo de dados de um estágio para outro
• Clique no botão de compilação
 Criar uma versão executável (OSH) da tarefa
• Execute e monitore o log da tarefa
 O log da tarefa pode ser visualizado no Designer ou no Director
 É possível executar a tarefa no Designer ou no Director
Visão geral do desenvolvimento de tarefa

Em uma unidade anterior, você aprendeu a importar uma definição de tabela para um
arquivo sequencial. Nesta unidade, você aprenderá a carregar essa definição de tabela
em um estágio em uma tarefa do DataStage. A tarefa que criaremos aqui será
relativamente simples, mas nos permitirá ver todo o processo de desenvolvimento, do
design, construção, compilação, execução e monitoramento.

Paleta de ferramentas
Categorias do
estágio
Estágios
Paleta de ferramentas
Este gráfico mostra a Palette do Designer. A Palette contém os estágios que você
pode incluir no design da tarefa arrastando-os para a tela de tarefa.
Há várias categorias de estágios. No início, você pode ter alguma dificuldade para
saber onde um estágio está. A maioria dos estágios que você usará estará na pasta
Database, na pasta File e na pasta Processing. Uma pequena coleção de estágios
de propósito especial, incluindo o estágio Row Generator, que usaremos na nossa
tarefa de exemplo, estará na pasta Development/Debug.

Inclusão de estágios e links

• Arraste estágios da paleta para o diagrama
 Também é possível arrastar da ramificação Stage Type na janela
Repository para o diagrama
• Trace links do estágio de origem para o estágio de destino
 Clique com o botão direito do mouse no estágio de origem
 Libere o botão do mouse sobre o estágio de destino
Inclusão de estágios e links

Para compilar sua tarefa, arraste os estágios da Palette para o diagrama. Então,
arraste links dos estágios de origem para os de destino na tela. Para arrastar o link,
mantenha o botão direito do mouse pressionado sobre o estágio de origem. Arraste
o link para o estágio de destino e solte o botão do mouse.

Sequência de exemplo de criação de tarefa

• Breve apresentação do procedimento
• Presume que a definição de tabela da origem já existe no Repository
• A tarefa neste exemplo simples:
 Gera os próprios dados usando o estágio Row Generator
−O estágio Row Generator é um tipo de estágio Source
− Outros estágios de origem, que analisaremos mais adiante, incluem o estágio
Sequential File e o estágio DB2
 Grava seus dados de saída no log da tarefa usando o estágio Peek
−O estágio Peek é um tipo de estágio de destino
− Outros estágios de destino, que analisaremos mais adiante, incluem o estágio
Sequential File e o estágio DB2
Sequência de exemplo de criação de tarefa

O exemplo ilustrado nas páginas a seguir fará uma breve apresentação do fluxo de
trabalho de desenvolvimento de tarefa. Para este exemplo, presumiremos que já existe
uma definição de tabela.
Nossa tarefa de exemplo consiste em um estágio Row Generator e um estágio Peek.
O primeiro gera linhas de dados com base na definição de tabela carregada nele. O
estágio Peek grava mensagens no log da tarefa.

Criação de uma nova tarefa paralela
Tela da tarefa paralela
Abertura de uma
nova janela
Tarefa paralela
Criação de uma nova tarefa paralela

Este gráfico mostra como abrir uma nova tela para uma tarefa paralela. Clique no
botão New na barra de ferramentas para abrir a janela New. Clique no ícone Parallel
Job para criar uma nova tarefa paralela (o foco deste curso).
Como mencionado anteriormente, há vários tipos diferentes de tarefas que podem ser
criadas no DataStage. Cada tipo tem o próprio conjunto especial de estágios. Verifique
se a palavra Parallel aparece no canto superior esquerdo da tela, indicando que você
está trabalhando no conjunto de estágios correto.

Arraste de estágios e links da paleta
Compilação
Execução
Propriedades Gerador
da tarefa de linha Peek
Link
Arraste de estágios e links da paleta

Este gráfico mostra a tarefa após os estágios terem sido arrastados para a tela e
vinculados.
O ícone Job Properties está destacado porque é onde os parâmetros da tarefa são
criados. Os botões Compile e Run também estão destacados.

Renomeação de links e estágios

• Clique em um estágio ou link para renomeá-lo
• Nomes com significado têm muitos benefícios
 Documentação
 Clareza
 Menos erros de desenvolvimento
Renomeação de links e estágios

Este gráfico ilustra como renomear links e estágios. Se você clicar em um estágio e
começar a digitar, uma caixa de texto, na qual é possível gravar o nome, é ativada.
Um dos principais benefícios do DataStage é que as suas tarefas são, de certa
forma, "autodocumentadas". O layout da GUI da tarefa documenta o fluxo de dados
da tarefa. No entanto, você obterá esse benefício apenas se atribuir nomes com
significado aos seus links e estágios e incluir estágios Annotation adicionais quando
necessário.

Estágio Row Generator

• Produz dados mock para colunas especificadas
• Não há link de entradas; link de saída único
• Na guia Properties, especifique o número de linhas
• Na guia Columns, carregue ou especifique definições de coluna
 Abra a janela Extended Properties para especificar os algoritmos usados
para gerar os dados
 Os algoritmos disponíveis dependem do tipo de dados da coluna
• Algoritmos para o tipo de número inteiro
 Aleatório: valor inicial, limite
 Ciclo: valor inicial, incremento
• Algoritmos para o tipo de sequência de caracteres: Ciclo, alfabeto
• Algoritmos para tipo de data: aleatório, ciclo
Estágio Row Generator

Na nossa tarefa de exemplo, o estágio Row Generator produz os dados de origem.
Tarefas posteriores neste curso lerão os dados de arquivos e tabelas.
O estágio Row Generator está na pasta Development/Debug porque ele costuma
ser usado durante o desenvolvimento para criar dados de teste para uma nova
tarefa.
A maioria dos estágios tem uma aparência similar. Em geral, há uma guia
Properties contendo uma lista de propriedades específicas para o tipo de estágio.
Você especifica os valores para essas propriedades para configurar como o estágio
deve se comportar na tarefa.
Normalmente, também há uma guia Columns que apresenta as colunas dos dados
que fluirão através do estágio. Uma definição de tabela pode ser carregada no
estágio para criar essas colunas.
Em uma unidade anterior, você aprendeu sobre propriedades estendidas. Para o
estágio Row Generator, são usadas propriedades estendidas para especificar como
os dados devem ser gerados para cada uma das colunas. Com base no tipo de
coluna, há diferentes algoritmos a escolher.

Dentro do estágio Row Generator
Guia
Properties
Configurar o
Propriedade valor da
propriedade
Dentro do estágio Row Generator

Este gráfico mostra a guia Properties no estágio Row Generator.
Para especificar um valor para uma propriedade, selecione a propriedade. Então, use a
caixa de texto no lado direito para especificar manualmente ou selecionar o valor para
a propriedade.
As propriedades são divididas em pastas. Neste estágio simples, há apenas uma pasta
com apenas uma propriedade. Se você selecionar uma pasta, as propriedades
adicionais que podem ser incluídas aparecerão na janela Available properties to add
no canto inferior direito do estágio. (Neste gráfico, essa área está esmaecida.)

Guia Row Generator Columns
Clique duas vezes para

especificar as
propriedades estendidas
Visualizar
Carregar uma dados
definição de tabela
Selecionar
definição de
tabela
Guia Row Generator Columns

O gráfico superior mostra a guia Row Generators Columns. É possível ver que as
colunas carregadas da definição de tabela aparecem no canto inferior esquerdo.
Depois de carregadas, as definições de coluna podem ser mudadas. Como alternativa,
essas definições de coluna podem ser inseridas e editadas manualmente.
Os dados que são gerados pelo estágio corresponderão a essas colunas.

Propriedades estendidas
Propriedades
especificadas e
seus valores
Propriedades
adicionais a incluir
Propriedades estendidas
Este gráfico mostra a janela Extended Properties.
Neste exemplo, a pasta Generator foi selecionada e a propriedade Type foi incluída
da janela Available properties to add no canto inferior direito. O valor cycle foi
selecionado para a propriedade Type. Então, a propriedade Type foi selecionada e as
propriedades Initial Value e Increment foram incluídas.
O algoritmo de ciclo gera valores alternando entre uma lista de valores que começam
com o valor inicial especificado.

Estágio Peek
• Exibe valores de campo
 Por padrão, log da tarefa gravado
 Pode controlar o número de registros a serem exibidos
 Pode especificar as colunas a serem exibidas
• Estágio útil para verificar os dados em um estágio em particular na
tarefa
 Por exemplo, coloque um estágio Peek antes de um estágio Transformer
e um estágio Peek após
− Apresenta uma imagem de antes/depois dos dados
Estágio Peek
Os dados gerados são, então, gravados no estágio Peek. Por padrão, o estágio Peek
exibe valores de coluna no log da tarefa, em vez de gravá-los em um arquivo. Após a
execução da tarefa, as mensagens Peek podem ser visualizadas no log da tarefa.
Neste exemplo, as linhas geradas pelo estágio Row Generator serão gravadas no log.

Propriedades do estágio Peek
Resultado para
log da tarefa
Propriedades do estágio Peek

Este gráfico mostra a guia Properties do estágio Peek. Em geral, os valores padrão
selecionados para as propriedades não precisam de edição.
Por padrão, o estágio Peek grava no log. Também é possível produzir uma saída do
estágio Peek para um arquivo.

Parâmetros da tarefa
• Definidos na janela Job Properties
• Torna a tarefa mais flexível
• Os parâmetros podem ser usados em qualquer lugar em que se possa
especificar um valor
 Usado em nomes de arquivo e caminho
 Para especificar valores de propriedade
 Usado em restrições e derivações em um estágio Transformer
• Valores de parâmetro são especificados no tempo de execução

• Quando usados para nomes de arquivos e diretório e valores de
propriedade, ficam entre cerquilhas (#)
 Por exemplo, #NumRows#
 A cerquilha distingue o parâmetro da tarefa de um valor codificado
manualmente
• Variáveis de ambiente do DataStage podem ser incluídas como
parâmetros da tarefa
Parâmetros da tarefa
As propriedades da tarefa são definidas na janela Job Properties. Elas tornam uma
tarefa mais flexível permitindo a especificação de valores no tempo de execução para
configurar como a tarefa se comporta.
É possível inserir os parâmetros da tarefa em muitos locais em uma tarefa do
DataStage. Aqui, focamos no seu uso como variáveis de propriedade. Um parâmetro
da tarefa é usado no lugar de um valor codificado manualmente de uma propriedade.
Em execuções de tarefa diferentes, é possível especificar diferentes valores para a
propriedade.
Neste exemplo, em vez de digitar, digamos, 100 para a propriedade Number of
Records, criamos um parâmetro da tarefa chamado NumRows e especificamos o
parâmetro como o valor da propriedade. No tempo de execução, podemos inserir um
valor para esse parâmetro, por exemplo, 100 ou 100.000.

Definição de um parâmetro da tarefa

Guia Parameters
Parâmetro
Incluir variável de
ambiente
Definição de um parâmetro da tarefa

Este gráfico mostra a guia Parameters na janela Job Properties. Aqui, é possível
especificar manualmente quaisquer parâmetros da tarefa que você queira usar na sua
tarefa. Ainda, é possível clicar no botão Add Environment Variable para incluir
variáveis de ambiente como parâmetros.
Clique no ícone Job Properties na barra de ferramentas do Designer para abrir a
janela Job Properties.
Observe também o botão Add Parameter Set. Clique nesse botão para incluir variáveis
do conjunto de parâmetros à lista de parâmetros. Os conjuntos de parâmetros são
discutidos mais adiante nesta unidade.

Uso de um parâmetro da tarefa em um estágio
Parâmetro da tarefa
Clique para inserir o
parâmetro da tarefa
Uso de um parâmetro da tarefa em um estágio

Este gráfico mostra como usar os parâmetros da tarefa na sua tarefa. Aqui, você vê
como usar o parâmetro da tarefa NumRows no estágio Row Generator.
Selecione a propriedade. Então, insira o valor na caixa de texto. Clique no botão à
direita da caixa de texto para exibir um menu para selecionar um parâmetro da tarefa.

Inclusão de documentação de tarefas

• Na janela Job Properties
 Descrições breves e longas
• Estágio Annotation
 Exibe descrições de texto formatadas no diagrama
Inclusão de documentação de tarefas

Além da documentação que a nomenclatura de links e estágios fornece, também é
possível incluir mais documentação usando os estágios Annotation. Outra opção é
especificar descrições da tarefa na guia General da janela Job Properties.

Documentação da janela Job Properties
Documentação
Documentação da janela Job Properties

Este gráfico mostra onde é possível incluir descrições da tarefa na guia General da
janela Job Properties.
As descrições da tarefa estão disponíveis a usuários sem abrir a tarefa. Alguns
usuários, como operadores do DataStage, não têm permissão para abrir uma tarefa,
nem mesmo para efetuar login no Designer. Assim, essas descrições da tarefa são
tudo o que eles têm (além do nome da tarefa) para determinar como a tarefa se
comporta.

Propriedades do estágio Annotation
Propriedades do estágio Annotation

Este gráfico mostra o interior do estágio Annotation. Inclua um ou mais estágios
Annotation na tela para documentar sua tarefa.
Um estágio Annotation funciona como uma caixa de texto com várias opções de
formatação. Você digita o texto. É possível especificar a fonte e as propriedades de
texto.
Opcionalmente, você pode mostrar ou ocultar os estágios Annotation pressionando um
botão na barra de ferramentas.
Há dois tipos de estágios Annotation. O estágio Description Annotation vincula seu
texto às descrições especificadas na janela Job Properties.

Compilação e execução de uma tarefa
Execução
Compilação
Estágio Annotation
Compilação e execução de uma tarefa

Este gráfico mostra como compilar e executar uma tarefa no Designer.
Antes de executar sua tarefa, é preciso compilá-la. Para compilá-la, clique em
File > Compile ou no botão Compile na barra de ferramentas. A janela Compile Job
exibe o status da compilação.
Depois de compilar a tarefa, presumindo que ela seja concluída sem erros, é possível
executá-la do Designer ou do Director. Para visualizar o log da tarefa, entre no cliente
do Director ou abra o log da tarefa dentro do Designer.

Mensagens de erros ou êxito
Destaque do Clique para obter

estágio com erro mais informações
Mensagens de erros ou êxito

Esse gráfico mostra a janela Compile Job, que mostra o status da compilação.
Se ocorrer um erro, clique em Show Error para destacar o estágio em que o erro
ocorreu.
Quando ativado, clique em More para recuperar mais informações sobre o erro além
daquelas exibidas na janela Compilation Status.

DataStage Director
• Use para executar e planejar tarefas
• Visualize mensagens do tempo de execução
• Pode chamar diretamente do Designer
 Tools > Run Director
DataStage Director
É possível abrir o Director do Designer clicando em Tools > Run Director. De modo
similar, é possível passar do Director para o Designer.
Há dois métodos para executar uma tarefa: executá-la imediatamente. Ou planejar sua
execução para uma data e hora posteriores. Clique no ícone Schedule view na barra
de ferramentas para planejar a tarefa.
Para executar uma tarefa imediatamente no Director, selecione-a na exibição Job
Status. A tarefa deve, então, ter sido compilada. Clique em Job > Run Now ou no
botão Run Now na barra de ferramentas. A janela Job Run Options é exibida. Se a
tarefa tiver parâmetros da tarefa, é possível defini-los neste ponto ou aceitar qualquer
valor de parâmetro padrão.

Opções de execução
Atribuir valores
ao parâmetro
Opções de execução
Esse gráfico mostra a janela Job Run Options. A janela Job Run Options é exibida
quando você clica em Job > Run Now.
Nessa janela, é possível especificar valores para quaisquer parâmetros da tarefa. Se
tiverem sido especificados valores padrão para os parâmetros da tarefa quando eles
foram definidos, esses padrões aparecerão inicialmente.
Clique no botão Run nessa janela para iniciar a tarefa.

Estatísticas de desempenho
• As estatísticas de desempenho são exibidas no Designer quando a
tarefa é executada
 Para habilitar, clique com o botão direito sobre a tela e depois clique em
Show performance statistics
• O link fica verde se os dados fluírem através dele
• Número de linhas e linhas por segundo são exibidos
• O link fica vermelho se ocorrer um erro de tempo de execução
Estatísticas de desempenho
Esse gráfico exibe as estatísticas de desempenho do Designer, que são exibidas ao
executar uma tarefa e visualizá-la no Designer. Essas estatísticas são atualizadas
conforme a tarefa é executada. As cores dos links indicam o status da tarefa. Verde
indica que os dados fluíram através do link sem erros. Vermelho indica um erro.
Para ativar ou desativar o monitoramento de desempenho, clique com o botão direito
do mouse sobre a tela e depois ative ou desative Show performance statistics.

Visualização de status do Director

Visualização
de status
Visualização de log
Visualização de
planejamento
Selecionar tarefas
cujas mensagens
deseja visualizar
Visualização de status do Director

Esse gráfico mostra a visualização (view) Status do Director, que mostra as tarefas no
projeto e seus status: Compiled, Running, Aborted e assim por diante. Também
exibe os horários de início e fim da última execução.
As tarefas são listadas no painel direito junto com seus status. Clique no ícone "open
book" para visualizar o log da tarefa para uma tarefa selecionada.

Log da tarefa, visualizada do Designer
Mensagem Peek
Log da tarefa, visualizada do Designer

Este gráfico mostra o log da tarefa no Designer para uma tarefa específica. O log da
tarefa está disponível tanto no Designer (clique em View > Job log) quanto no Director
(clique no ícone Log). O log da tarefa exibe mensagens gravadas durante a execução
da tarefa.
Algumas mensagens são sobre eventos de controle, como o início, o fim ou o
cancelamento de uma tarefa. Também são incluídas mensagens de informação,
mensagens de aviso e mensagens de erro. Clique duas vezes em uma mensagem
para abri-la.
Mensagens Peek têm como prefixo o nome do estágio Peek.

Detalhes da mensagem
Dados gerados do estágio Row

Generator e gravados no estágio Peek
Detalhes da mensagem
Este gráfico mostra um exemplo de detalhes da mensagem. Clique duas vezes em
uma mensagem para abri-la e ler os seus detalhes.
Nesse exemplo, a mensagem Peek está exibindo linhas de dados em uma das
partições ou nós (partição 0). Se a tarefa estiver em execução em várias partições,
haverá mensagens Peek para cada uma.
Cada linha exibe os nomes das colunas seguidos pelos seus valores.

Outras funções do log da tarefa

• Limpeza do log da tarefa das mensagens
 No Director, clique em Job > Clear Log
 Essa função não está disponível no Designer
• Reconfiguração da tarefa
 Se uma tarefa for interrompida, ela poderá entrar em um estado não
executável
− Clique no botão Reset na barra de ferramentas do Director ou na barra de
ferramentas de log da tarefa do Designer para retornar a tarefa a um estado
executável
Outras funções do log da tarefa

Algumas outras funções de log da tarefa úteis são listadas aqui. O log da tarefa pode
ficar cheio, assim, você pode preferir limpar as mensagens no log para uma tarefa em
particular. No Director, clique em Job > Clear Log para fazer isso. Essa função não
está disponível no Designer. Com relação ao log da tarefa, o Director tem mais
funcionalidades que o Designer.
Às vezes, se uma tarefa é interrompida, ela pode entrar em um estado não executável.
Reconfigure-a usando o botão Reset. Às vezes, pode não ser possível reconfigurar
uma tarefa. Nesses casos, recompile a tarefa para retorná-la a um estado executável.

Monitor do Director
• Monitor do Director
 Clique em Tools > New Monitor
 Visualize as estatísticas de tempo de execução por estágio/link
(como estatísticas de desempenho na tela)
 Visualize as estatísticas de tempo de execução partição a partição
− Clique com o botão direito do mouse sobre a janela para ativar esse recurso
Estágio Peek
Employees em
execução na partição 0
Monitor do Director
Esse gráfico mostra o Monitor do Director, que ilustra as estatísticas de desempenho.
Conforme já mencionado, também é possível visualizar estatísticas do tempo de
execução na tela do Designer. No entanto, as estatísticas na tela do Designer não
podem ser divididas em partições individuais, que você pode visualizar no Director.
Aqui, vemos que o estágio Peek chamado PeekEmployees é executado em ambas as
partições (0 e 1). Cada instância processa cinco linhas. Assim, no geral, o estágio Peek
processa 10 linhas.
O estágio Row Generator Employees está em execução em uma única partição (0).
Aqui, vemos que ele gerou 10 linhas.

Execução de tarefas da linha de comando

• dsjob –run –param numrows=10 DSProject GenDataJob
 Executa uma tarefa
 Use –run para executar a tarefa
 Use –param para especificar os parâmetros
 Neste exemplo, DSProject tem o mesmo nome do projeto
 Neste exemplo, GenDataJob é o nome da tarefa
• dsjob –logsum DSProject GenDataJob
 Exibe as mensagens da tarefa no log
• Documentado no "Guia do Programador do IBM InfoSphere
DataStage"
Execução de tarefas da linha de comando

Embora o foco neste curso seja a execução de tarefas e a visualização (view) do log
por meio de clientes do DataStage, é importante observar que o DataStage também
tem uma interface da linha de comandos. Ela lista alguns exemplos de comando.
O comando primário é o dsjob. O primeiro exemplo o utiliza para executar o
GenDataJob em um projeto do DataStage chamado DSProject.
O segundo exemplo usa o comando dsjob para exibir as mensagens no log da tarefa
para a mesma tarefa.

Conjuntos de parâmetros
• Armazena uma coleção de parâmetros da tarefa em um objeto do
repositório nomeado
 Pode ser importado e exportado como qualquer outro objeto de repositório
• Um ou mais arquivos de valor podem ser vinculados ao conjunto de
parâmetros
 Arquivos de valores específicos podem ser selecionados no tempo de
execução
 Implementados como arquivos de texto armazenados no diretório de
projeto
• Usos:
 Armazenar conjuntos padrão de parâmetros para reutilização
 Usar arquivos de valores para armazenar conjuntos comuns de valores
de parâmetros da tarefa
Conjuntos de parâmetros
Conjuntos de parâmetros armazenam um conjunto de parâmetros de tarefas em um
objeto definido. Isso permite que eles sejam carregados em uma tarefa como uma
coleção, em vez de separadamente. Também permite que sejam importados e
exportados como um conjunto.
Suponha que uma empresa tenha um conjunto comum de 20 parâmetros que ela
inclua em todas as tarefas criadas. Sem os conjuntos de parâmetros, seria necessário
criar manualmente esses parâmetros em cada tarefa. Com conjuntos de parâmetros, a
empresa pode incluir toda uma coleção de uma só vez.
Outro recurso-chave dos conjuntos de parâmetros é que eles podem ser vinculados a
um ou mais "arquivos de valores" – arquivos que fornecem valores para os parâmetros
no conjunto de parâmetros. No tempo de execução, um usuário pode selecionar qual
arquivo de valores usar.

Criação de um conjunto de parâmetros
Criação de um conjunto de parâmetros

Para criar um conjunto de parâmetros, clique em New e depois selecione a pasta
Other. O gráfico mostra os ícones da pasta Other.

Definição dos parâmetros

• Especifique parâmetros da tarefa como faria em uma tarefa
• Os valores padrão especificados aqui se tornarão os valores padrão para
os parâmetros especificados nos arquivos de valores na guia Values
Especificar o nome do
conjunto de parâmetros
usando a guia General
Definição dos parâmetros

Esse gráfico mostra a guia Parameters da janela Parameter Set. Parâmetros
individuais são definidos da mesma forma como são definidos individualmente em
tarefas. Você especifica o nome, o prompt, o tipo e, opcionalmente, um tipo padrão do
parâmetro.
Como se pode ver, ao criar um arquivo de valores, na guia Values, os valores padrão
especificados aqui se tornam os valores padrão no arquivo de valores.
Observe que as variáveis de ambiente podem ser incluídas como parâmetros em um
conjunto de parâmetros.

Definição de arquivos de valores

• Digite os nomes dos arquivos de valores
• Insira os valores para os parâmetros
 Os valores padrão são exibidos inicialmente, mas podem ser substituídos
Definição de arquivos de valores

Esse gráfico mostra a guia Values da janela Parameter Set. Como opção, digite os
nomes de um ou mais arquivos de valores. Os parâmetros especificados na guia
Parameters se tornam, então, títulos da coluna nesta guia. Os valores padrão
inseridos na guia Parameters se tornam os valores padrão no arquivo de valores.
É possível editar qualquer um desses valores de parâmetros padrão. O objetivo geral
desses arquivos de valores é fornecer conjuntos de opções de valores. Por exemplo,
um arquivo de valores pode ser usado durante o desenvolvimento e outro, durante a
produção.

Carregamento de um conjunto de parâmetros para uma

tarefa
Conjunto de
parâmetros incluído
Visualizar conjunto de parâmetros
Incluir conjunto
de parâmetros
Carregamento de um conjunto de parâmetros para uma tarefa

Esse gráfico mostra a guia Parameters da janela Job Properties em uma tarefa.
Clique no botão Add Parameter Set para incluir a coleção de parâmetros. Observe
que o tipo (Parameter Set) o distingue na janela de um parâmetro comum.
Também é possível clicar no botão View Parameter Set para visualizar os conteúdos
do conjunto de parâmetros enquanto trabalha na janela Job Properties.

Uso de parâmetros do conjunto de parâmetros
Prefixo do conjunto
de parâmetros
Parâmetro
Uso de parâmetros do conjunto de parâmetros

Esse gráfico mostra a guia Properties do estágio Row Generator na tarefa de
exemplo. Um parâmetro de um conjunto de parâmetros é usado como o valor da
propriedade Number of Records.
Observe que os parâmetros do conjunto de parâmetros são distinguidos dos
parâmetros comuns tendo como prefixo o nome do conjunto de parâmetros.

Execução de tarefas com parâmetros do conjunto de

parâmetros
Selecionar arquivo
de valores
Execução de tarefas com parâmetros do conjunto de parâmetros

Esse gráfico mostra a janela Job Run Options, que é aberta ao clicar no botão Run.
O conjunto de parâmetros é listado junto com os parâmetros individuais no conjunto de
parâmetros.
Para o conjunto de parâmetros, é possível selecionar um arquivo de valores. Para
qualquer parâmetro individual, é possível mudar seu valor, substituindo o valor padrão
fornecido pelo arquivo de valores.

1. Qual estágio pode ser usado para exibir os dados de saída no
log da tarefa?
2. Qual estágio é usado para documentar sua tarefa na tela de tarefa?
3. Qual comando é usado para executar tarefas na linha de comandos
do sistema operacional?
4. O que é um "arquivo de valores"?


1. Estágio Peek
2. Estágio Annotation
3. dsjob -run
4. Um ou mais arquivos de valores estão associados a um conjunto
de parâmetros. O arquivo de valores é um arquivo de texto que
contém valores que podem ser passados para a tarefa no tempo
de execução.

Demonstração 1
• Nesta demonstração, você vai:

 Criar uma tarefa do DataStage
 Compilar uma tarefa
 Executar uma tarefa
 Visualizar mensagens gravadas no log da tarefa
 Documentar uma tarefa usando o estágio Annotation
 Definir e usar um parâmetro da tarefa na tarefa
 Definir e usar um conjunto de parâmetros na tarefa
Demonstração 1: Criação de tarefas paralelas

Demonstração 1:
Propósito:
Você deseja explorar todo o processo de criar, compilar, executar e monitorar
uma tarefa paralela do DataStage. Para fazer isso, você vai primeiro projetar,
compilar e executar a tarefa paralela do DataStage. Em seguida, você vai
monitorar a tarefa primeiro visualizando o log da tarefa e, então,
documentando-o no estágio Annotation. Por fim, vai usar os parâmetros da
tarefa para aumentar a flexibilidade da tarefa e criar um conjunto de
parâmetros para armazenar os parâmetros para reutilização.
Tarefa 1. Crie uma tarefa paralela.
Você deseja criar uma nova tarefa paralela com o nome GenDataJob e, então, salvá-
la na pasta _Training > Jobs.
1. Efetue login no Designer como student/student.
2. No menu File, clique em New.
3. Clique em Parallel Job e depois clique em OK.

4. No menu File, clique em Save.
5. Salve sua tarefa como GenDataJob na pasta _Training > Jobs.
Em seguida, você deseja incluir um estágio Row Generator e um estágio Peek
da pasta Development/Debug.
6. No painel esquerdo, abaixo de Palette, expanda Development/Debug.
Dica: pode ser necessário redimensionar os painéis para poder visualizar os
elementos em Palette.
7. Arraste os estágios Row Generator e Peek para a tela GenDataJob.
8. Trace um link do estágio Row Generator para o estágio Peek.
Para fazer isso, clique com o botão direito do mouse e segure sobre o estágio
Row Generator e, então, arraste o cursor do mouse para o estágio Peek antes
de soltar o botão do mouse.

9. Dê nome ao Row Generator e ao link o nome Employees. Dê ao estágio

Peek o nome de PeekEmployees, como mostrado.
10. Abra o estágio Employees - Row Generator e clique na guia Columns.

11. Clique no botão Load e carregue as definições de coluna da definição de
tabela Employees.txt importada em uma demonstração anterior.
12. Verifique as definições de coluna com o seguinte.

13. Na guia Properties, especifique que 100 registros devem ser gerados. Para
fazer isso, selecione Number of Records = 10 no painel esquerdo e depois
atualize o valor na caixa Number of Records para 100. Pressione Enter para
aplicar o novo valor.
14. Clique em View Data e depois em OK para visualizar os dados que serão
gerados.
15. Clique em Close e clique em OK para fechar o estágio Row Generator.

Tarefa 2. Compile, execute e monitore a tarefa

1. Na barra de ferramentas, clique em Compile para compilar a sua tarefa.
Se a compilação da tarefa apresentar erros, corrija-os antes de continuar.
2. Clique com o botão direito sobre uma parte vazia da tela e assegure que Show
performance statistics esteja ativado.
3. Execute sua tarefa clicando em Run na barra de ferramentas.

4. No menu View, ative Job Log para abrir o painel dentro do Designer e
visualizar as mensagens de log.
5. Role nas mensagens no log.
Não deve haver avisos ou erros. Se houver, clique duas vezes nas mensagens
para examinar seus conteúdos. Corrija o problema, recompile e execute.
Observe que há uma ou mais mensagens de log começando com a etiqueta
"PeekEmployees" no estágio Peek.
6. Clique duas vezes em uma delas para abrir a janela Log Event Detail.
7. Feche a janela Job Log.

Tarefa 3. Especifique propriedades estendidas.
1. Salve sua tarefa como GenDataJobAlgor na pasta _Training > Jobs.
2. Abra o estágio Employees - Row Generator e vá para a
guia Columns.
3. Clique duas vezes no número da linha à esquerda do primeiro nome da coluna.

4. Especifique as propriedades estendidas, como mostrado.

 Clique em Type para incluir a propriedade Type.
 Clique em Initial Value; defina seu valor para 10000 no campo Initial value
à direita.
 Selecione a propriedade Type e inclua a propriedade Increment; defina 1
como o valor de incremento
5. Clique em Apply e depois em Next.

6. Para a coluna Name, especifique que você deseja alternar entre três nomes de
sua escolha configurando o seguinte:
 Selecione Generator no painel Properties e clique em Algorithm.
 Escolha cycle no menu suspenso à direita.
 Clique em Value; no campo Value, inclua um nome para o primeiro valor.
 Pressione Enter para incluir um segundo valor.
 Repita para incluir um terceiro valor.
7. Clique em Apply, e, em seguida, em Next.

8. Para a coluna HireDate, especifique que você deseja que as datas sejam
geradas aleatoriamente.
 Na janela Available properties to add:, no canto inferior direito, escolha
Type.
 No campo Type, selecione random.
9. Clique em Apply e, em seguida, clique em Close.

10. Clique em View Data para ver os dados que serão gerados.
11. Feche o estágio.

Tarefa 4. Documente sua tarefa.
1. Na pasta General da Pallete, inclua um estágio Annotation ao diagrama da
tarefa. Abra o estágio Annotation e escolha outra cor do plano de fundo.
Descreva brevemente o que a tarefa faz.
2. Compile e execute sua tarefa.

3. No Designer, clique em View > Job Log para visualizar as mensagens no log
da tarefa. Corrija quaisquer avisos ou erros.
4. Verifique os dados examinando as mensagens do estágio Peek no log.
Tarefa 5. Inclua um parâmetro da tarefa.
1. Salve sua tarefa como GenDataJobParam na pasta _Training > Jobs.
2. No menu Designer, clique em Edit > Job Properties. (Como alternativa, clique
no ícone Job Properties na barra de ferramentas.) Clique na guia
Parameters.
3. Defina um novo parâmetro chamado NumRows, com um valor padrão de 10,
digite Integer.
4. Abra a guia Properties do estágio Row Generator na sua tarefa. Selecione a

propriedade Number of Records e clique na seta para a direita para selecionar
seu parâmetro, como mostrado. Selecione o novo parâmetro NumRows.
O resultado aparece da seguinte forma:
5. Visualize os dados.
6. Compile e execute sua tarefa. Verifique os resultados.

Tarefa 6. Crie um conjunto de parâmetros.

1. No menu File, clique em New.
2. Clique na pasta Other.
3. Clique duas vezes no ícone Parameter Set e depois dê ao conjunto de

parâmetros o nome RowGenTarget.

4. Clique na guia Parameters. Crie o parâmetro NumRows, como um Integer,

junto com o valor padrão mostrado (100).
5. Clique na guia Values. Crie dois arquivos de valores. O primeiro é chamado de

LowGen e usa os valores padrão para o parâmetro NumRows. O segundo,
HighGen, muda o valor padrão do parâmetro NumRows para 10000.
6. Clique em OK. Salve o conjunto de parâmetros na pasta _Training > Metadata.

7. Salve sua tarefa como GenDataJobParamSet.
8. No menu Edit, clique em Job Properties e selecione a guia Parameters.
9. Clique no botão Add Parameter Set.

10. Selecione o conjunto de parâmetros RowGenTarget criado antes (expanda as

pastas).
11. Clique em OK para incluir o conjunto de parâmetros à tarefa.
12. Clique em OK para fechar a janela Job Properties.

13. Abra o estágio Employees Row Generator e selecione a propriedade Number
of Records.
14. Selecione o parâmetro NumRows no conjunto de parâmetros como o valor
para a propriedade.
15. Clique em OK para fechar o estágio.

16. Compile sua tarefa.

17. Clique no botão Run. Na caixa de diálogo Job Run Options, selecione o
arquivo de valores HighGen.
18. Clique em Run. Verifique se a tarefa gera 10000 registros.
Resultados:
Você desejava explorar todo o processo de criar, compilar, executar e
monitorar uma tarefa paralela do DataStage. Para fazer isso, você primeiro
projetou, compilou e executou a tarefa paralela do DataStage. Em seguida,
você monitorou a tarefa primeiro visualizando o log da tarefa e, então,
documentando-o no estágio Annotation. Por fim, você usou os parâmetros da
tarefa para aumentar a flexibilidade da tarefa e criou um conjunto de
parâmetros para armazenar os parâmetros da coleção para reutilização.

Resumo da unidade
• Projetar uma tarefa paralela no DataStage Designer
• Definir um parâmetro da tarefa
• Usar os estágios Row Generator, Peek e Annotation na tarefa
• Compilar a tarefa
• Executar a tarefa
• Monitorar o log da tarefa
• Criar um conjunto de parâmetros e usá-lo em uma tarefa
Resumo da unidade

Unidade 6 Acesso a dados sequenciais
Acesso a dados sequenciais


• Entender os estágios para acessar diferentes tipos de dados de
arquivo
• Ler e gravar arquivos sequenciais usando o estágio Sequential File
• Ler e gravar em arquivos do conjunto de dados usando o estágio Data
Set
• Criar links de rejeição
• Trabalhar com nulos em arquivos sequenciais
• Ler de vários arquivos sequenciais usando padrões do arquivo
• Usar vários leitores
Acesso a dados sequenciais © Copyright IBM Corporation 2015
Propósito – na última unidade, os alunos criaram uma tarefa que adquiriu dados
gerados pelo estágio Row Generator. Nesta unidade, trabalharemos com um tipo
principal de dados: dados sequenciais. Em uma unidade posterior, focaremos no
outro tipo principal de dados: dados relacionais.

Como dados sequenciais são manipulados

• O estágio Sequential File pode ser usado para ler e gravar em arquivos
sequenciais
• O estágio Sequential File usa uma definição de tabela para determinar
o formato dos dados nos arquivos sequenciais
• A definição de tabela descreve o formato de registro (fim da linha) e o
formato das colunas (tipos de coluna, delimitador)
 Os registros que não podem ser lidos nem gravados são "rejeitados"
• As mensagens no log da tarefa usam a terminologia
"importar"/"exportar"
 Importar = ler; exportar = gravar
 Por exemplo, "100 registros importados/exportados com sucesso; 2
rejeitados"
Como dados sequenciais são manipulados

O estágio Sequential File é usado para ler e gravar em arquivos sequenciais em
uma tarefa do DataStage. Para ler com sucesso de um arquivo sequencial, o
estágio precisa saber qual é o formato do arquivo e o número de colunas e seus
tipos. Isso é feito de modo lógico carregando uma definição de tabela para o
estágio.
O que acontece se o estágio não conseguir ler uma ou mais das linhas de dados?
Em geral, isso acontece porque os dados na linha não correspondem à definição
de tabela que foi carregada para o estágio. Talvez os dados tenham um número
menor de colunas. Ou talvez o valor em uma das colunas não corresponda ao tipo
da coluna. Por exemplo, os dados são uma sequência de caracteres não numérica
"abc", mas a coluna é definida como um tipo de número inteiro.
Quando uma linha não pode ser lida pelo estágio, ela é rejeitada. Como você verá
posteriormente, essas linhas podem ser capturadas usando um link de rejeição.

Recursos do estágio Sequential File

• Normalmente, é executado no modo sequencial
• Pode ser executado em paralelo
 Ao ler vários arquivos
 Ao usar vários leitores
• O estágio precisa saber:
 Como o arquivo é dividido em linhas (formato de registro)
 Como as linhas são divididas em colunas (formato de coluna)
• Opcionalmente, tem suporte para um link de rejeição
 Captura linhas que são rejeitadas pelo estágio
Recursos do estágio Sequential File

Aqui estão listados os principais recursos do estágio Sequential File. Por padrão,
um estágio Sequential File é executado no modo sequencial, mas pode ser
executado no modo paralelo, dependendo de algumas configurações de
propriedades, como você verá mais adiante nesta unidade.
Para ler o arquivo sequencial, o estágio precisa conhecer o formato do arquivo. Ele
precisa saber qual é o formato do registro e o formato da coluna. O formato do
registro está relacionado a como o estágio pode determinar onde um registro de
dado termina e outro começa. Ou seja, há um caractere de final de linha ou os
registros têm um comprimento fixo? Se houver um caractere de final de linha, ele é
DOS ou UNIX?
Como já mencionado, é possível criar um link de rejeição para capturar linhas que o
estágio não consegue ler com sucesso (importação).

Exemplo de formato de arquivo sequencial

Delimitador de registro
Campo 1 Campo 2 Campo 3 Último campo nl
Delimitador de campo Delimitador final = end
Campo 1 Campo 2 Campo 3 Último campo nl
Delimitador final = vírgula
Exemplo de formato de arquivo sequencial

Esse gráfico mostra o formato de um tipo principal de arquivo sequencial.
Delimitadores separam colunas. De modo similar, os registros são separados por
caracteres de rescisão. Para ler e gravar em arquivos sequenciais, essas
informações devem ser especificadas no estágio. Em geral, são especificadas
carregando uma definição de tabela para o estágio, mas também podem ser
especificadas manualmente.
Nesse gráfico, as vírgulas são usadas como delimitadores de coluna, mas qualquer
caractere é possível. Com frequência, você também verá o caractere de barra
vertical (|) sendo usado como delimitador de coluna.

Design de tarefa com estágios Sequential File
Leitura do arquivo Gravação no arquivo
Link de fluxo
Link de rejeição Link de rejeição

(linha quebrada) (linha quebrada)
Design de tarefa com estágios Sequential File

Esse gráfico mostra uma tarefa que lê de um arquivo usando um estágio Sequential
File e grava em outro arquivo também usando um estágio Sequential File. Um
estágio Sequential File usado para ler de uma tarefa terá um único link de saída de
fluxo (linha não quebrada) e, opcionalmente, um link de rejeição (linha quebrada).
Os dados que são lidos fluirão para fora desse link.
Um estágio Sequential File usado para gravar em uma tarefa terá um único link de
entrada de fluxo (linha não quebrada) e, opcionalmente, um link de saída de
rejeição (linha quebrada). Os dados que são gravados no arquivo fluirão para o
estágio nesse link.
O estágio Sequential File não permite mais de um link de entrada ou link (de fluxo)
de saída. Ele não pode ter links de fluxo tanto de entrada quanto de saída.

Propriedades do estágio Sequential File
Guia Output
Guia Properties
Caminho para
o arquivo
Nomes da coluna
na primeira linha
Propriedades do estágio Sequential File

O gráfico mostra a guia Properties no estágio Sequential File. Aqui, você
especifica o Read Method (um arquivo especificamente indicado, ou padrão de
arquivo) e o caminho para o arquivo. Selecione a propriedade File e depois procure
o arquivo que deseja que o estágio leia. O caminho de arquivo deve estar visível no
sistema de servidor do DataStage, no qual a tarefa do DataStage é executada.
Essas propriedades estão sendo especificadas na guia Output. Isso implica que
haja um link saindo do estágio. Portanto, esse estágio está sendo usado para ler de
um arquivo.
Alguns (não todos) arquivos sequenciais têm uma primeira linha de nomes de
coluna. Essa linha não é de dados reais. Ela é usada como metadados
descrevendo os conteúdos do arquivo. Se você estiver lendo de um arquivo que
tenha essa linha, defina a propriedade First Line is Column Names para true.
Caso contrário, o estágio confundirá essa linha com dados reais e provavelmente a
rejeitará.

Guia Format
Guia Format
Formato
de registro
Carregar formato da
Formato de
coluna
Guia Format
Esse gráfico mostra a guia Format do estágio Sequential File.
Aqui, você especifica o delimitador de registro e o formato de coluna geral,
incluindo o delimitador de coluna e o caractere aspas simples. Em geral, essas
propriedades são especificadas carregando a definição de tabela importada que
descreve o arquivo sequencial, mas essas propriedades também podem ser
especificadas manualmente.
Use o botão Load para carregar as informações de formato de uma definição de
tabela.
Observe que as definições de coluna não são especificadas aqui, mas
separadamente na guia Columns. Assim, como se pode ver, há dois lugares nos
quais é possível carregar as definições de tabela: a guia Format e a guia
Columns.

Guia Columns
Guia Columns
Visualizar
dados
Carregar colunas da
Salvar como uma

nova definição de
tabela
Guia Columns
Esse gráfico mostra a guia Columns do estágio Sequential File.
Clique no botão Load para carregar as colunas de definição de tabela para o
estágio. As definições de coluna podem ser modificadas depois de serem
carregadas. Quando isso tiver sido concluído, é possível salvar as colunas
modificadas como uma nova definição de tabela. Esse é o propósito do botão
Save. Esteja atento para não confundir esse botão Save com salvar a tarefa. Clicar
nesse botão não salva a tarefa.
Depois de terminar de editar o formato e as propriedades do estágio, é possível
clicar no botão View Data. Esse é um bom teste para ver se o formato e as
propriedades do estágio foram especificados corretamente. Se não conseguir
visualizar os dados, sua tarefa provavelmente também não conseguirá ler os dados
quando for executada.

Leitura de arquivos sequenciais usando um padrão do arquivo
Usar curingas
Selecionar padrão
do arquivo
Leitura de arquivos sequenciais usando um padrão do arquivo

O gráfico mostra a guia Properties do estágio Sequential File.
Para ler arquivos usando um padrão de arquivo, mude o Read Method para File
Pattern. A propriedade File Pattern reconhece os caracteres curingas asterisco (*)
e o ponto de interrogação (?) na especificação do caminho. O asterisco significa
qualquer caractere zero ou mais. O ponto de interrogação significa qualquer
caractere único.
Neste exemplo, o estágio lerá todos os arquivos no diretório /Temp com nomes que
começam com "TargetFile_" seguidos por qualquer caractere único. Presume-se
que todos os arquivos tenham o mesmo formato e as mesmas definições de
coluna.

Vários leitores
Number of Readers per Node é

uma propriedade opcional que
pode ser incluída
Dois leitores por nó
Vários leitores
O gráfico mostra a guia Properties do estágio Sequential File.
Number of Readers per Node é uma propriedade opcional que pode ser incluída
para permitir a leitura de um único arquivo sequencial usando vários processos de
leitor sendo executados em paralelo. Por exemplo, se você especificar dois leitores,
esse arquivo poderá ser lido duas vezes mais rápido que com apenas um leitor (o
padrão). Conceitualmente, é possível imaginar isso como um leitor lendo a metade
superior do arquivo e o segundo leitor lendo a metade inferior do arquivo,
simultaneamente, em paralelo.
Observe que a ordem da linha não é mantida quando você usa vários leitores.
Portanto, se houver necessidade de identificar linhas de entrada, essa opção
poderá ser usada apenas se os dados em si fornecerem um identificador exclusivo.
Isso funciona para registros de comprimento fixo e de comprimento variável.

Gravação em um arquivo sequencial
Guia Input
Caminho para o
arquivo de saída
Anexar/sobrescrever
Incluir primeira linha

dos nomes da coluna
Gravação em um arquivo sequencial

Até o momento, discutimos como usar o estágio Sequential File para ler de
arquivos sequenciais. Agora nós voltamos para o seu uso para a gravação em
arquivos sequenciais. O gráfico mostra a guia Properties do estágio Sequential
File na guia Input. Isso implica que haja um link indo para o estágio. Portanto, esse
estágio está sendo usado para gravar em um arquivo sequencial.
A propriedade File é usada para especificar o caminho para o arquivo de saída,
que pode ou não já existir. A propriedade File Update Mode é usada para
especificar se você deseja sobrescrever o arquivo existente, caso haja um, ou
anexar ao arquivo existente.
A propriedade First Line is Column Names também existe aqui. Neste caso, ela
especifica se o estágio deve incluir uma primeira linha de colunas com base nas
definições de coluna carregadas para o estágio.

Links de rejeição
• Link de saída opcional
• Distinguem-se dos links de saída normais de fluxo pelas suas linhas
quebradas
• Capturam linhas que o estágio rejeita
 Em um estágio Sequential File de origem, as linhas que não podem ser
lidas devido a um problema de metadados ou formato
 Em um estágio Sequential File de destino, as linhas que não podem ser
gravadas devido a um problema de metadados ou formato
• As linhas capturadas podem ser gravadas em um estágio Sequential
File ou estágio Peek ou processadas de alguma outra maneira
• As linhas rejeitadas são gravadas como uma única coluna de dados:
datatype = bruto (binário)
• Use a propriedade Reject Mode para especificar que rejeições devem
ser geradas como saída
Links de rejeição
O estágio Sequential File pode ter um único link de rejeição. Os links de rejeição
podem ser incluídos a estágios Sequential File usados para leitura ou para
gravação. Eles capturam linhas que o estágio rejeita. Em um estágio Sequential
File de origem, isso inclui linhas que não podem ser lidas devido a um problema de
metadados ou formato. Em um estágio Sequential File de destino, isso inclui linhas
que não podem ser gravadas devido a um problema de metadados ou formato.
Além de traçar o link de rejeição saindo do estágio, também é preciso definir a
propriedade Reject Mode. Caso contrário, você receberá um erro de compilação.
As linhas rejeitadas são gravadas no link de rejeição como uma única coluna de
dados binários (tipo de dados brutos).

Links de rejeição de origem e destino
Link de fluxo
Link de rejeição
Link de rejeição
(linha quebrada)
(linha quebrada)
Links de rejeição de origem e destino

Esse gráfico exibe uma tarefa com links de rejeição de estágios Sequential File.
O segundo link que você traça de um estágio de origem é automaticamente
interpretado como um link de rejeição. É possível mudar o tipo de um link clicando
com o botão direito do mouse sobre ele e selecionando o tipo.
Neste exemplo, as rejeições são enviadas para os estágios Peek, que gravam os
dados no log da tarefa. Porém, também é possível enviar os dados para estágios
Sequential File ou para estágios de processamento, como um estágio Transformer.

Configuração da propriedade Reject Mode
Rejeições de saída
Configuração da propriedade Reject Mode

Esse gráfico mostra a guia Properties do estágio Sequential File.
Por padrão, a propriedade Reject Mode é definida para Continue. Isso significa
que uma linha rejeitada será descartada e o processamento continuará com a linha
seguinte. Se você incluir um link de rejeição, deverá definir o Reject Mode para
Output.

Estágio Copy
• Linhas que chegam no estágio Copy por meio do link de entrada
podem ser mapeadas para um ou mais links de saída
• Nenhuma transformação pode ser executada nos dados
• Nenhuma condição de filtragem pode ser especificada
 O que entra deve sair
• Operações que podem ser executadas:
 Números de colunas podem ser reduzidos
 Nomes de colunas podem ser mudados
 Conversões de tipo automáticas podem ocorrer
• Na guia Mapping, as colunas de entrada são mapeadas para as
colinas de link de saída
Estágio Copy
O estágio Copy é um estágio de processamento simples, mas eficiente. É chamado
de estágio Copy porque nenhuma transformação ou filtragem dos dados pode ser
executada dentro do estágio. Os dados de entrada são simplesmente copiados
para os links de saída. Por esse motivo, o estágio tem pouca sobrecarga. Contudo,
o estágio tem vários usos importantes. Uma vez que ele dá suporte a vários links
de saída, ele pode ser usado para dividir um único fluxo em vários fluxos para
processamento separado.
Os metadados também podem ser mudados usando o estágio. O número de
colunas na saída pode ser reduzido e os nomes das colunas de saída podem ser
mudados.
Embora nenhuma transformação explícita possa ser executada, conversões de tipo
automático de fato acontecem. Por exemplo, colunas do tipo Varchar() podem ser
mudadas para colunas do tipo Char().

Exemplo de estágio Copy

• Um link de entrada
• Dois links de saída
 Divide os dados de entrada em dois fluxos de saída
 Todas as linhas de entrada saem por ambos os links de saída
Exemplo de estágio Copy

Esse gráfico mostra um estágio Copy com um link de entrada e dois links de saída.
Isso divide o fluxo de entrada único em vários fluxos de saída. Todas as linhas de
entrada sairão em ambos os links de saída.

Mapeamentos do estágio Copy
Lista de links de
nome de saída
Lista de links
de saída
Mapeamentos Os nomes de
de coluna colunas mudaram
Mapeamentos do estágio Copy

Esse gráfico mostra a guia Output > Mapping do estágio Copy.
Mapeamentos de colunas de entrada para colunas de saída são feitos na guia
Output > Mapping. Neste exemplo, duas colunas de entrada foram arrastadas
para o lado de saída. Os nomes das colunas também foram mudados. Quatros
colunas fluem para dentro e duas fluem para fora desse link de saída.
Se houver vários links de saída, será preciso especificar os mapeamentos para
cada um. Selecione o nome de cada link de saída na lista Output name na parte
superior esquerda do estágio e, então, especifique os mapeamentos para cada um.

Demonstração 1
Leitura e gravação em arquivos sequenciais

 Ler de um arquivo sequencial usando o estágio Sequential File
 Gravar em um arquivo sequencial usando o estágio Sequential File
• Usar o estágio Copy em uma tarefa

• Criar links de rejeição de estágios Sequential File
• Usar vários leitores no estágio Sequential File
• Ler vários arquivos usando um padrão de arquivo
Demonstração 1: Leitura e gravação em arquivos sequenciais

Demonstração 1:
Leitura e gravação em arquivos sequenciais
Propósito:
Arquivos sequenciais são um tipo de dado que as empresas costumam
precisar processar. Você lerá e gravará arquivos sequenciais usando o
estágio Sequential File. Mais adiante, você criará um segundo link de saída,
criará links de rejeição dos estágios Sequential File, usará vários leitores no
estágio Sequential File e lerá vários arquivos usando um padrão de arquivo.
Tarefa 1. Leia e grave em um arquivo sequencial.
Nesta tarefa, você projeta uma tarefa que lê dados do arquivo
Selling_Group_Mapping.txt, copia-o para um estágio Copy e, então, grava os dados
em um novo arquivo chamado Selling_Group_Mapping_Copy.txt.
1. No menu File, clique em New e, no painel esquerdo, clique em Jobs.
2. Clique em Parallel Job, clique em OK e salve a tarefa com o nome

CreateSeqJob na pasta _Training > Jobs.
3. Inclua um estágio Sequential File da pasta File da paleta, um estágio Copy da
pasta Processing da paleta e um segundo estágio Sequential File.

4. Trace links entre os estágios e atribua os nomes aos estágios e links, conforme
mostrado.
5. No estágio Sequential File de origem (Selling_Group_Mapping), guias

Columns e Format, carregue as definições de coluna e formato da definição
de tabela Selling_Group_Mapping.txt importada em uma demonstração
anterior.
6. Na guia Properties, especifique um caminho para o arquivo a ser lido, ou seja,
o arquivo Selling_Group_Mapping.txt. Ainda, defina a propriedade First Line
is Column Names para True.
Se você não definir a propriedade, sua tarefa terá problemas para ler a primeira
linha e emitirá uma mensagem de aviso no log da tarefa.

7. Clique em View Data para verificar se os metadados foram especificados

adequadamente no estágio.
8. Clique em Close e depois em OK.

9. No estágio Copy, guia Output > Mapping, arraste todas as colunas da origem
para o destino.
10. Clique em OK.

11. No estágio Sequential File de destino (Selling_Group_Mapping_Copy), clique
na guia Format. Confirme que Field defaults > Delimiter = comma.
12. Retorne para a guia Properties. Dê ao arquivo o nome
Selling_Group_Mapping_Copy.txt e grave-o no diretório
C:\CourseData\DSEss_Files\Temp.

13. Crie-o com uma primeira linha de nomes da coluna. Deve sobrescrever
qualquer arquivo existente com o mesmo nome.
14. Clique em OK. Compile e execute sua tarefa.

15. Visualize o log da tarefa e corrija quaisquer erros, se houver.
16. Para visualizar os dados, no estágio de destino, clique com o botão direito
sobre o estágio e clique em View <stage name> data. Uma vez que não foram
feitas mudanças aos dados, os dados se parecerão como estavam no estágio
de origem.
Tarefa 2. Crie um parâmetro da tarefa para o arquivo de
destino.
1. Salve sua tarefa CreateSeqJob como CreateSeqJobParam. Renomeie o
último link e o estágio Sequential File para TargetFile.

2. Abra a janela Job Properties.

3. Na guia Parameters, defina um parâmetro da tarefa chamado TargetFile ou
digite String. Crie um nome do arquivo padrão adequado, por exemplo,
TargetFile.txt.
4. Abra o estágio sequencial de destino na guia Properties. Selecione a

propriedade File. Na caixa de texto File, retenha o caminho do diretório.
Substitua o nome do arquivo pelo parâmetro da tarefa.

Tarefa 3. Inclua links de rejeição.

1. Inclua um segundo link (que vai automaticamente se tornar um link de rejeição)
do estágio Sequential File de origem para um estágio Peek. Ainda, inclua um
link de rejeição do estágio Sequential File de destino para um estágio Peek.
Atribua nomes adequados a esses novos estágios e links.
2. Na guia Properties de cada estágio Sequential File, mude o valor da

propriedade Reject Mode para Output.
3. Compile e execute. Verifique se a execução está ocorrendo corretamente. Não

deve haver nenhuma rejeição, erro ou aviso.
4. Para testar o link de rejeição, mude temporariamente a propriedade First Line
is Column Names para False no estágio de origem, recompile e execute.
Isso fará a primeira linha ser rejeitada porque os valores na primeira linha, que
são todas as sequências de caracteres, não corresponderão às definições de
coluna, algumas das quais são tipos de números inteiros.

5. Examine o log da tarefa. Procure uma mensagem de aviso indicando um erro

de importação na leitura do primeiro registro (registro 0). Também abra a
mensagem SourceRejects do estágio Peek. Observe os dados na linha que
foi rejeitada.
Tarefa 4. Crie um segundo link de saída de um estágio Copy.

1. Inclua um segundo link de saída do estágio Copy para um estágio Peek,
atribuindo ao link o nome ToPeek.
2. Abra o estágio Copy. Clique na guia Output > Mapping e, na caixa de

listagem suspensa Output name, selecione o link para o estágio Peek
ToPeek.

3. Arraste as duas primeiras colunas para o link de destino.
4. Clique na guia Columns e renomeie a segunda coluna SG_Desc.

5. Compile e execute sua tarefa. Visualize as mensagens gravadas no log pelo

estágio de saída Peek.
Tarefa 5. Leia um arquivo usando vários leitores.

1. Salve sua tarefa como CreateSeqJobMultiRead.
2. Clique na guia Properties do estágio Sequential File de origem.
3. Clique na pasta Options para selecioná-lo e inclua a propriedade Number of
Readers Per Node. Defina a propriedade para 2.
5. Visualize o log da tarefa.
Nota: você receberá algumas mensagens de aviso no log da tarefa
relacionadas à primeira linha. E essa linha será rejeitada. É possível ignorar
essas mensagens com segurança.
Tarefa 6. Crie uma tarefa que lê vários arquivos.
1. Salve sua tarefa como CreateSeqJobPattern.
2. Abra o estágio Sequential File de destino e selecione a guia Format.
3. Selecione a pasta Record Level e clique em Record delimiter na janela
Available properties to add.

4. Aceite seu valor padrão – UNIX newline.

Isso produzirá os arquivos com delimitadores de registro UNIX, que é o que
queremos nesse caso, porque o estágio de origem lê os arquivos nesse
formato.
5. Compile e execute sua tarefa duas vezes, especificando os seguintes nomes

de arquivo no parâmetro da tarefa para o arquivo de destino: TargetFile_A.txt,
TargetFile_B.txt. Isso grava dois arquivos no seu diretório
DSEss_Files\Temp.
6. Edite o estágio Sequential de origem e mude o método de leitura para File
Pattern. Você receberá uma mensagem de aviso. Clique em Yes para
continuar.

7. Procure o arquivo TargetFile_A.txt. Coloque um curinga (?) na última parte do

nome do arquivo: TargetFile_?.txt.
8. Clique em View Data para verificar se você consegue ler os arquivos.

9. Compile e execute a tarefa, gravando em um arquivo chamado TargetFile.txt.
Visualize o log da tarefa.
10. Clique com o botão direito no estágio de destino e clique em View TargetFile
data para verificar os resultados.
Deve haver duas cópias de cada linha, já que você agora está lendo dois
arquivos idênticos. É possível usar o botão Find na janela View Data para
localizar ambas as cópias.
Resultados:
Você leu e gravou arquivos sequenciais usando o estágio Sequential File.
Mais adiante, você criou um segundo link de saída, criou links de rejeição dos
estágios Sequential File, usou vários leitores no estágio Sequential File e leu
vários arquivos usando um padrão de arquivo.

Trabalho com nulos

• Internamente, nulo é representado por um valor especial fora do
intervalo de quaisquer valores legítimos existentes
• Se nulo for gravado em uma coluna não anulável, a tarefa será
interrompida
• As colunas podem ser especificadas como anuláveis
 Os nulos podem ser gravados em colunas anuláveis
• É preciso "manipular" nulos gravados em colunas anuláveis em um
estágio
Sequential File
 É preciso dizer ao DataStage qual valor gravar no arquivo
 Linhas não manipuladas são rejeitadas
• Em um estágio de origem Sequential File, é possível especificar os
valores que você deseja que o DataStage converta para nulos
Trabalho com nulos

Nulos podem entrar no fluxo de trabalho e, quando fizerem isso, devem ser
manipulados com cuidado. Caso contrário, erros de tempo de execução e
resultados inesperados podem ocorrer. Isso descreve como os valores nulos
podem ser manipulados no DataStage no contexto de arquivos sequenciais.
Unidades posteriores discutirão valores nulos em outros contextos.
Internamente, nulo é representado por um valor fora do intervalo de qualquer valor
dos dados legítimo. Portanto, não pode ser confundido com um valor dos dados
legítimo. Por isso ele é tão útil.
Capacidade de anulação é uma propriedade de colunas. As colunas permitem
nulos ou proíbem nulos. Um valor nulo gravado em uma coluna não anulável no
tempo de execução causará a interrupção da tarefa.
Colunas em um estágio Sequential File podem ser anuláveis. Portanto, nulos
podem ser lidos de colunas e gravados nelas em um estágio Sequential File.
Porém, que valor deve ir no arquivo sequencial quando um nulo é gravado em uma
coluna anulável no estágio Sequential File? Deve ser uma sequência de caracteres
vazia? Deve ser a palavra "NULL" ou algum outro valor? O estágio Sequential File
permite especificar o valor. Pode ser qualquer valor que dê suporte ao seu
propósito comercial.

Especificação de um valor para nulo
Coluna Nullable
Propriedade
incluída
Especificação de um valor para nulo

Esse gráfico mostra a janela de propriedades estendidas para uma coluna anulável
no estágio Sequential File. Para especificar um valor para nulo, inclua a
propriedade Null field value opcional. Então, especifique um valor para essa
propriedade. O valor pode ser qualquer um que você queira: a sequência de
caracteres vazia ("") a palavra "unknown", qualquer coisa. O valor nem sequer
precisa corresponder ao tipo de coluna. Por exemplo, é possível usar "unknown"
para representar valores inteiros nulos.
O que acontece se você não especificar um valor para uma coluna anulável e nulo
for gravado na coluna no tempo de execução? A tarefa não é interrompida. A linha é
rejeitada.
Observe que, na guia Format, é possível especificar um valor padrão para todas as
colunas anuláveis no estágio.

Exemplo de sequência de caracteres vazia

• Se você desejar que dois delimitadores de coluna sem nada entre
eles signifiquem nulo, especifique a sequência de caracteres vazia ("")
como o Null field value
Valor da
sequência de
caracteres vazia
Exemplo de sequência de caracteres vazia

O gráfico mostra como especificar a sequência de caracteres vazia ("") como o
valor nulo. Inclua a propriedade Null field value e depois digite duas aspas sem
espaços. As aspas podem ser simples ou duplas. Aqui, e em geral, o DataStage
permite qualquer uma.

Visualização de dados com nulos

• Ao clicar em View Data, valores nulos, independentemente do seu
valor real no arquivo, aparecem como "NULL"
• Para ver os valores reais que representam nulo, é preciso visualizar o
arquivo de dados real
Valor da sequência
de caracteres vazia
Visualização de dados com nulos

Esse gráfico mostra como valores nulos são exibidos ao clicar no botão View Data.
Independentemente do valor real no arquivo, o valor é exibido pela palavra "NULL".
Isso, às vezes, confunde os desenvolvedores do DataStage. Por exemplo, eles
acabaram de especificar a palavra "unknown" para representar nulo. Porém, parece
que a palavra "unknown" não foi gravada no arquivo. No entanto, se você verificar
diretamente no arquivo (em um editor de texto) no sistema de servidor do
DataStage, localizará a palavra "unknown", e não a palavra "NULL".

Demonstração 2
Leitura e gravação de valores nulos

 Ler valores que significam nulo de um arquivo sequencial
 Gravar valores que significam nulo em um arquivo sequencial
Demonstração 2: Leitura e gravação de valores nulos

Demonstração 2:
Leitura e gravação de valores nulos
Propósito:
Você deseja ler e gravar valores NULL usando um arquivo sequencial. Os
valores NULL entram no fluxo de tarefas em vários locais nas tarefas do
DataStage. Você deseja verificar como os valores NULL são manipulados no
contexto de leitura e gravação em arquivos sequenciais.
NOTA:
Nesta demonstração e em outras demonstrações neste curso, pode haver atividades
que iniciam com tarefas que você foi instruído a criar em atividades anteriores. Se você
não tiver conseguido concluir a tarefa anterior, pode importá-la do arquivo
DSEssLabSolutions_V11_5_1.dsx no diretório de arquivos
C:\CourseData\DSEss_Files\dsx. Esse arquivo contém todas as tarefas construídas
nas demonstrações para este curso.
Nota: se for necessário importar (e substituir seu trabalho salvo existente), renomeie o
elemento existente para você não perder o que criou. Isso evitará sobrescrever (e
perder) o trabalho que você fez até agora no curso.
Etapas:
1. No menu do Designer, clique em Import e depois em DataStage
Components.
2. Selecione a opção Import selected (isso permitirá que você selecione e
escolha o que deseja importar) e depois selecione o elemento requerido na
lista de elementos exibida.
Tarefa 1. Leia valores NULL de um arquivo sequencial.
1. Abra a tarefa CreateSeqJobParam.

2. Salve sua tarefa como CreateSeqJobNULL.
3. Em Windows\All Programs\Accessories, clique em WordPad.

4. No menu File, no Wordpad, clique em Open.
5. Na janela Open, mude o tipo de arquivo para Text Documents (*.txt), se ainda
não estiver aparecendo, e procure no seguinte caminho para abrir o arquivo:
C:\CourseData\DSEss_Files\Selling_Group_Mapping_Nulls.txt.
Observe, nos dados, que a coluna Special_Handling_Code contém alguns

valores de números inteiros de 1. Observe também que a última coluna
(Distr_Chann_Desc) está sem alguns valores.
Para testar como ler NULLs, vamos presumir que 1 na terceira coluna significa
NULL e que a ausência de um valor na última coluna também significa NULL.
Nas etapas a seguir, você especificará isso.

6. Abra o estágio Sequential de origem na guia Columns. Clique duas vezes à

esquerda da coluna Special_Handling_Code para abrir a janela Edit Column
Meta Data.
7. Mude o campo Nullable para Yes. Observe que a pasta Nullable aparece no
painel Properties. Selecione essa pasta e inclua a propriedade Null field
value. Especifique um valor de 1 para ela.
8. Clique em Apply e, em seguida, clique em Next.

9. Move para a coluna Distribution_Channel_Description. Defina esse campo

para anulável. Inclua a propriedade Null field value. Aqui, você tratará a
sequência de caracteres vazia como significando NULL. Para fazer isso,
especifique "" (aspas duplas em sequência).
10. Clique em Apply e, em seguida, clique em Close.

11. Na guia Properties, para a propriedade File, selecione o arquivo
Selling_Group_Mapping_Nulls.txt.
12. Clique no botão View Data.
Observe que os valores interpretados pelo DataStage como NULL aparecem
como a palavra "NULL", não importa seu valor atual no arquivo.
13. Clique em Close e depois em OK.


Ela deve ser interrompida, já que valores NULL serão gravados em colunas
não anuláveis no seu destino.
15. Visualize o log da tarefa para ver as mensagens.
Tarefa 2. Grave valores NULL em um arquivo sequencial.

1. Salve sua tarefa como CreateSeqJobHandleNULL.
2. Abra o estágio Sequential File de destino para a guia Columns. Especifique que a
coluna Special_Handling_Code e a coluna Distribution_Channel_Description
são anuláveis.
O que acontece?
Nesse caso, a tarefa não é interrompida, já que os valores NULL não estão
sendo gravados em colunas não anuláveis. Porém, as linhas com valores
NULL são rejeitadas porque os valores NULL não estão sendo manipulados.
Elas são gravadas no estágio Peek TargetRejects e é possível visualizá-las no
log da tarefa.
Agora, deixe-nos manipular os valores NULL. Ou seja, especificaremos os

valores a serem gravados no arquivo de destino que representa NULLs.

4. Abra o estágio de destino na guia Columns e especifique:

 Coluna Special_Handling_Code, valor do campo Null de -99999.
 Coluna Distribution_Channel_Description, valor do campo Null
UNKNOWN.
O procedimento é o mesmo que quando o estágio Sequential é usado como
uma origem (Tarefa 1 desta demonstração)
Os resultados aparecem da seguinte forma:
5. Compile e execute sua tarefa. Visualize o log da tarefa. Você não deve receber
nenhum erro ou rejeição.
6. Clique em View Data no estágio Sequential File de destino para verificar os
resultados.
7. Para ver os valores reais gravados no arquivo, abra o arquivo TargetFile.txt no
diretório DSEss_Files\Temp. Verifique os valores -99999 e UNKNOWN.
Nota: Ao visualizar os dados no DataStage, tudo o que você vê é a palavra
"NULL", não os valores reais. Para ver os valores reais, seria preciso abrir o
arquivo de dados no sistema de servidor do DataStage em um editor de texto.
Resultados:
Você lê e grava valores NULL usando um arquivo sequencial. Os valores
NULL entram no fluxo de tarefas em vários locais nas tarefas do DataStage.
Você verificou como os valores NULL são manipulados no contexto de leitura
e gravação em arquivos sequenciais.

Estágio Data Set

• Arquivo de dados binário
• Preserva o particionamento
 Os arquivos do conjunto de dados do componente são gravados em cada
partição
• Recebe o sufixo .ds
• Referido por um arquivo de cabeçalho
• Gerenciado pelo utilitário Data Set Management da GUI
(Designer, Director)
• Representa dados persistentes
• Segredo para bom desempenho em um conjunto de tarefas vinculadas
 Não há necessidade de conversões de importação/exportação
 Não há necessidade de particionamento
• Acessado usando o estágio Data Set
• Vinculado a um arquivo de configuração em particular
Estágio Data Set

Os conjuntos de dados representam dados persistentes mantidos no formato
interno do DataStage. Eles são arquivos, mas de um tipo especial, muito diferente
de arquivos sequenciais. Para identificar um arquivo como um arquivo do conjunto
de dados, aplique a extensão .ds ao nome do arquivo.
Há dois recursos principais de conjuntos de dados. Primeiro, eles contêm dados
binários, assim, seus dados não podem ser visualizados usando um editor de texto
comum. Nesse sentido, eles diferem de conjuntos de arquivos, que serão
discutidos mais adiante nesta unidade.
Em segundo lugar, os conjuntos de dados contêm dados particionados. Seus dados
são particionados de acordo com o número de nós no arquivo de configuração
usado para criar o conjunto de dados. Arquivos de componente de dados
individuais, referidos por um arquivo de cabeçalho, existem em cada nó identificado
no arquivo de configuração.
Os conjuntos de dados são o segredo para o bom desempenho entre um conjunto
de tarefas paralelas vinculadas. Uma tarefa pode gravar em um conjunto de dados
que a tarefa seguinte lê sem coletar os dados para um único nó, o que reduziria o
desempenho.

Tarefa com um estágio Data Set de destino

Estágio Data
Set
Propriedades do
estágio Data Set
Tarefa com um estágio Data Set de destino

O gráfico superior exibe uma tarefa com um estágio Data Set de destino. O gráfico
inferior exibe a guia Properties do estágio Data Set. A propriedade File foi definida
para o nome e o caminho do conjunto de dados. Esse é o local real do arquivo de
cabeçalho do conjunto de dados. Os arquivos do componente de dados vinculado
estarão localizados em outro lugar, em cada um dos nós.

Utilitário Data Set Management
Exibição de dados
Exibição do
esquema
Exibição das contagens

de registros para cada
partição
Utilitário Data Set Management

Esse gráfico exibe a janela Data Set Management.
A janela está disponível tanto no Designer quanto no Director. No Designer, clique
em Tools > Data Set Management para abrir a janela.
Clique no ícone Show Schema na parte superior da janela para visualizar o
esquema do conjunto de dados. Um conjunto de dados contém os próprios
metadados de coluna na forma de um esquema. Um esquema é a versão do
conjunto de dados de uma definição de tabela.
Clique no ícone Data Set Viewer para visualizar os dados no conjunto de dados.
Os registros podem ser exibidos para cada partição individual ou conjuntamente.

Dados e esquema exibidos
Visualizador de
dados
Esquema descrevendo o
formato dos dados
Dados e esquema exibidos

O gráfico esquerdo mostra os dados do conjunto de dados da janela Data Set
Viewer. O gráfico direito mostra a janela Record Schema, descrevendo o formato
dos dados. Observe que o registro consiste em nomes de colunas seguidos por
tipos de dados. Os tipos de dados são C++. No nível da GUI do DataStage, a maior
parte dos tipos de dados de coluna são dos tipos SQL. Internamente, o DataStage
usa tipos C++.

Estágio File Set

• Use para ler e gravar em conjuntos de arquivos
• Arquivos sufixados por .fs
• Similar a um conjunto de dados
 Particionado
• Como os conjuntos de arquivo diferem de conjuntos de dados
 Conjuntos de arquivos são legíveis por editores de texto (não binários)
− Assim, são adequados para arquivamento
Estágio File Set

Conjuntos de arquivos são similares a conjuntos de dados. Como conjuntos de
dados, eles são particionados. Ambos têm cabeçalhos, que fazem referência aos
arquivos de dados do componente em cada partição.
A principal diferença é que eles são legíveis por editores de texto comuns. Isso
reduz levemente o desempenho em comparação a conjuntos de dados, mas o
torna adequados para arquivamento.

Demonstração 3
Trabalho com conjuntos de dados

 Gravar em um conjunto de dados
 Usar o utilitário Data Set Management para visualizar os dados em um
conjunto de dados
Demonstração 3: Trabalho com conjuntos de dados

Demonstração 3:
Trabalho com conjuntos de dados
Propósito:
Os conjuntos de dados são adequados como arquivos de preparação
temporários entre tarefas do DataStage. Aqui, você gravará em um conjunto
de dados e depois visualizará os dados no conjunto de dados usando o
utilitário Data Set Management.
NOTA:
Etapas:
1. Clique em Import e depois em DataStage Components.
2. Selecione a opção Import selected e selecione a tarefa desejada na lista
exibida.
Se você quiser salvar uma versão anterior da tarefa, salve-a com um novo nome antes
de importar a versão do arquivo de soluções de demonstração.
Tarefa 1. Grave em um conjunto de dados
1. Abra a tarefa CreateSeqJob e salve-a como CreateDataSetJob.
2. Exclua o estágio sequencial de destino, deixando um link suspenso.
3. Arraste um estágio Data Set da pasta File da Pallete para a tela e conecte-o ao
link suspenso. Mude o nome do estágio de destino para
Selling_Group_Mapping_Copy.

4. Edite as propriedades do estágio Data Set de destino. Grave em um arquivo

chamado Selling_Group_Mapping.ds no diretório DSEss_Files\Temp.
5. Abra o estágio Sequential File de origem e inclua a propriedade opcional para

definir o número de leitores por nó. Clique em Yes quando receber a
mensagem de aviso. Mude o valor da propriedade para 2.
(Isso assegurará que os dados sejam gravados em mais de uma partição.)
6. Compile e execute sua tarefa. Verifique se há erros no log da tarefa. É possível
ignorar com segurança a mensagem de aviso sobre o registro 0.

Tarefa 2. Visualize um conjunto de dados.

1. No Designer, clique em Tools > Data Set Management. Procure o conjunto de
dados que foi criado. Observe quantos relatórios foram gravados em cada uma
das duas partições.
2. Clique no ícone Show Data Window na parte superior da janela. Selecione a

partição número 1. Isso somente exibirá os dados na segunda partição.
3. Clique em OK para visualizar os registros nessa partição.

4. Clique no ícone Show Schema Window na parte superior da janela para

visualizar o esquema do conjunto de dados.
Um conjunto de dados contém os próprios metadados de coluna na forma de
um esquema. Um esquema é a versão do conjunto de dados de uma definição
de tabela.
Resultados:
Você gravou em um conjunto de dados e, então, visualizou os dados no
conjunto de dados usando o Utilitário Data Set Management.

1. Liste três tipos de dados do arquivo.
2. O que torna o desempenho dos conjuntos de dados melhor que
o de arquivos sequenciais em tarefas paralelas?
3. Qual é a diferença entre um conjunto de dados e um conjunto de
arquivos?


1. Arquivos sequenciais, conjuntos de dados, conjuntos de arquivos.
2. Eles são particionados e armazenam dados no formato paralelo
nativo.
3. Ambos são particionados. Os conjuntos de dados armazenam
dados em um formato binário não legível pelos aplicativos de
usuário. Os conjuntos de arquivos são legíveis.

Resumo da unidade
• Entender os estágios para acessar diferentes tipos de dados de
arquivo
• Ler e gravar arquivos sequenciais usando o estágio Sequential File
• Ler e gravar em arquivos do conjunto de dados usando o estágio Data
Set
• Criar links de rejeição
• Trabalhar com nulos em arquivos sequenciais
• Ler de vários arquivos sequenciais usando padrões do arquivo
• Usar vários leitores
Resumo da unidade


Unidade 7 Algoritmos de particionamento e coleta
Algoritmos de
particionamento e coleta

Unidade 7 Algoritmos de particionamento e cole ta

• Descrever a arquitetura de processamento paralelo
• Descrever paralelismo de pipeline
• Descrever paralelismo de partição
• Listar e descrever algoritmos de particionamento e coleta
• Descrever arquivos de configuração
• Descrever o processo de compilação de tarefa paralela
• Explicar OSH
• Explicar a pontuação
Algoritmos de particionamento e coleta © Copyright IBM Corporation 2015
Propósito - os desenvolvedores do DataStage precisam de uma compreensão
básica da arquitetura paralela e da estrutura para desenvolver tarefas eficientes e
robustas.

• Divida o fluxo de entrada de dados em subconjuntos a serem
processados separadamente por um estágio/operação
 Os subconjuntos são chamados de partições (nós)
 Facilita o processamento de alto desempenho
−2 nós = duas vezes mais desempenho
− 12 nós = doze vezes mais desempenho
• Cada partição de dados é processada pelo mesmo estágio/operação
 Se o estágio for um estágio Transformer, cada partição será processada
pelas instâncias do mesmo estágio Transformer
• O número de partições é determinado pelo arquivo de configuração
• O particionamento ocorre no nível do estágio
 No link de entrada de um estágio que está particionando, o estágio
determina o algoritmo que será usado para particionar os dados
O particionamento rompe o fluxo de dados em conjuntos menores que são
processados de modo independente, em paralelo. Esse é um segredo da
escalabilidade. É possível aumentar o desempenho aumentando o número de
partições, presumindo que você tenha o número de processadores físicos para
processá-las. Embora haja limites ao número de processadores razoavelmente
disponíveis em um único sistema, há suporte para uma configuração GRID que
distribui o processamento entre um conjunto de sistemas de computador em rede.
Não há limite ao número de sistemas (e, portanto, de processadores) que podem
ser conectados em rede.
Os dados precisam ser distribuídos uniformemente pelas partições; de outra forma,
os benefícios da partição serão reduzidos.
É importante notar que o que é feito em cada partição de dados é igual. Cópias
exatas de cada estágio/operador são executadas em cada partição.

Particionamento de estágio
Estágio/operação Nó 0
subconjunto 1
subconjunto 2
Dados Estágio/operação Nó 0
subconjunto 3
Estágio/operação Nó 0
• Aqui os dados são particionados em três partições

• A operação é executada em cada partição de dados separadamente e
em paralelo
• Se os dados forem distribuídos uniformemente, os dados serão
processados três vezes mais rápido
Particionamento de estágio
Este diagrama ilustra como o particionamento de estágio funciona. Subconjuntos
do total de dados vão para cada partição, nas quais o mesmo estágio ou operação
é aplicado. O modo como os dados são particionados é determinado pelo algoritmo
de particionamento de estágio que é utilizado.
O diagrama está mostrando apenas um estágio. Tarefas típicas envolvem muitos
estágios. Em cada estágio, ocorre particionamento, reparticionamento ou coleta.

Ambientes de hardware do DataStage

Disco dedicado Disco compartilhado Nada compartilhado
Disco Disco
CPU CPU CPU CPU

CPU
MEMÓRIA COMPARTILHADA
MEMÓRIA
MPP, sistemas em clusters
Sistema SMP
(processamento paralelo massivo)
Uniprocessador (multiprocessador
simétrico)
• Grade/cluster
• CPU única • SMP
 Sistemas múltiplos com
• Memória dedicada • Várias CPUs (2-64+) várias CPU
 Memória dedicada por nó
e disco
• Memória  Armazenamento
compartilhada e compartilhado típico
baseado em SAN
disco
• MPP
 Vários nós com memória
e armazenamento
dedicados
• 2 – Milhares de CPUs
Ambientes de hardware do DataStage

Este gráfico ilustra os três ambientes de hardware que podem ser usados para
executar tarefas do DataStage: CPU, SMP e GRID únicos.
As tarefas paralelas do DataStage são projetadas para ser independentes de
plataforma. Uma única tarefa, se projetada corretamente, pode funcionar através de
recursos dentro de uma única máquina (única CPU ou SMP) ou várias máquinas
(arquiteturas de cluster, GRID ou MPP).
Embora tarefas paralelas possam ser executadas em um ambiente de uma única
CPU, o DataStage é projetado para tirar proveito de plataformas paralelas.

Algoritmos de particionamento
• Round robin
• Random
• Hash: determina a partição com base no valor da chave
 Requer especificação de chave
• Modulus
 Requer especificação de chave
• Entire: envia todas as linhas para todas as partições
• Same: preserva o mesmo particionamento
• Auto: deixa o DataStage escolher o algoritmo
 O DataStage escolhe o algoritmo com base no tipo de estágio
Algoritmos de particionamento
Os algoritmos de particionamento determinam como o estágio particiona os dados.
Aqui são mostrados os principais algoritmos usados. Você não precisa especificar
explicitamente um algoritmo para cada estágio. A maioria dos tipos de estágios é,
por padrão, definida para Auto, o que permite ao DataStage escolher o algoritmo
com base no tipo de estágio.
Não pense em Same como um algoritmo de particionamento separado. Ele sinaliza
que o estágio deve usar o mesmo algoritmo de particionamento adotado pelo
estágio anterior, qualquer que seja ele.

Coleta (1 de 2)
• A coleta retorna dados particionados de volta para um único fluxo
 Algoritmos de coleta determinam como os dados são coletados
• A coleta reduz o desempenho, mas:
 Às vezes é necessária para um propósito comercial
− Por exemplo, queremos carregar os dados em um único arquivo sequencial
 Às vezes é requerida pelo estágio
− Alguns estágios, principalmente anteriores, são executados apenas no modo
sequencial
− Os estágios, às vezes, são executados no modo sequencial para obter um
determinado resultado, por exemplo, uma contagem global de todos os
registros
Coleta
A coleta é o oposto do particionamento. A coleta retorna dados particionados de
volta para um único fluxo. Os algoritmos de coleta determinam como os dados são
coletados.
De um modo geral, é o processamento paralelo dos dados que impulsiona o
desempenho da tarefa. Em geral, então, é preferível evitar a coleta dos dados. No
entanto, a coleta costuma ser necessária para atender às necessidades de
negócios. Alguns tipos de estágios são executados no modo sequencial. Por
exemplo, os estágios Sequential File e Row Generator são ambos executados por
padrão no modo sequencial.

Coleta (2 de 2)
Estágio/operação
Nó 0
Estágio/operação Estágio/operação
Nó 1
Estágio/operação
Nó 2
• Aqui, os dados são coletados de três partições até um único nó

• No link de entrada de um estágio que está coletando, o estágio
determina o algoritmo que será usado para coletar os dados
Este diagrama ilustra como os dados nas três partições são coletados em um único
fluxo de dados. O estágio inicial, mostrado aqui, está sendo executado em paralelo
em três nós. O segundo estágio está sendo executado sequencialmente. Para dar
suporte à operação do segundo estágio, todos os dados precisam ser coletados em
um único nó (Node 0).
Assim como ocorre com o particionamento, há diferentes algoritmos que o segundo
estágio pode usar para coletar os dados. Em geral, por padrão, o algoritmo é
"obtido da linha que chega primeiro".

Coleta de algoritmos
• Round robin
• Auto
 Coleta o primeiro registro disponível
• Sort Merge
 Lê por chave
 Presume que os dados são classificados pela chave de coleção em cada
partição
 Compila um único fluxo classificado com base na chave
• Ordered
 Lê todos os registros da primeira partição, então da segunda e assim por
diante
Coleta de algoritmos
É mostrada uma lista dos principais algoritmos de coleta. Por padrão, a maioria dos
estágios é definida para Auto, o que deixa o DataStage decidir qual algoritmo usar.
Na maioria dos casos, isso é feito para coletar a próxima linha disponível.
Sort Merge é o algoritmo de coleta usado com mais frequência além de Auto. É
usado para compilar uma coleção global de dados classificada de várias partições
de dados classificados.

Algoritmos de particionamento sem chave versus com chave

• Sem chave: as linhas são distribuídas de modo independente dos
valores de dados
 Round Robin
 Random
 Entire
 Same
• Com chave: as linhas são distribuídas com base nos valores na
chave especificada
 Hash: partição com base na chave
− Exemplo: a chave é um estado. Todas as linhas "CA" vão para a mesma
partição; todas as linhas "MA" vão para a mesma partição. Duas linhas do
mesmo estado nunca vão para partições diferentes
 Modulus: partição com base na chave dividida pelo número de partições.
A chave é um tipo numérico
− Exemplo: a chave é OrderNumber (tipo numérico). As linhas com o mesmo
número de ordem também vão para a mesma partição
 DB2: combina com o particionamento DB2 Enterprise Edition
Algoritmos de particionamento sem chave versus com chave

Os algoritmos de particionamento podem ser divididos em duas categorias
principais: com chave e sem chave. A primeira distribui os dados com base nos
dados em uma ou mais colunas-chave. A segunda distribui os dados de modo
independente dos valores dos dados. Entre os algoritmos sem chave estão Round
Robin, Random, Entire e Same.
O algoritmo de particionamento de chave primária é Hash. Esse algoritmo é
mapeado para valores de dados em uma ou mais colunas para números de partição.
Cada ocorrência do mesmo valor de dados na coluna-chave tem a garantia de ir
para a mesma partição. Por exemplo, suponha que uma coluna-chave seja State e
que haja várias linhas de dados com o mesmo valor "CA" na coluna-chave. Todas
essas linhas irão para a mesma partição. Não sabemos qual, mas sabemos que,
para onde quer que uma vá, as outras irão também.

Particionamento Round Robin e Random

• Métodos de particionamento
sem chave Sem chave
• As linhas são distribuídas por
igual nas partições …8 7 6 5 4 3 2 1 0
 Bom para importação inicial de

dados se nenhum outro
particionamento for necessário
Round Robin
 Útil para a redistribuição de
dados
• Baixa sobrecarga
• Round Robin atribui linhas a
partições como em uma 6 7 8
3 4 5
distribuição de cartas de baralho 0 1 2
• Random possui uma sobrecarga
levemente maior, mas atribui
linhas de modo não determinista
entre as execuções da tarefa
Particionamento Round Robin e Random

O diagrama ilustra o método de particionamento Round Robin. Round Robin
atribui linhas a partições como em uma distribuição de cartas de baralho. A primeira
linha vai para a primeira partição; a segunda vai para a segunda partição e assim
por diante. A principal vantagem de usar o algoritmo de particionamento Round
Robin é que ele distribui de maneira uniforme os dados em todas as partições.
Como mencionado anteriormente, isso gera o melhor desempenho.
Random tem um resultado similar de distribuir as linhas de modo mais ou menos
uniforme (embora não perfeitamente, é claro). Porém, não há ordenação fixa das
linhas nas partições. Para determinados conjuntos de dados iniciais, isso pode ser
desejável. Random tem uma sobrecarga levemente maior que Round Robin.

Particionamento Entire
• Cada partição recebe uma cópia Sem chave
completa dos dados …8 7 6 5 4 3 2 1 0
 Pode afetar o desempenho devido à
duplicação de dados
• Entire é o algoritmo de Entire
particionamento padrão para os links
de referência do estágio Lookup
 Em plataformas SMP, o estágio
Lookup utiliza memória compartilhada
em vez de duplicar todo o conjunto de . . .
dados de referência . . .
3 3 3
 Em plataformas Grid, ocorrerá 2 2 2
1 1 1
duplicação de dados 0 0 0
Particionamento Entire
O diagrama ilustra o método de particionamento Entire. Cada partição recebe uma
cópia completa de todos os dados. Entire é o algoritmo de particionamento padrão
para os links de referência da consulta. Isso garante que a procura por uma linha
correspondente na tabela de consulta sempre obtenha sucesso, caso haja uma
correspondência. A linha não pode ficar "oculta" em outra partição, já que todas as
linhas estão em todas as partições.

Particionamento Hash
Com chave
• Método de particionamento com
chave
• As linhas são distribuídas de Valores da coluna-chave
acordo com os valores nas …0 3 2 1 0 2 3 2 1 1
colunas-chave
 Garante que as linhas com os
mesmos valores da chave vão para
Hash
a mesma partição
 Necessário para impedir que linhas
correspondentes fiquem "ocultas"
em outras partições
 Os dados podem se tornar
0 1 2
distribuídos de modo não uniforme 3 1 2
entre as partições, dependendo das 0 1 2
frequências dos valores de coluna- 3
chave
• Selecionado por padrão para os
estágios Aggregator, Remove
Duplicates, Join
Particionamento Hash
Para determinados estágios (Remove Duplicates, Join, Merge) funcionarem
corretamente em paralelo, Hash – ou um dos algoritmos similares (Range,
Modulus) – é necessário. A seleção padrão Auto seleciona Hash para esses
estágios.
O diagrama ilustra o método de particionamento Hash. Aqui, os números não são
mais identificadores de linha, mas os valores da coluna-chave. Hash garante que
todas as linhas com valores da chave 3, por exemplo, acabem na mesma partição.
Hash não garante "continuidade" entre os mesmos valores. Observe, no diagrama,
que há zeros separando alguns dos números três.
Hash também não garante balanceamento de carga. Algumas partições podem ter
muito mais linhas que outras. Escolhas colunas-chave que tenham valores
diferentes o suficiente para distribuir os dados entre as partições disponíveis.
Gender, por exemplo, seria uma má escolha de uma chave. Todas as linhas iriam
para apenas algumas partições, independentemente de quantas partições estão
disponíveis.

Particionamento Modulus
Com chave
• As linhas são distribuídas de
acordo com os valores em uma Valores da coluna-chave
coluna-chave numérica
…0 3 2 1 0 2 3 2 1 1
 Usa a partição
Modulus = MOD
(key_value/número de partições)
Modulus
• Mais rápido que Hash
• Equivalente a Hash em termos
lógicos
0 1 2
3 1 2
0 1 2
3
Particionamento Modulus
Modulus funciona do mesmo modo que Hash. A única diferença é que ele requer
que a coluna-chave seja numérica. Uma vez que a coluna-chave está restrita a
tipos numéricos, o algoritmo é um pouco mais rápido que Hash.

Particionamento Auto
• O DataStage insere operadores de partição conforme necessário
para assegurar resultados corretos
 Em geral, escolhe Round Robin ou Same
 Insere hash em estágios que requerem valores da chave
correspondentes
(Join, Merge, Remove Duplicates)
 Insere Entire nos links de referência do estágio Lookup
• Uma vez que o DataStage tem reconhecimento limitado dos seus
dados e regras de negócio, pode ser útil especificar explicitamente
Hash ou outro particionamento
 O DataStage não possui visibilidade na lógica Transformer
 O DataStage pode escolher algoritmos de particionamento mais
dispendiosos do que você sabe serem necessários
− Verifique a pontuação no log da tarefa para determinar o algoritmo utilizado
Particionamento Auto
Auto é a escolha padrão dos estágios. Contudo, não pense em Auto como um
algoritmo de particionamento separado. Ele indica que DataStage deve escolher o
algoritmo específico. A escolha do DataStage geralmente é baseada no tipo de
estágio.
Auto geralmente escolhe Round Robin ao ir de estágios sequenciais para
paralelos. Em geral, ele escolhe Same ao ir de estágios paralelos para paralelos.
Ele escolhe o último para evitar reparticionamento desnecessário, que reduz o
desempenho.
Visto que o DataStage possui reconhecimento limitado de seus dados e regras de
negócios, a melhor prática é especificar explicitamente o particionamento Hash
quando necessário, ou seja, quando o processamento precisa de grupos de
registros relacionados.

Requisitos de particionamento para registros relacionados

• Registros mal posicionados
 Uso do estágio Aggregator para somar vendas do cliente por número de
cliente
 Se houver 25 clientes, o resultado será de 25 registros
 No entanto, suponha que registros com os mesmos números de cliente
sejam distribuídos entre partições
− Isso produzirá mais de 25 grupos (registros)
 Solução: usar o algoritmo de particionamento Hash
• Desequilíbrios de partição
 Se todos os registros estiverem percorrendo apenas um dos nós, a tarefa
estará, na verdade, sendo executada sequencialmente
Requisitos de particionamento para registros relacionados

Escolha o algoritmo de particionamento correto para evitar registros mal
posicionados e desequilíbrios de partição, como descrito aqui.
Desequilíbrios de particionamento ocorrem quando os números de registros
percorrendo algumas das partições disponíveis excedem muito os números de
registros percorrendo outras. A quantidade de tempo que leva para processar as
partições com mais registros será, obviamente, maior que a quantidade de tempo
que leva para processar as partições com menos registros. O ponto crucial a
perceber é que a quantidade total de tempo da tarefa é o tempo total que leva para
processar a partição mais lenta. Ou seja, a tarefa não é concluída até que todas as
partições sejam concluídas.
O problema de registros mal posicionados ocorre quando o conjunto total de
registros necessários para realizar um determinado cálculo não está disponível
dentro da partição. Ou seja, alguns dos registros estão em outras partições. O que
acontece é que, em vez de haver um único cálculo de todos os registros para o
cliente X, haverá vários cálculos para o cliente X, um para cada uma das partições
que o cliente X registra. Para evitar isso, todos os registros do cliente X precisam
estar em uma, e apenas uma, partição.

Exemplo de desbalanceamentos de partição
• Os mesmos valores da • Hash em LName, com arquivo de

chave são atribuídos à configuração de dois nós
mesma partição
Parte 0
ID LName FName Endereço
Dados de origem

5 Dodge Horace 17840 Jefferson
6 Dodge John 75 Boston Boulevard

1 Ford Henry 66 Edison Avenue
2 Ford Clara 66 Edison Avenue
Partição 1
3 Ford Edsel 7900 Jefferson
1 Ford Henry 66 Edison Avenue

4 Ford Eleanor 7900 Jefferson
2 Ford Clara 66 Edison Avenue
3 Ford Edsel 7900 Jefferson

5 Dodge Horace 17840 Jefferson
4 Ford Eleanor 7900 Jefferson
6 Dodge John 75 Boston Boulevard 7 Ford Henry 4901 Evergreen
8 Ford Clara 4901 Evergreen
7 Ford Henry 4901 Evergreen 9 Ford Edsel 1100 Lakeshore
10 Ford Eleanor 1100 Lakeshore

8 Ford Clara 4901 Evergreen
9 Ford Edsel 1100 Lakeshore
10 Ford Eleanor 1100 Lakeshore
Exemplo de desbalanceamentos de partição

Este é um exemplo de um desbalanceamento de partição de linhas em diferentes
partições. A distribuição da partição corresponde à distribuição de dados de origem.
Neste exemplo, o número menor de valores de chave de Hash distintos limita o
benefício do paralelismo. A tarefa não será concluída até que todas as linhas na
partição 1 sejam processadas. Na verdade, essa tarefa não será executada com
mais rapidez do que se estivesse sendo executada em sequência, com todas as
linhas em uma única partição.

Ícones do link de particionamento/coleta
Indica que os
dados estão sendo
particionados
Indica que os
dados estão sendo
coletados
Ícones do link de particionamento/coleta

Esse gráfico destaca os ícones de particionamento nos links de uma tarefa.
O ícone "fan out" (à esquerda) indica que os dados estão sendo particionados. Ou
seja, os dados estão se movendo de um nó (partição) para vários nós (partições).
O ícone "fan in" indica que os dados estão sendo coletados. Ou seja, os dados
estão se movendo de vários nós para um único nó. O algoritmo em particular que
está sendo usado para particionamento/coleta não é indicado.

Mais ícones de particionamento
Mesmo particionador
"Borboleta" indica
reparticionamento Particionador
automático
Mais ícones de particionamento

Esse gráfico destaca mais ícones de particionamento em uma tarefa.
Alguns ícones indicam o algoritmo de particionamento que está sendo usado. Aqui,
os ícones indicando Auto e Same são destacados. O ícone de "borboleta" indica
que está ocorrendo reparticionamento. Ou seja, linhas de dados em algumas
partições estão se movendo para outras partições. Isso é algo a se observar.
Dados movendo-se entre partições podem afetar o desempenho, especialmente
em um GRID, em que dados reparticionados se deslocam na rede.

Especificação de um algoritmo de particionamento
Guia Partitioning
Guia Input
Seleção de colunas-chave
Tipo de partição
Seleção de algoritmo
Especificação de um algoritmo de particionamento

Esse gráfico exibe a guia Input > Partitioning em um estágio de exemplo. Todos
os algoritmos de particionamento, a partir dos quais é possível escolher, são
exibidos.
Se você selecionar um algoritmo de particionamento com chave (por exemplo,
Hash), será preciso selecionar a coluna ou colunas que compõem a chave.
Selecione algoritmos de particionamento e de coleta na guia Input > Partitioning.
Como determinar se o estágio está particionando ou coletando? As palavras logo
acima da lista indicam isso. Se você visualizar Partition type, em vez de Collector
type, sabe que o estágio está particionando.

Especificação de um algoritmo de coleta
Guia Partitioning
Seleção de colunas-chave
Tipo de coletor
Especificação de um algoritmo de coleta

Esse gráfico exibe a guia Input > Partitioning em um estágio de exemplo. Os
algoritmos de coleta entre os quais se pode escolher são listados. Observe as
palavras Collector type acima da lista, indicando que o estágio está coletando, em
vez de particionando.

• Determina o número de nós (partições) em que a tarefa é executada
• Especifica os recursos que podem ser usados por nós individuais
para:
 Armazenamento temporário
 Estouro de memória
 Armazenamento de dados do conjunto de dados
• Especifica os "conjuntos de nós"
 Usado para restringir estágios (operadores) ao uso de determinados nós
 A configuração da variável de ambiente $APT_CONFIG_FILE determina
qual arquivo de configuração está em vigor durante uma execução da
tarefa
 Se você incluir $APT_CONFIG_FILE como um parâmetro da tarefa, poderá
especificar no tempo de execução qual arquivo de configuração uma tarefa
usa
O arquivo de configuração determina o número de nós (partições) em que uma
tarefa é executada. A configuração em vigor para uma execução da tarefa em
particular é o arquivo de configuração atualmente referido pela variável de
ambiente $APT_CONFIG_FILE. Essa variável tem um padrão de projeto ou pode
ser incluída como um parâmetro da tarefa para uma tarefa.
Além de determinar o número de nós, o arquivo de configuração especifica os
recursos que podem ser usados pela tarefa em cada um dos nós. Esses recursos
incluem armazenamento temporário, armazenamento para conjuntos de dados e
armazenamento temporário que pode ser usado quando a memória se esgota.

Exemplo de arquivo de configuração
Nome do nó
Recursos do nó
Exemplo de arquivo de configuração

Esse gráfico exibe um exemplo de arquivo de configuração com dois nós. Os
nomes do nó são especificados pelo usuário. Observe as entradas de recurso para
cada nó. Elas especificam os recursos que podem ser usados pela tarefa para os
estágios em execução no nó.
No log da tarefa, abra a mensagem chamada main_program: APT configuration
file… para exibir o arquivo de configuração usado pela tarefa durante aquela
execução da tarefa.
A entrada fastname indica o nome da rede do sistema de computador em que o nó
existe. Neste exemplo, ambos os nós existem em EDSERVER.

Inclusão de $APT_CONFIG_FILE como um parâmetro da

tarefa
Incluir variável de
$APT_CONFIG_FILE
ambiente
Inclusão de $APT_CONFIG_FILE como um parâmetro da tarefa

Esse gráfico mostra a guia Parameters na janela Job Properties para uma tarefa
aberta no Designer.
Se você incluir a variável de ambiente $APT_CONFIG_FILE como um parâmetro
da tarefa, poderá selecionar, no tempo de execução, o arquivo de configuração que
a tarefa deve usar. Caso não seja incluída, a tarefa usará o arquivo de configuração
padrão especificado para o projeto.

Edição dos arquivos de configuração

• Clique em Tools > Configurations para abrir o editor
• Use para criar e editar arquivos de configuração
Edição dos arquivos de configuração

Esse gráfico mostra o editor Configuration File no Designer. Clique em
Tools > Configurations para abrir o editor. Aqui você pode, opcionalmente, criar,
visualizar e editar arquivos de configuração disponíveis.
Quando o Information Server é instalado, um arquivo de configuração padrão é
criado. É possível criar arquivos de configuração adicionais que podem ser
selecionados para a variável de ambiente $APT_CONFIG_FILE.
É fácil incluir um nó a um arquivo de configuração. Basta copiar um dos nós
existentes e, então, mudar o nome do nó. Então, modifique qualquer recurso ou
outras entradas conforme necessário para o novo nó.

Compilação de tarefa paralela

• O que é gerado: Cliente do
Designer
• OSH: um tipo de script

• OSH representa o fluxo de dados de design Compilação
e os estágios
 Os estágios são compilados para operadores Servidor do DataStage
OSH
• Operador Transform para cada Transformer
 Um operador customizado construído durante a
compilação
 Compilado em C++ e, então, para operadores Tarefa
executável
nativos correspondentes
− Assim, um compilador C++ é necessário para
compilar tarefas com um estágio Transformer
Componentes
do
Transformer
Compilação de tarefa paralela

Ao clicar no botão Compile para uma tarefa, o OSH (Orchestrate Shell Script) é
gerado. Esse é um arquivo de script que pode ser executado pelo mecanismo
paralelo do DataStage. O OSH contém operadores que correspondem a estágios
no diagrama.
O gráfico ilustra como, para cada estágio Transformer em uma tarefa, o processo de
compilação cria um operador OSH customizado. Primeiro, ele gera o código-fonte
C++ para o operador e, então, compila o código-fonte C++ para um operador OSH
executável. Isso explica por que o DataStage precisa de um compilador C++ no
sistema no qual está instalado. O compilador C++ não é necessário para a execução
de tarefas do DataStage. Ele é necessário para compilar tarefas paralelas do
DataStage contendo estágios Transformer.

OSH gerado
Visualizável
do OSH
Nome do estágio OSH está visível

em:
Operador
- Janela Job
Properties
Esquema - Log da tarefa
- Janela View Data
- Definições de tabela
OSH gerado
É possível visualizar o OSH gerado no DataStage Designer na guia Job Properties
Generated OSH. Isso exibe o OSH gerado quando a tarefa é compilada. É
importante observar, porém, que esse OSH pode passar por algumas mudanças
adicionais antes de ser executado.
O gráfico à esquerda mostra o OSH gerado na janela Job Properties. Para
visualizar o OSH gerado, a opção de visualizar OSH deve estar ativada no
Administrator, como mostra o gráfico na parte superior à direita.

Exemplos do mapeamento de estágio a operador

• Estágio Sequential File
 Usado como origem: operador import
 Usado como destino: operador export
• Estágio Data Set: operador copy
• Estágio Sort: tsort
• Estágio Aggregator: operador group
• Estágio Row Generator: operador generator
• Estágio Transformer: operador customizado etiquetado com a palavra
"transform" no nome
Exemplos do mapeamento de estágio a operador

Quando o OSH é gerado, os estágios na tela da GUI são mapeados para os
operadores OSH. Aqui são listados alguns exemplos.
Os estágios no diagrama não realizam necessariamente mapeamentos um a um
para operadores. Por exemplo, o estágio Sequential File, quando usado como uma
origem, é mapeado para o operador import. Quando o mesmo estágio é usado
como destino, ele é mapeado para o operador export.
O inverso também é verdadeiro. Diferentes tipos de estágios podem ser mapeados
para o mesmo operador. Por exemplo, os estágios Row Generator e Column
Generator são mapeados para o operador generator.
Como mencionado anteriormente, o operador do estágio Transformer é mapeado
para um operador customizado. É possível identificar esse operador no OSH pela
palavra "transform" no seu nome.

Pontuação da tarefa
• Gerada do OSH junto com o arquivo de configuração utilizado para
executar a tarefa
• Pense no "Score" como uma partitura musical, e não como a
pontuação de um jogo
• Atribui nós (partições) a cada operador OSH
• Especifica operadores OSH adicionais conforme necessário
 Operadores tsort, quando requeridos por um estágio
 Operadores de algoritmo de particionamento especificados explícita ou
implicitamente (Auto)
 Inclui operadores de buffer para impedir conflitos
• Define os processos da tarefa reais
• Útil para depuração e ajuste de desempenho
Pontuação da tarefa
A pontuação da tarefa é gerada do OSH junto com o arquivo de configuração
utilizado para executar a tarefa. Uma vez que ela não é conhecida até o tempo de
execução ao qual o arquivo de configuração uma tarefa usará, a pontuação da
tarefa não será gerada até o tempo de execução. A geração da pontuação faz parte
da sobrecarga inicial da tarefa.
Essa pontuação determina quais operadores são executados em quais nós. Será
um único nó para operadores (estágios) em execução no modo sequencial. Pode
ser vários nós para operadores em execução no modo paralelo.
A pontuação também inclui operadores de adição conforme necessário. Por
exemplo, alguns estágios, como Join, requerem que os dados sejam classificados.
A pontuação incluirá operadores tsort para executar essas classificações. Os
operadores de buffer também são incluídos conforme necessário a dados em buffer
que estão indo para operadores, nos quais podem ocorrer conflitos.
Desenvolvedores experientes do DataStage costumam verificar a pontuação para
coletar informações úteis para depuração e ajuste de desempenho.

Visualização da pontuação
• Defina $APT_DUMP_SCORE
para saída do Score para o log
da tarefa
Operadores com
• Para identificar a mensagem designações de nó
do Score, procure por "main
program: This step ..."
 A palavra "Score" não é usada
Mensagem de Score no
log da tarefa
Visualização da pontuação
A pontuação não está visível até que a tarefa seja executada. Uma das variáveis de
ambiente Reporting determina se ela é exibida no log da tarefa. Para identificar a
mensagem de Score, procure a mensagem chamada "main program: This step ..."
O gráfico exibe um exemplo de Score. Observe como os operadores são atribuídos
aos nós. Observe que op0 é atribuído a um único nó (node1). Isso foi gerado de um
estágio Sequential File em execução no modo sequencial. op2, gerado de um
estágio Copy, é atribuído a dois nós.

1. Qual arquivo define o grau de paralelismo sob o qual uma tarefa é
executada?
2. Quais são os dois algoritmos de particionamento que particionam
com base em valores da chave?
3. Quais algoritmos de particionamento produzem distribuições
uniformes de dados nas partições?
4. Em que um design de tarefa é compilado?
5. O que é gerado do OSH e do arquivo de configuração usado para
executar a tarefa?


1. Arquivo de configuração.
2. Hash, Modulus.
3. Round Robin, Entire, Random (talvez).
4. Script OSH.
5. Score.

Demonstração 1
Particionamento e coleta

 Visualizar ícones de particionamento
 Definir algoritmos de particionamento em estágios
 Visualizar o OSH no log da tarefa
 Visualizar o arquivo de configuração no log da tarefa
 Visualizar a pontuação no log da tarefa
Demonstração 1: Particionamento e coleta

Demonstração 1:
Particionamento e coleta
Propósito:
Neste exercício, você determinará como os dados são colocados nos nós
(partições) de uma tarefa configurando o particionamento e coletando
algoritmos em cada estágio.
NOTA:
Etapas:
exibida.
Tarefa 1. Particione e colete.
1. Salve a tarefa CreateSeqJobParam como CreateSeqJobPartition.
Observe o ícone no link de entrada para o estágio de destino (fan-in). Ele indica
que o estágio está coletando os dados.

2. Abra o estágio Sequential File de destino na guia Input > Partitioning.

Observe, na área Partitioning/Collecting, que ele indica "Collector type" - e
que o algoritmo de coleta "(Auto)" está selecionado.

4. Visualize os dados no estágio de destino.
5. Abra o estágio Sequential de destino na guia Properties.
Em vez de gravar em um único arquivo, você deseja gravar em dois arquivos
com nomes diferentes. Você deseja que os arquivos fiquem no diretório
DSEss_Files\Temp.
6. Clique na pasta Target.
7. No painel Available properties to add, clique em File.
8. Para as propriedades de File, inclua o caminho do diretório e o parâmetro
#TargetFile# para o segundo arquivo.

9. Anexe algo ao fim do caminho para distinguir os dois nomes de arquivo. Por
exemplo, 1 e 2. Aqui, 1 e 2 foram anexados ao parâmetro de nome de cada
arquivo, respectivamente, de modo que os nomes dos dois arquivos são
diferentes.
10. Clique na guia Partitioning.

Observe que o estágio não está mais coletando, mas particionando, pois está
gravando os dados nos dois arquivos em fluxos paralelos separados de dados
de saída. É possível confirmar isso observando as palavras acima da lista
suspensa Partitioning/Collecting. Se disserem Partition type, o estágio está
particionando. Se disserem Collector type, ele está coletando.

11. Clique em OK para fechar o estágio.

Observe que o ícone de particionamento mudou. Ele não indica mais coleta. O
ícone que você vê agora indica particionamento automático.
12. Agora abra o estágio do Sequential File de destino novamente e mude

Partition type para Same.

13. Feche o estágio.

Observe como o ícone de particionamento mudou.

15. Visualize o log da tarefa. Observe como os dados são exportados para as duas
partições diferentes (0 e 1). 24 registros vão para uma partição (partição 0) e 23
registros vão para a outra (partição 1).

Tarefa 2. Visualize OSH, Configuration File e Score.

1. No log da tarefa para a última execução da tarefa CreateSeqJobPartition,
abra a mensagem etiquetada como OSH script.
Isso exibe o script OSH gerado quando a tarefa foi compilada.
2. No OSH, observe o seguinte:

 Operadores: correspondem aos estágios no design de tarefa.
 Esquemas: correspondem às definições da tabela nos estágios.
 Propriedades: correspondem às propriedades definidas na guia Properties.

3. No log, abra a mensagem etiquetada como

main_program: APT configuration file.
4. Observe o seguinte no arquivo de configuração:

 O número de nós e seus nomes. Neste exemplo, há dois nós etiquetados
como "node1" e "node2".
 Discos de recurso usados por cada nó. As entradas etiquetadas como
"resource disk". Isso identifica o espaço em disco usado para armazenar
os dados em conjuntos de dados.
 Discos utilizáveis de recurso usados por cada nó. Eles armazenam os
arquivos temporários criados durante uma execução da tarefa, como
aqueles usados na classificação.

5. No log, abra a mensagem etiquetada como (nota: "X" representa #)

main_program: This step has X datasets.
Esse é o Score.
A pontuação é dividida em duas seções. A segunda seção lista os nós em que
cada operador é executado. Por exemplo, op0 é executado apenas no nó
único, node1.
Observe que op3 (…TargetFile) é executado em dois nós.
Resultados:
Você determinou como os dados são colocados nos nós (partições) de uma
tarefa configurando o particionamento e coletando algoritmos em cada
estágio.

Resumo da unidade
• Descrever a arquitetura de processamento paralelo
• Descrever paralelismo de pipeline
• Descrever paralelismo de partição
• Listar e descrever algoritmos de particionamento e coleta
• Descrever arquivos de configuração
• Descrever o processo de compilação de tarefa paralela
• Explicar OSH
• Explicar a pontuação
Resumo da unidade


Unidade 8 Combinação de dados
Combinação de dados


• Combinar dados usando o estágio Lookup
• Definir consultas de intervalo
• Combinar dados usando o estágio Merge
• Combinar dados usando o estágio Join
• Combinar dados usando o estágio Funnel
Combinação de dados © Copyright IBM Corporation 2015
Esta unidade discute os principais estágios que podem ser usados para combinar
dados. Conforme discutido anteriormente, alguns estágios "passivos" para acessar os
dados (estágio Sequential File, estágio Data Set). Nesta unidade, começamos a
discutir alguns estágios de processamento "ativos".

• Necessidades comuns de negócios
 Os registros contêm colunas que fazem referência a dados em outras
origens de dados
− Um registro de ordem contém IDs do cliente que fazem referência a informações
do cliente na tabela ou no arquivo CUSTOMERS
 Registros de duas ou mais origens diferentes são combinados em um
registro mais longo com base em um valor de chave correspondente
− Asinformações de folha de pagamento do funcionário em um registro são
combinadas com as informações de endereço do funcionário de outro registro
• O DataStage tem vários estágios diferentes que podem ser usados
para combinar dados:
 Join
 Merge
 Lookup
• Combine dados de um ou mais links de entrada que podem conter
dados de tabelas relacionais, arquivos ou processamento de envio de
dados
Combinar dados é uma necessidade comum dos negócios. Por exemplo, registros de
dados em uma tabela ou arquivo podem conter referências a dados em outra tabela ou
arquivo. Os dados devem ser combinados de modo que registros individuais
contenham dados de ambas as tabelas.
O DataStage tem vários estágios diferentes que podem ser usados para combinar
dados: Join, Merge e Lookup. Em geral, é possível obter o mesmo resultado usando
qualquer um desses estágios. Porém, eles diferem com relação às suas exigências e
propriedades individuais.
É importante observar que esses estágios combinam fluxos de dados ou links de
dados. A origem dos dados não é restrita. É possível combinar dados de tabelas
relacionais, arquivos simples ou dados vindos de outro estágio de processamento,
como um Transformer.

Estágios Lookup, Join, Merge

• Esses estágios combinam dois ou mais links de entrada
 Os dados são combinados pelas colunas-chave designadas
• Esses estágios diferem principalmente em:
 Uso de memória
 Propriedades do estágio
 Requisitos do estágio
− Se os dados precisam ser classificados
− Se os dados precisam ser desduplicados
 Como falhas de correspondência são manipuladas
Estágios Lookup, Join, Merge

Esses estágios têm funcionalidade similar. Qual você usaria? Isso depende de vários
fatores, que são apresentados aqui. As principais diferenças são com relação ao uso
de memória (alguns desses estágios precisam de mais memória que outros),
exigências de estágio (alguns exigem que os dados de entrada sejam classificados) e
propriedades do estágio (um desses estágios pode ter uma propriedade útil para você
no contexto determinado).
Todos esses estágios combinam dados com base em valores de coluna-chave
correspondentes.

Recursos do estágio Lookup

• Um link de entrada de fluxo (link de origem)
• Um ou mais links de referência de entrada
• Um link de saída
• Link de rejeição opcional
 Captura falhas de correspondência
• Opções de falha de consulta
 Continue, Drop, Fail, Reject
• Opcionalmente, pode retornar várias linhas correspondentes de um
link de referência de entrada
• Cria uma estrutura de arquivo indexado na memória dos dados do
link de referência
 Indexado pela chave de consulta
 Deve ter memória suficiente para conter os dados de referência ou os
dados transbordarão para o disco
Recursos do estágio Lookup

Lista os principais recursos do estágio Lookup. O estágio Lookup pode ter apenas um
único link de entrada de fluxo e um único link de saída de fluxo. Opcionalmente, um link
de saída adicional, chamado link de rejeição, pode ser incluído para capturar falhas de
correspondência de consulta.
Os links para qualquer arquivo ou tabela de consulta ou outros links de processamento
são implementados como links vindos das tabelas de consulta ou de arquivos para o
estágio Lookup. Portanto, eles são links de entrada no estágio Lookup e são
chamados de links de referência. Eles podem ser divididos em linhas para distingui-los
do link de entrada de fluxo principal.
Antes de processar a primeira linha no estágio Lookup, todos os dados de referência
são armazenados na memória em uma estrutura indexada. Assim, nenhuma leitura de
arquivo físico é necessária para realizar uma consulta para uma linha no momento em
que a linha é lida. Dessa forma, as consultas podem ser executadas rapidamente.
Porém, deve haver memória suficiente para conter todos os dados de referência, ou os
dados serão gravados no disco.

Tipos de consulta
• Correspondência de igualdade
 Combina os valores na coluna-chave de consulta do link de referência com
os valores selecionados na linha de origem
 Retorna uma ou mais linhas correspondentes
 Oferece suporte para correspondência exata ou correspondência
independente de maiúsculas/minúsculas
• Correspondência de intervalo
 Duas colunas definem o intervalo
 Uma correspondência ocorre quando um valor está dentro do intervalo
especificado
 O intervalo pode estar no link de entrada de origem ou no link de referência
 Correspondências de intervalo podem ser combinadas com
correspondências de igualdade
− Consulte registros para o ID do funcionário dentro de um determinado intervalo de
datas
Tipos de consulta
Há dois tipos gerais de consulta que você pode executar usando o estágio Lookup.
Correspondências de igualdade e consultas de intervalo. Correspondências de
igualdade comparam dois ou mais valores de coluna-chave quanto à igualdade. Um
exemplo é combinar um valor de ID do cliente em uma coluna de link de fluxo com um
valor em uma coluna no link de referência.
Uma correspondência de intervalo compara um valor em uma coluna no link de fluxo
com os valores nas duas colunas no link de referência. A correspondência obtém
sucesso se o valor estiver entre os valores nas duas colunas. As correspondências de
intervalo também comparam um único valor em um link de referência com duas
colunas no link de fluxo.
As consultas de intervalo podem ser combinadas com colunas de igualdade. Por
exemplo, é possível procurar o ID do cliente correspondente dentro de um intervalo de
datas.

Exemplo do estágio Lookup com correspondência de

igualdade
Link de origem Link de

(fluxo) referência
Exemplo do estágio Lookup com correspondência de igualdade

Este slide exibe um exemplo de uma tarefa do DataStage com um estágio Lookup
(estágio de centro). Neste exemplo, a tarefa usa uma correspondência de igualdade
para determinar qual linha ou linhas extrair do link de referência, que, neste caso, é um
link para um arquivo sequencial (Items). O estágio Sequential File como a origem dos
dados de referência é apenas um exemplo. Não há restrições quanto aos dados do link
de referência. Eles podem fluir de uma tabela relacional, de um arquivo sequencial ou
de processamento mais complexo.
Observe que os links de entrada e saída de fluxo têm linhas sólidas. O link de
referência tem uma linha pontilhada.

Estágio Lookup com uma correspondência de igualdade

Colunas do
link de origem
Restrições
de consulta
Colunas
de saída
Correspondência
de consulta
Colunas do link
de referência
Nomes e definições
de coluna
Estágio Lookup com uma correspondência de igualdade

Este slide mostra o interior do estágio Lookup e destaca seus principais recursos.
Para uma consulta de correspondência de igualdade ou independente de
maiúsculas/minúsculas, uma ou mais colunas no link de referência são selecionadas
como chaves (veja o painel inferior esquerdo). As colunas do link de origem são
combinadas com as colunas-chave usando arrastar e soltar. Para especificar uma
correspondência de igualdade, selecione o sinal de igual (=) na célula Key Type do
painel do link de referência. Para especificar uma correspondência independente de
maiúsculas/minúsculas, selecione Caseless na caixa Key Type no painel do link de
referência.
As colunas de saída são especificadas no painel superior direito. As colunas do link de
origem e referência são arrastadas para a frente dessas colunas para especificar os
valores a serem mapeados para as colunas de saída.
As definições de coluna das colunas listadas nas janelas do link são especificadas nas
guias na parte inferior da janela.

Definição da chave de consulta

Arraste esta
• Arraste as colunas do link coluna
de entrada de origem para a
célula à esquerda das
colunas da chave de
referência correspondente
 A caixa de seleção Key da Coluna-chave
coluna do link de referência
é marcada
• Selecione o tipo de chave
 Equality
 Caseless
Correspondência
de igualdade
Coluna-chave
de consulta
Definição da chave de consulta

Este slide mostra o lado esquerdo do estágio Lookup em que a correspondência de
igualdade é especificada. Neste exemplo, a janela Items lista as colunas do link de
referência e a janela Warehouse lista as colunas do link de fluxo. Primeiro, é preciso
selecionar uma ou mais colunas-chave na janela Items e especificar o tipo de
correspondência na célula Key Type à esquerda.
Para especificar as colunas-chave correspondentes da consulta, arraste a coluna-
chave do link de fluxo (aqui, a coluna Warehouse) para a coluna-chave
correspondente do link de referência (coluna Item).

Especificação das colunas de saída

• Arraste as colunas do link de
referência ou do link de fluxo
no lado esquerdo para o lado
direito
• É possível selecionar uma ou
mais colunas para arrastar
 Arrastar o cabeçalho do link
arrasta todas as colunas
• Opcionalmente, renomeie as
colunas do link de saída na
janela inferior
• Opcionalmente, reordene as
colunas de saída usando
arrastar e soltar
Coluna renomeada
Especificação das colunas de saída

Os mapeamentos do resultado são especificados no lado direito da janela do estágio
Lookup. As colunas de entrada para as quais você deseja enviar o estágio podem ser
arrastadas das janelas esquerdas para a janela direita. Neste exemplo, todas as
colunas do link Warehouse foram arrastadas junto com a coluna Description do link
Items.
Conforme já mencionado, as guias na parte inferior fornecem os metadados para as
colunas nas janelas do link. Neste exemplo, o nome da coluna Description foi alterado
para ItemDescription. Essa coluna também foi movida para a terceira na lista de
saída.

Ações de falha de consulta

• Se a consulta falhar em localizar uma coluna-chave correspondente, é
possível realizar uma entre várias ações:
 Fail (padrão)
−O estágio relata um erro e a tarefa falha
 Drop
−A linha de entrada é eliminada
 Continue
−A linha de entrada é transferida para a saída. As colunas do link de referência
são preenchidas com valores nulos ou padrão
 Reject
−A linha de entrada é enviada a um link de rejeição
−O estágio deve ter um link de rejeição
Ações de falha de consulta

Clique no ícone Lookup Constraints no canto superior esquerdo do estágio Lookup
para especificar as ações de falha de consulta. Por padrão, a ação de falha de
consulta é Fail, ou seja, a tarefa falha (é interrompida). Para muitos propósitos, essa
ação é drástica demais.
Em vez de fazer a tarefa falhar, é possível especificar que a linha com falha de
consulta seja eliminada, rejeitada ou enviada para fora do estágio para mais
processamento.

Especificação de ações de falha de consulta
Selecione o link de referência

para retornar várias linhas
Selecione a ação de
falha de consulta
Especificação de ações de falha de consulta

Clique no ícone Lookup Constraints no canto superior esquerdo do estágio Lookup
para abrir a janela Lookup Stage Conditions. No lado direito, selecione a ação
Lookup Failure.
Por padrão, se houver mais de uma linha correspondente, apenas uma
correspondência será retornada. É possível selecionar um link de referência do qual
todas as linhas correspondentes devem ser retornadas. Apenas um link de referência
pode ser selecionado, se houver mais de um. Se ele for selecionado, uma única linha
de entrada indo para o estágio Lookup pode resultar em várias linhas saindo do
estágio, uma para cada correspondência.

Estágio Lookup com link de rejeição
Link de rejeição.
Selecione Reject para a
ação de falha de consulta
Estágio Lookup com link de rejeição

Este slide mostra uma tarefa com um link de rejeição de um estágio Lookup. Isso
requer que Reject esteja selecionado como Lookup Failure Action. (Veja a página
anterior.) Este link será enviado a quaisquer linhas de entrada que não tenham linha de
referência correspondente. Neste exemplo, as linhas são enviadas para um estágio
Peek. Porém, qualquer estágio passivo ou estágio de processamento de série pode
ser usado para processar as rejeições.

Comportamento do estágio Lookup
Link de origem Link de referência
Revolution Citizen Citizen Exchange

1789 Lefty M_B_Dextrous Nasdaq
1776 M_B_Dextrous Righty NYSE
Coluna-chave
de consulta
Comportamento do estágio Lookup

Este exemplo e o seguinte ilustram como o estágio Lookup se comporta para
diferentes ações de falha de consulta. Neste exemplo, a coluna Citizen no link de
origem é combinada com a coluna Citizen no link de referência. Para a primeira linha
de origem, a consulta não localizará uma correspondência (porque não há linha Lefty
nos dados do link de referência). Para a segunda, ela localizará uma correspondência
(a primeira linha com M_B_Dextrous).
A próxima página ilustra a saída do estágio Lookup.

Saída do estágio Lookup
Saída de Lookup com a opção Continue
Revolution Citizen Exchange Sequência de

1789 Lefty caracteres
vazia ou nula
1776 M_B_Dextrous Nasdaq
Saída de Lookup com a opção Drop
Revolution Citizen Exchange

Saída do estágio Lookup

Isso mostra os resultados, dependendo de qual opção de Lookup foi selecionada.
Para a primeira linha de origem (1789), a consulta falha em localizar uma
correspondência. Uma vez que Continue é a opção de falha de consulta, a linha é
gerada como saída. A coluna Exchange é preenchida com nulo (se a coluna for
anulável) ou com a sequência de caracteres vazia (se a coluna não for anulável).
Para a segunda linha de origem (1776), a consulta localiza uma correspondência, de
modo que a coluna Exchange obtém um valor do arquivo de consulta.
Se Drop for a ação de falha de consulta, a primeira linha será eliminada, pois não há
correspondência.

Demonstração 1
Uso do estágio Lookup
Demonstração 1: Uso do estágio Lookup

Demonstração 1:
Uso do estágio Lookup
Propósito:
Você criará consultas usando o estágio Lookup, identificará como as falhas
de consulta são manipuladas e, por fim, capturará as falhas de consulta como
um link de rejeição.
NOTA:
DSEssLabSolutions_v11_5_1.dsx no diretório de arquivos
Etapas:
exibida.
Tarefa 1. Consulte a descrição de item do warehouse
1. Abra uma nova tarefa paralela e salve-a com o nome LookupWarehouseItem.
2. Inclua os estágios, estratificando-os como mostrado, e nomeie-os de acordo. O
estágio Lookup é localizado na seção Processing da paleta.

3. Depois de todos os estágios terem sido incluídos, inclua os links – começando

da esquerda para a direita – entre os três estágios na parte inferior do diagrama
primeiro. Quando os três estágios inferiores tiverem sido conectados, inclua o
link do estágio restante ao estágio Lookup.
Seus resultados aparecerão como mostrado (observe os conectores sólidos
versus tracejados):
4. No Windows Explorer, localize e abra o seguinte arquivo usando o Bloco de

Notas: C:\CourseData\DSEss_Files\Warehouse.txt
Note o delimitador nos dados – neste caso, o símbolo de barra vertical (|).
5. Importe a definição de tabela para o arquivo sequencial Warehouse.txt para
sua pasta _Training > Metadata.

6. Clique em Import e confirme se as suas configurações são como o mostrado a

seguir.
7. Clique na guia Define, verifique se os nomes da coluna aparecem e clique em

OK.
8. Edite o estágio Sequential File Warehouse, definindo Warehouse.txt como o
arquivo de origem do qual os dados serão extraídos. As propriedades de
formato identificadas na definição de tabela precisarão ser duplicadas no
estágio Sequential File. Certifique-se de poder visualizar os dados. Se houver
problemas, verifique se os metadados estão corretos nas guias Columns e
Format.
9. Importe a definição de tabela para o arquivo Items.txt.

10. Edite o estágio Sequential File de Items para extrair os dados do arquivo
Items.txt. Execute Load e confirme os resultados como mostrado. Atualize a
opção Quote para "single".
11. Novamente, assegure-se de poder visualizar os dados no estágio Items antes

de continuar.
12. Abra o estágio Lookup. Mapeie a coluna Item no painel superior esquerdo
para a coluna-chave Item da consulta no painel inferior esquerdo do painel da
tabela de itens arrastando uma para a outra. Se a janela Confirm Action
aparecer, clique em Yes para tornar a coluna Item um campo-chave.

13. Arraste todas as colunas do painel Warehouse para o link de destino

Warehouse_Items à direita.
14. Arraste a coluna Description do painel Items para logo acima da coluna de
destino Onhand no painel Warehouse_Items.
15. Na guia Warehouse_Items na parte inferior da janela, mude o nome da coluna
de destino Description, recém-incluída, para ItemDescription.
16. Edite o estágio Sequential de destino conforme necessário.

17. Compile e execute. Examine o log da tarefa. Sua tarefa provavelmente foi
interrompida. Tente determinar porque ela falhou e pense no que você poderia
fazer a respeito. (Você corrigirá o que for necessário na próxima tarefa.)

Tarefa 2. Manipule falhas de consulta.

1. Salve sua tarefa como LookupWarehouseItemNoMatch.
2. Abra o estágio Lookup. Clique no ícone Constraints (parte superior, segundo da
esquerda). Quando a consulta falhar, especifique que a tarefa deve continuar.
3. Compile e execute. Examine o log. Você não deve receber erros fatais desta vez.
4. Visualize os dados no arquivo de destino. Você localiza alguma linha no arquivo
de destino em que a consulta falhou? Essas seriam linhas com descrições de
item ausentes. Aumente o número de linhas exibidas para pelo menos algumas
centenas se não visualizar nenhum item ausente inicialmente. Por padrão,
quando há uma falha de consulta com Continue, o DataStage produz valores
vazios para as colunas de consulta. Se as colunas forem anuláveis, o DataStage
produz NULLs como saída. Se as colunas não forem anuláveis, o DataStage
gerará valores padrão como saída, dependendo do seu tipo.
5. Abra o estágio Lookup. Torne a coluna Description no lado esquerdo e a coluna

ItemDescription no lado direito anuláveis. Agora, para não correspondências, o
DataStage retornará NULLs, em vez de sequências de caracteres vazias.

6. Uma vez que NULLs serão gravados no estágio de destino, será preciso
manipulá-los. Abra o estágio Sequential de destino. Substitua NULLs pela
sequência de caracteres "NOMATCH". Para fazer isso, clique duas vezes à
esquerda da coluna ItemDescription na guia Columns. Nas propriedades
estendidas, especifique um valor de campo nulo de NOMATCH.
7. Compile e execute.
8. Visualize os dados no estágio Sequential File de destino. Execute a
visualização (view) com pelo menos 200 linhas de dados.
9. Clique em Find. Digite NULL na caixa Find what:. Selecione ItemDescription
para a lista suspensa In column:. Clique em Find Next para localizar o
primeiro valor NULL. Os resultados serão similares aos abaixo.

Tarefa 3. Inclua um link de rejeição.

1. Salve sua tarefa como LookupWarehouseItemReject.
2. Abra o estágio Lookup e, usando Constraints, especifique que as falhas de
consulta devem ser rejeitadas.
3. Feche o estágio Lookup e inclua um link de rejeição indo para um estágio Peek
para capturar as falhas de consulta.
4. Compile e execute. Examine as mensagens Peek no log da tarefa para ver

quais linhas foram falhas de consulta.
5. Examine o log da tarefa. Observe, nas mensagens Peek, que várias linhas
foram rejeitadas.
Resultados:
Você combinou consultas usando o estágio Lookup, identificou como as
falhas de consulta são manipuladas e, por fim, capturou as falhas de consulta
como um link de rejeição.

Tarefa do estágio Range Lookup
Link de referência
Estágio Lookup
Tarefa do estágio Range Lookup

Este slide mostra mais uma vez uma tarefa com um estágio Lookup. Neste exemplo,
uma consulta de intervalo será especificada no estágio Lookup, em vez de uma
correspondência de igualdade.

Intervalo no link de referência
Valores do intervalo
de referência
Recuperar
descrição
Valores de origem
Intervalo no link de referência

Aqui, você vê os dados de origem e os dados do link de referência. O valor da coluna
Item no link de origem será combinado com o intervalo especificado no link de
referência pelas colunas StartItem e EndItem. Neste exemplo, a primeira linha dos
dados de origem caberá no intervalo "Description A". Assim, para a primeira linha,
"Description A" será retornado.

Seleção da coluna de fluxo
Clique duas vezes para Link de origem

especificar o intervalo
Link de referência
Seleção da coluna de fluxo

Este slide mostra o interior do estágio Lookup. Warehouse é o link de fluxo e
Range_Description é o link de referência. Para especificar um intervalo no link de
referência, primeiro selecione a caixa Range ao lado da coluna-chave (Item). Então,
clique duas vezes na célula Key Expression à esquerda da coluna-chave. Isso abre a
janela Range Expression Editor, na qual você especifica o intervalo.

Editor de expressão de intervalo
Seleção de colunas do
intervalo
Seleção de
operadores

Este slide mostra a janela Range Expression Editor. Selecione os operadores e as
colunas para definir o intervalo. Neste exemplo, a expressão de intervalo será
verdadeira quando Item for maior ou igual ao valor StartItem e menor que o valor
EndItem da coluna.
Observe aqui que duas condições separadas são combinadas (AND) usando um
operador lógico.

Intervalo no link de fluxo
Intervalo de origem
Recuperar outros
valores de coluna
Chave do link de referência
Intervalo no link de fluxo

Este slide mostra um exemplo de tarefa em que o intervalo está no link de fluxo, em
vez de na linha de referência. Observe que o link de fluxo (a linha sólida) está vindo do
estágio Range_Description na parte superior. Ele tem duas colunas, StartItem e
EndItem, que especifica o intervalo. O link de referência tem a coluna Item que será
combinada com esse intervalo.

Especificação da consulta de intervalo
Seleção do
tipo de chave
do intervalo
Especificação da consulta de intervalo

Aqui, você vê a parte interna do estágio Lookup. Selecione Range na coluna Key
Type ao lado de Item no link de referência Warehouse. Então, clique duas vezes na
célula à esquerda para abrir a janela Range Expression Editor.

Seleção de colunas
do intervalo

Este slide mostra a janela Range Expression Editor. Aqui, como antes, você
seleciona os operadores e as colunas para definir o intervalo.

Demonstração 2
Consultas de intervalo
Demonstração 2: Consultas de intervalo

Demonstração 2:
Consultas de intervalo
Propósito:
Você deseja entender os dois tipos de consultas de intervalo melhor. Para
isso, você projetará uma tarefa com uma consulta de intervalo de linha de
referência e uma tarefa com uma consulta de intervalo de fluxo.
NOTA:
Etapas:
exibida.
Tarefa 1. Projete uma tarefa com uma consulta de intervalo
de link de referência.
1. Abra sua tarefa LookupWarehouseItem e salve-a com o nome
LookupWarehouseItemRangeRef. Salve na pasta _Training > Jobs.
Renomeie os estágios e os links conforme mostrado.

2. Importe a definição de tabela para o arquivo sequencial

Range_Descriptions.txt. Os campos StartItem e EndItem devem ser
definidos como o campo Item está definido no estágio Warehouse, ou seja,
como VarChar(255).
3. Edite o estágio Sequential File do Range_Description para ler de

Range_Descriptions.txt configurando as propriedades e alterando as
configurações de formato da maneira adequada. Ao carregar as novas
definições de coluna, exclua as colunas existentes primeiro. Verifique se
consegue visualizar os dados.
4. Abra o estágio Lookup. Edite a coluna Description à esquerda e a coluna
ItemDescription à direita para que ambas sejam anuláveis.
5. Marque a caixa de seleção Range à esquerda do campo Item na janela do

painel Warehouse.

6. Clique duas vezes na célula Key Expression para a coluna Item abrir o editor
Range Expression. Especifique que o valor da coluna Warehouse.Item deve
ser maior ou igual ao valor da coluna StartItem e menor que o valor da coluna
EndItem.
7. Abra a janela Constraints e especifique que a tarefa deve continuar se houver

uma falha de consulta.
8. Edite o estágio Sequential File de destino. A coluna ItemDescription no
estágio Sequential File é anulável. Vá para a janela de propriedades estendidas
para esta coluna. Substitua valores NULL pela sequência de caracteres
NO_DESCRIPTION.
10. Visualize os dados no estágio de destino para verificar os resultados.

Tarefa 2. Projete uma tarefa com uma consulta de intervalo

de fluxo.
Essa tarefa lê do arquivo Range_Descriptions.txt. Ela, então, executa uma
consulta no arquivo Warehouse.txt. Para cada linha lida, ela seleciona todos os
registros do arquivo Warehouse.txt com itens dentro do intervalo. A descrição
adequada é incluída a cada registro que, então, é gravado em um arquivo.
1. Salve sua tarefa como LookupItemsRangeStream na pasta _Training >
Jobs.
2. Reverta os links de origem e de consulta. Primeiro torne o link de origem um
link de referência. Clique no botão direito do mouse e clique em Convert to
reference. Então, torne o link de consulta um link de fluxo.
3. Abra o estágio Lookup. Selecione a coluna Item na tabela Warehouse como a

chave. Especifique Key type como Range.
4. Clique duas vezes na célula Key Expression ao lado de Item. Especifique a
expressão de intervalo.

5. Clique no ícone Constraints. Especifique que várias linhas devem ser

retornadas do link Warehouse. Especifique também que a tarefa deve
continuar se houver uma falha de consulta.

7. Visualize os dados para verificar os resultados.
Resultados:
Você projetou uma tarefa com uma consulta de intervalo de linha de
referência e uma tarefa com uma consulta de intervalo de fluxo.

Estágio Join
• Quatro tipos de junções:
 Inner
 Left outer
 Right outer
 Full outer
• Os dados do link de entrada devem ser classificados
 Link esquerdo e um link direito. Qual é qual pode ser especificado no
estágio
 Dá suporte a links "intermediários" adicionais
• Leve
 Pouca memória necessária devido à exigência de classificação
• Junção de uma ou mais colunas-chave
 Os nomes da coluna para cada link de entrada devem corresponder. Se
necessário, inclua um estágio Copy antes do estágio Join para mudar o
nome de uma das colunas-chave
Estágio Join
Como o estágio Lookup, o estágio Join também pode ser usado para combinar dados.
Ele tem a mesma funcionalidade básica que uma junção SQL. É possível selecionar
um entre quatro tipos de junção: interna, externa esquerda, externa direita e externa
integral.
Uma junção inner produz como saída linhas que correspondem.
Uma junção left outer produz como saída todas as linhas no link esquerdo, tenham
elas correspondências no link direito ou não. Os valores padrão são inseridos para
quaisquer valores ausentes no caso de uma falha de correspondência.
Uma junção right outer produz como saída todas as linhas no link direito, tenham elas
correspondências no link esquerdo ou não. Os valores padrão são inseridos para
quaisquer valores ausentes no caso de uma falha de correspondência.
Uma junção full outer produz como saída todas as linhas no link esquerdo e no link
direito, tenham elas correspondências ou não. Os valores padrão são inseridos para
quaisquer valores ausentes no caso de falhas de correspondência.

Tarefa com estágio Join
Link de
entrada direito
Link de entrada Estágio Join

esquerdo
Tarefa com estágio Join

Este slide exibe uma tarefa simples com um estágio Join. Há dois links de entrada. Os
links são ordenados. Um é designado como o link esquerdo e o outro, como o link
direito, o que é importante ao definir as junções externas direita e esquerda. O estágio
contém uma guia em que essa ordenação do link pode ser especificada. (Não se pode
dizer do diagrama qual link é o esquerdo e qual link é o direito, embora isso seja
destacado no exemplo.)

Propriedades do estágio Join
Selecione qual link é

o esquerdo/direito
Coluna a
corresponder
Selecione
o tipo de
junção
Selecione se várias colunas

compõem a chave de junção
Propriedades do estágio Join

Este slide mostra a guia Properties do estágio Join. Aqui, você especifica as
colunas-chave de junção e o tipo de junção. A guia Link Ordering é destacada.
Por padrão, uma única propriedade Key é especificada. Isso permite que você escolha
uma coluna-chave. Se a chave contiver mais de uma coluna-chave, clique na
propriedade Key na janela Available properties to add.
As colunas-chave consistem em colunas dos links esquerdo e direito. Os nomes da
coluna devem corresponder exatamente. Assim, a coluna Item no exemplo se refere a
uma coluna Item no link esquerdo e à coluna Item no link direito. Se as colunas-chave
não corresponderem exatamente, será preciso incluir um estágio Copy como um link
de entrada para renomear uma das colunas de modo que elas correspondam.

Guia Output Mapping

• Arraste as colunas de entrada da entrada para a saída
• O link de saída inclui colunas de ambos os links de entrada
 Item.Description de um link de entrada
 Todas as colunas do outro link de entrada
Guia Output Mapping

Este slide mostra a guia Output > Mapping. Aqui você especifica os mapeamentos de
coluna de saída. O estágio Join requer um único link de saída. Não há suporte para
vários links de saída.

Comportamento do estágio Join
Link esquerdo (entrada primária) Link direito (entrada secundária)
Revolution Citizen Citizen Exchange

1789 Lefty M_B_Dextrous Nasdaq
1776 M_B_Dextrous Righty NYSE
Junção de
coluna-chave
Comportamento do estágio Join

Nesta página e nas seguintes, os exemplos ilustram o comportamento do estágio Join.
Neste exemplo, a coluna Citizen no link de origem é combinada com a coluna Citizen
no link de referência. Para a primeira linha de origem (Lefty), não há linha
correspondente no link direito. Para a segunda, há uma linha correspondente
(M_B_Dextrous).

Saída da junção interna

• Somente linhas com valores de chave correspondentes são
produzidas como saída
Saída da junção interna na chave Citizen

Saída da junção interna

Se uma junção interna for selecionada no estágio, apenas a segunda linha do link
esquerdo (M_B_Dextrous) e sua linha correspondente no link direito serão produzidas
como saída.

Saída da junção externa esquerda

• Todas as linhas do link esquerdo são produzidas como saída. Todas
as linhas do link direito com valores de chave correspondentes são

Valor nulo ou
1789 Lefty padrão
Saída da junção externa esquerda

Se uma junção externa esquerda for selecionada no estágio, ambas as linhas do link
esquerdo serão produzidas como saída. A primeira linha no link esquerdo (Lefty) não
tem uma linha correspondente no link direito. Portanto, a coluna Exchange da linha,
que vem do link direito, é preenchida com nulo ou com um valor padrão, dependendo
do tipo de coluna.

Saída da junção externa direita

• Todas as linhas do link direito são produzidas como saída. Todas as
linhas do link esquerdo com valores de chave correspondentes são

Righty NYSE
Valor nulo ou
padrão
Saída da junção externa direita

Se uma junção externa direita for selecionada no estágio, ambas as linhas do link
direito serão produzidas como saída. A primeira linha no link direito (M_B_Dextrous)
tem uma linha correspondente no link direito. A segunda linha não tem. Portanto, a
coluna Revolution da linha, que vem do link esquerdo, é preenchida com nulo ou com
um valor padrão, dependendo do tipo de coluna.

Junção externa integral

• Todas as linhas do link esquerdo são produzidas como saída. Todas
as linhas do link direito são produzidas como saída
• Cria novas colunas correspondentes às colunas-chave dos links
esquerdo e direito
Revolution leftRec_Citizen rightRec_Citizen Exchange

1789 Lefty
1776 M_B_Dextrous M_B_Dextrous Nasdaq
0 Righty NYSE
Valor nulo ou Valor nulo ou

padrão padrão
Junção externa integral

Isso mostra os resultados para uma junção externa integral. Combina os resultados de
uma junção externa esquerda e uma junção externa direita. As colunas Revolution e
Exchange que existem em apenas um link receberão valores nulo ou padrão para não
correspondências.
Observe que as colunas-chave do link direito e as colunas-chave do link esquerdo
serão incluídas à saída. Para linhas de saída não correspondentes, pelo menos uma
dessas colunas conterá valores nulos ou padrão.

Estágio Merge
• Similar ao estágio Join
 Link mestre (fluxo) e um ou mais links secundários
• Requisitos do estágio
 Os dados de link mestre e secundário devem ser classificados pela chave
de mesclagem
 Os dados do link mestre devem estar livres de duplicatas
• Leve
 Pouca memória necessária devido à exigência de classificação
• As linhas do link mestre sem correspondência podem ser mantidas ou
eliminadas
• As linhas do link secundário sem correspondência podem ser
capturadas
 Um link de rejeição pode ser incluído para cada link secundário
Estágio Merge
O estágio Merge é similar ao estágio Join. Ele pode ter vários links de entrada, um dos
quais é designado como o link mestre.
Ele difere um pouco nos seus requisitos de estágio. Os dados do link mestre devem
estar livres de duplicatas, além de serem classificados, o que não é um requisito do
estágio Join.
O estágio Merge também difere do estágio Join em algumas das suas propriedades.
As linhas do link secundário sem correspondência podem ser capturadas em links de
rejeição. Um link de rejeição pode ser incluído para cada link secundário.
Como o estágio Join, ele requer pouca memória devido à exigência de classificação.

Tarefa do estágio Merge
Link mestre Link secundário
Captura de não
correspondências
do link secundário
Tarefa do estágio Merge

Este slide mostra um exemplo de tarefa com um estágio Merge. Os links de entrada
são ordenados: link mestre e link secundário.
Como mencionado antes, o estágio Merge tem suporte para links de rejeição para
capturar não correspondências de link secundário. Neste exemplo, o link ItemsReject
captura linhas não correspondentes do link secundário Items.

Propriedades do estágio Merge
Correspondência
de chave
Manter ou eliminar
mestres sem
correspondência
Propriedades do estágio Merge

Este slide mostra a guia Property do estágio Merge. Além das propriedades Key,
podem ser usadas várias propriedades opcionais. A propriedade Unmatched Masters
Mode está destacada. Use essa propriedade para especificar se o estágio deve
manter ou eliminar as linhas mestre que não têm linhas de link secundário
correspondentes.

Gráfico de comparação
Joins Lookup Merge

Modelo Relacional estilo RDBMS Fonte – na tabela de LU da RAM Principal – atualização(ões)
Uso de memória Leve pesado Leve
Nº e nomes das entradas 2 ou mais: direita, esquerda 1 fonte, N tabelas de LU 1 principal, N atualização(ões)
Classificação de entrada obrigatória Todas as entradas Não Todas as entradas
Duplicatas na entrada primária OK OK Aviso!
Duplicatas nas entradas secundárias OK Aviso! OK apenas quando N = 1
Opções em primária sem
correspondência Keep (left outer), Drop (Inner) [fail] | continue | drop | reject [keep] | drop
Opções em secundária sem
correspondência Keep (right outer), Drop (Inner) NONE capture in reject set(s)
Em correspondência, as entradas
capturado Capturado Consumido
secundárias são
Nº de saídas 1 1 saída, (1 rejeição) 1 out, (N rejeições)
Entradas primárias sem Entradas secundárias sem
Capturado em conjuntos de rejeição Nada (N/A)
correspondência correspondência
Gráfico de comparação
Esse gráfico resume as diferenças entre três estágios de combinação. O ponto
principal aqui é que os estágios Join e Merge são leves com relação ao uso da
memória, mas têm o requisito adicional de que os dados sejam classificados. O estágio
Lookup não tem o requisito de classificação, mas é pesado em termos de uso de
memória.
Além dos requisitos de memória, cada estágio oferece um conjunto de propriedades
levemente diferente.

O que é um estágio Funnel?

• Coleta linhas de dados de vários links de entrada em um único fluxo
de saída
 As linhas que saem têm os mesmos metadados que as linhas que entram.
Apenas mais linhas
• Todas as origens devem ter metadados compatíveis
 Mesmo número de colunas de tipos compatíveis
• Três modos
 Continuous: os registros são combinados em ordem aleatória
 Sort Funnel: preserva a saída classificada dos links de entrada
 Sequence: produz como saída todos os registros do primeiro link de
entrada, então todos do segundo link e assim por diante
O que é um estágio Funnel?

O estágio Funnel coleta linhas de dados de vários links de entrada em um único fluxo
de saída. Embora o estágio Funnel combine dados, ele combina de uma maneira
muito diferente dos estágios Join, Merge e Lookup. O último combina horizontalmente
as colunas de cada link de entrada. O link de saída do estágio Funnel tem as mesmas
colunas que nos links de entrada. E cada link de entrada tem o mesmo número de
colunas com tipos compatíveis.

Exemplo do estágio Funnel
Estágio Funnel
Exemplo do estágio Funnel

O slide mostra uma tarefa com um estágio Funnel. Ambos os links de entrada devem
ter os mesmos metadados, ou seja, o mesmo número de colunas e tipos de coluna
compatíveis. A saída é um fluxo único contendo todas as linhas de ambos os links de
entrada.
O número total de linhas que passa através do link de saída é a soma do número de
linhas para cada link de entrada.

Propriedades do estágio Funnel

• O estágio Funnel tem somente uma propriedade: Tipo Funnel
 Aqui, Continuous Funnel foi selecionado
Propriedade
Funnel Type
Propriedades do estágio Funnel

Este slide mostra as propriedades do estágio Funnel. O estágio Funnel tem somente
uma propriedade: Tipo Funnel. Aqui, Continuous Funnel foi selecionado. Isso implica
que os registros que passam através do link de saída não estarão em nenhuma ordem
em particular.

1. Qual estágio usa a menor quantidade de memória? Join ou Lookup?
2. Qual estágio requer a classificação dos dados de entrada? Join ou
Lookup?
3. Se o link de entrada esquerdo tiver 10 linhas e o link de entrada
direito tiver 15 linhas, quantas linhas serão produzidas como saída
do estágio Join para uma junção externa esquerda? Do estágio
Funnel?


1. Join
2. Join
3. Pelo menos 10 linhas serão produzidas como saída do estágio Join
usando uma junção externa esquerda. Possivelmente, até 15, se
houver múltiplas correspondências. 25 linhas serão produzidas como
saída do estágio Funnel.

Demonstração 3
Uso dos estágios Join, Merge e Funnel
Demonstração 3: Uso dos estágios Join, Merge e Funnel

Demonstração 3:
Uso dos estágios Join, Merge e Funnel
Propósito:
Você deseja entender como os estágios Join, Merge e Funnel podem ser
usados para combinar dados, portanto, criará cada um desses estágios em
uma tarefa.
NOTA:
Etapas:
exibida.
Tarefa 1. Use o estágio Join em uma tarefa.
1. Abra a tarefa LookupWarehouseItem. Salve-a como JoinWarehouseItem.
2. Exclua o estágio Lookup e substitua-o por um estágio Join disponível na pasta
Processing na paleta. (Apenas exclua o estágio Lookup, arraste sobre um
estágio Join e, então, reconecte os links.)
3. Verifique se consegue visualizar os dados no estágio Warehouse.

4. Verifique se consegue visualizar os dados no estágio Items.

5. Abra o estágio Join. Faça a junção por Item. Especifique uma junção Right Outer.
6. Clique na guia Link Ordering. Torne o Warehouse o link Right selecionando

Items ou Warehouse e, então, clicando na seta para cima ou para baixo
conforme adequado.
7. Clique na guia Output > Mapping. Assegure-se de que todas as colunas

estejam mapeadas para a saída.

8. Edite o estágio Sequential File de destino. Edite ou confirme que a tarefa é

gravada em um arquivo chamado WarehouseItems.txt no diretório Temp de
arquivos de laboratório.
9. Compile e execute. Verifique se o número de registros gravados no arquivo
sequencial de destino é o mesmo que os lidos do arquivo Warehouse.txt, já
que essa é uma junção Right Outer.
10. Visualize os dados. Verifique se é feita a junção da descrição em cada registro

de arquivo Warehouse das colunas.

Tarefa 2. Use o estágio Merge em uma tarefa.

Nesta tarefa, você verá se o estágio Merge pode ser usado no lugar do estágio
Join. Você verá que ele não pode ser usado com sucesso.
1. Salve sua tarefa como MergeWarehouseItem. Substitua o estágio Join pelo
estágio Merge. (Apenas exclua o estágio Join, arraste sobre um estágio Merge
e, então, reconecte os links.)
2. No estágio Merge, especifique que os dados devem ser mesclados, com

distinção entre maiúsculas e minúsculas, pela chave (Item). Presuma que os
dados sejam classificados em ordem crescente. Especifique também que
registros sem correspondência do Warehouse (o link mestre) devem ser
eliminados

3. Na guia Link Ordering, garanta que o link Warehouse seja o link mestre.
4. Na guia Output > Mapping, certifique-se de que todas as colunas de entrada

sejam mapeadas para as colunas de saída adequadas.
5. Compile e execute. Visualize os dados.

6. Visualize o log da tarefa. Observe que vários registros principais foram
eliminados por serem duplicatas.
Lembre-se de que o estágio Merge requer que os dados mestre não tenham
duplicatas na coluna-chave. Vários registros de atualização também foram
eliminados porque eles não correspondiam aos registros principais.

A moral aqui é que não se pode usar o estágio Merge se a origem principal
tiver duplicatas. Nenhum dos registros duplicados corresponderá a registros de
atualização.
Lembre-se de que outro requisito do estágio Merge (e do estágio Join) é que os
dados sejam particionados para hash e classificados pela chave. Você não fez
isso explicitamente, então por que a sua tarefa não falhou? Vamos examinar o
log da tarefa para pistas.
7. Abra a mensagem Score.
Observe que particionadores de hash e classificações (operadores tsort) foram
inseridos pelo DataStage.
Tarefa 3. Use o estágio Funnel em uma tarefa.

Nesta tarefa, você passará as linhas de dois arquivos de entrada por um funil para
um único arquivo.
1. Abra uma nova tarefa paralela e salve-a como FunnelWarehouse. Inclua links
e estágios e nomeie-os conforme mostrado.

2. Edite os dois estágios Sequential File de origem para, respectivamente, extrair

os dados dos dois arquivos Warehouse, Warehouse_031005_01.txt e
Warehouse_031005_02.txt. Eles têm o mesmo formato e definições de coluna
que o arquivo Warehouse.txt fi.
3. Edite o estágio Funnel para combinar dados dos dois arquivos no modo
Continuous Funnel.
4. Na guia Output > Mapping, mapeie todas as colunas pelo estágio.

5. No estágio de destino, grave em um arquivo chamado TargetFile.txt no
diretório Temp.
6. Compile e execute. Verifique se o número de linhas que vai para o destino é a
soma do número de linhas que vem das duas origens.
Resultados:
Você desejava entender como os estágios Join, Merge e Funnel podem ser
usados para combinar dados, portanto, criou cada um desses estágios em
uma tarefa.

Resumo da unidade
• Combinar dados usando o estágio Lookup
• Definir consultas de intervalo
• Combinar dados usando o estágio Merge
• Combinar dados usando o estágio Join
• Combinar dados usando o estágio Funnel
Resumo da unidade


Unidade 9 Estágios de processamento de grupo
Estágios de processamento
de grupo


• Classificar dados usando classificações em estágio e o estágio Sort
• Combinar dados usando o estágio Aggregator
• Combinar dados usando o estágio Remove Duplicates
Estágios de processamento de grupo © Copyright IBM Corporation 2015

Estágios de processamento de grupo

• Os estágios de processamento de grupo incluem:
 Estágio Sort
 Estágio Aggregator
 Estágio Remove Duplicates
 Estágio Transformer (discutido em outra unidade)
• Em todos os estágios de processamento de grupo, você especificará
uma ou mais colunas que definem os grupos

Estágios de processamento de grupo executam atividades em grupos de linhas. Os
grupos são definidos por uma ou mais colunas-chave. O estágio Sort coloca os grupos
em ordem de classificação. O estágio Aggregator executa cálculos com relação a cada
grupo. O estágio Remove Duplicates mantém uma única linha de cada grupo.
Além dos estágios Sort, Aggregator e Remove Duplicates, o estágio Transformer
também pode executar processamento de grupo. Isso é discutido em uma unidade
posterior.

Classificação de dados
• Usos
 A classificação é uma necessidade de negócios comum
− Pré-requisito para muitos tipos de relatórios
 Alguns estágios requerem entrada classificada
− Estágios Join, Merge
 Alguns estágios são mais eficientes com entrada classificada
−O estágio Aggregator usa menos memória
• Duas maneiras de classificar:
 Classificações em estágio
− Na guia Partitioning do link de entrada
• Requer um algoritmo de particionamento diferente de Auto
−O ícone de classificação aparece no link de entrada
 Estágios Sort
− Mais propriedades configuráveis que a classificação em estágio
Classificação de dados
A classificação tem muitos usos dentro de tarefas do DataStage. Além de implementar
as necessidades de negócios, os dados de entrada classificados são exigidos por
alguns estágios e úteis para outros.
A classificação pode ser especificada dentro de estágios (classificações no estágio) ou
usando um estágio Sort separado. O último fornece propriedades que não estão
disponíveis em classificações no estágio.

Alternativas de classificação
Estágio Ícone de classificação

Sort em estágio
Alternativas de classificação
O slide mostra duas tarefas que classificam dados. O estágio Sort é usado na tarefa
superior. Na tarefa inferior, você vê o ícone de classificação no estágio, que fornece
um indicador visual de que uma classificação foi definida no estágio associado ao
ícone.

Classificação em estágio
Guia Ativação da Preservação da ordenação
Partitioning classificação de linha não chave
Remoção de
duplicatas
Seleção de Seleção de algoritmo Chave de

colunas-chave de particionamento classificação
Classificação em estágio
Este slide mostra a guia Input > Partitioning de um estágio típico (aqui, o estágio
Merge). Para especificar uma classificação no estágio, primeiro marque a caixa de
seleção Perform sort. Então, marque as colunas-chave de classificação na caixa
Available. Na caixa Selected, é possível especificar algumas opções de classificação.
Opcionalmente, você pode selecionar Stable. Stable preservará a ordenação original
dos registros dentro de cada grupo de chave. Se não estiver configurado, nenhuma
ordenação em particular dos registros dentro de grupos de classificação será
garantida.
Opcionalmente, selecione a caixa Unique para remover linhas duplicadas com base
nas colunas-chave.
A classificação estará ativa somente se um Partition type diferente de Auto for
selecionado.

Ilustração de classificação estável
Chave Col Chave Col
4 X 1 K
3 Y 1 A
1 K 2 P
3 C 2 L
2 P 3 Y
3 D 3 C
1 A 3 D
2 L 4 X
Ilustração de classificação estável

Esse diagrama mostra como a classificação estável funciona. A ordenação de valores
de coluna não chave dentro de cada grupo de classificação é preservada. Por
exemplo, à esquerda, a linha 1-K está antes da linha 1-A. À direita, a ordenação é
preservada. De modo similar, a linha 2-P é anterior à linha 2-L. A ordenação é
preservada.
Às vezes, devido a necessidades de negócios, essa ordenação precisa ser
preservada. Por exemplo, suponha que o último registro seja considerado a versão
"final", que é usada em processamento posterior. As versões anteriores devem ser
removidas do processamento posterior.

Guia Properties do estágio Sort
Chave de
classificação
Opções de
classificação
Guia Properties do estágio Sort

Este slide mostra a parte interna do estágio Sort e destaca a propriedade Sort Keys.
Neste exemplo, a chave de classificação tem três colunas.
Há duas pastas de propriedades: Sorting Keys, Options. Essas propriedades e
opções são discutidas nas próximas páginas.

Especificação de chaves de classificação

• Inclusão uma ou mais chaves
• Especificação do modo de chave de classificação para cada chave
 Sort: classificar por esta chave
 Don’t sort (previously sorted):
− presume que os dados já foram classificados nessa chave
 O propósito é evitar classificação desnecessária, que afeta o desempenho
• Especificação da ordem de classificação: ascendente/decrescente
• Especificação da distinção entre maiúsculas e minúsculas
Especificação de chaves de classificação

A propriedade mais importante dentro do estágio Sort, e que não está disponível para
classificações em estágio, é a propriedade Sort Key Mode. Seu propósito é evitar
classificação desnecessária, que afeta o desempenho. Se os dados já tiverem sido
parcialmente classificados, o estágio poderá aproveitar isso.

Opções do estágio Sort
Opção Mais informações

Sort Utility Escolha DataStage, que é o padrão
Stable O mesmo que para classificação em estágio
Allow duplicates O mesmo que para classificação em estágio
Restrict Memory Especifica a quantidade máxima de memória ou a memória
Usage que pode ser usada para classificação
property • A quantidade é por partição
A classificação é feita na memória para melhorar o
desempenho
• Usa o disco utilizável (conforme definido no arquivo de
configuração) se ficar sem memória
Aumentar a quantidade de memória pode aumentar o
desempenho
Create key Inclua uma coluna com um valor de 1 / 0
change 1 indica que o valor da chave mudou
0 significa que o valor da chave não mudou
column Útil para processamento de grupo no estágio Transformer
Opções do estágio Sort

Há várias propriedades de classificação opcionais disponíveis no estágio Sort.
Por padrão, o estágio Sort usa o utilitário de classificação do DataStage. Isso é mais
rápido que a alternativa.
Restrict Memory Usage especifica a quantidade máxima de memória disponível ao
estágio por partição. Aumente esse valor se não houver memória suficiente disponível
para o estágio.
A propriedade Create key change Column é usada para agrupar processamento
dentro de um estágio Transformer de recebimento de dados. Processamento de grupo
no estágio Transformer é discutido em uma unidade posterior.

Criação de coluna de mudança de chave
Chave Col Chave Col K_C
4 X 1 K 1
3 Y 1 A 0
1 K 2 P 1
2 L 0
3 C
3 Y 1
2 P
3 D 3 C 0
1 A 3 D 0
2 L 4 X 1
Criação de coluna de mudança de chave

Este diagrama ilustra como a Create Key Change Column funciona. Observe que,
após a classificação, uma coluna adicional (K_C) foi incluída com números 1 e 0. "1"
indica o início de um novo grupo de linhas. Neste exemplo, 3-Y, 1-K e 4-X estão entre
as linhas que iniciam novos grupos.
O estágio Transformer vê uma linha por vez, mas pode continuar executando totais.
Ele pode usar a coluna de mudança de chave para detectar quando seu total para um
grupo está completo.

Classificações da partição
• A classificação ocorre separadamente dentro de cada partição
 Por padrão, o estágio Sort é executado em modo paralelo
• E se você precisar de uma classificação global final, ou seja, uma
classificação de todos os dados, não apenas dos dados em uma
partição em particular?
 Ao gravar os dados, colete-os usando o algoritmo Sort Merge
 Ou execute o estágio Sort no modo sequencial
(não recomendado porque reduz o desempenho)
Classificações da partição
Por padrão, o estágio Sort é executado em modo paralelo. A classificação ocorre
separadamente dentro de cada partição. Em muitos casos, essa é toda a classificação
necessária. Em alguns casos, uma classificação global entre todas as partições é
necessária. Mesmo neste caso, faz sentido executar o estágio no modo paralelo e
coletá-lo depois usando Sort Merge. Isso geralmente é muito mais rápido que
executar o estágio no modo sequencial.

Estágio Aggregator
• Propósito: executar agregações de dados
 Funciona como uma instrução SQL com uma cláusula GROUP BY
• Especifique uma ou mais colunas que definam os grupos de
agregação
• Dois tipos de agregações
 Aqueles que agregam os dados dentro de colunas específicas
− Seleção de colunas
− Especificação das agregações: SUM, MAX, MIN etc.
 Aqueles que simplesmente contam as linhas dentro de cada grupo
• O estágio Aggregator pode funcionar de modo mais eficiente se os
dados tiverem sido pré-classificados
 Especificado na propriedade Method: Hash (padrão) / Sort
Estágio Aggregator
Este slide apresenta os principais recursos do estágio Aggregator. Ele funciona de
modo muito semelhante a uma
instrução SQL com uma cláusula GROUP BY. Porém, contém muito mais agregações
possíveis que aquelas que o SQL fornece.
As principais atividades que você executa no estágio Aggregator são especificar as
colunas-chave que definem os grupos e selecionar as agregações que o estágio deve
executar. Há dois tipos básicos de cálculos: contar as linhas dentro de cada grupo, que
é um cálculo que não é executado com relação a nenhuma coluna específica; e
cálculos executados com relação às colunas selecionadas.
Se os dados que estão indo para o estágio Aggregator já tiverem sido classificados,
esse estágio poderá funcionar de maneira mais eficiente. Você indica isso usando a
propriedade Method.

Tarefa com estágio Aggregator
Estágio
Aggregator
Tarefa com estágio Aggregator

Este slide mostra um design de tarefa "bifurcação-junção" com um estágio Aggregator.
Nesta tarefa, todas as linhas saem por ambos os links de saída do estágio Copy. Um
link de saída vai para o estágio Aggregator, em que os dados são agrupados e
resumidos. Então, o resultado resumido é unido de volta a cada uma das linhas que vai
do estágio Copy para o Join.
Isso é chamado de design de tarefa de "bifurcação-junção" porque os dados são
bifurcados em vários fluxos de saída e, então, reunidos de volta.

Tipos de agregação
• Count rows
 Contagem de linhas em cada grupo
 Especificação da coluna de saída
• Calculation
 Seleção das colunas para cálculo
 Seleção de cálculos a executar, incluindo:
− Soma
− Mín., máx.
− Média
− Contagem de valor ausente
− Contagem de valor não ausente
 Especificação das colunas de saída
Tipos de agregação
Há dois tipos básicos de agregação: Count rows, Calculation. O primeiro conta o
número de linhas em cada grupo. Com o segundo tipo, você seleciona uma coluna de
entrada em que deseja executar o cálculo. Então, você seleciona os cálculos a
executar naquela coluna de entrada e as colunas de saída nas quais colocar os
resultados.

Tipo de agregação Count Rows
Coluna-chave
do grupo
Tipo de
agregação
Count Rows
Coluna para
o resultado
Tipo de agregação Count Rows

Este slide mostra a parte interna do estágio Aggregator na guia Properties e destaca
as propriedades principais. A propriedade Group especifica as colunas que definem os
grupos. Selecione Count Rows ou Calculation para a propriedade Aggregation
Type.
Para especificar uma nova coluna de saída, basta digitar o nome da coluna de saída
na propriedade Count Output Column. Essa coluna aparecerá na guia Output >
Mapping com um tipo padrão. Na guia Output > Mapping, é possível editar o tipo de
dados da coluna, se necessário.
Neste exemplo, Sort foi selecionado para a propriedade Method. Isso informa o
estágio de que os dados que vão para o estágio já foram classificados. O estágio em si
não classifica os dados! Se os dados não forem de fato classificados, ocorrerão erros
de tempo de execução.

Guia Output Mapping

• Arraste as colunas para criar as colunas de saída
• É possível modificar o nome e o tipo das colunas na guia
Columns
Coluna de resultados para contagem

Guia Output Mapping

Este slide mostra a guia Output > Mapping do estágio Aggregator. É onde você
mapeia os resultados da agregação para produzir colunas como saída. Neste exemplo,
a saída do estágio ainda não foi especificada. Aqui, ambas as colunas à esquerda
serão arrastadas para o link de saída. Assim, o link de saída terá os resultados do
grupo e da chave do grupo. A chave do grupo será usada para a junção dos dados de
volta ao outro fluxo, no estágio Join.

Guia Output Columns

• Novas colunas de saída são criadas com um tipo padrão de Double
 Opcionalmente, mude o tipo da coluna de saída
Tipo de coluna
padrão
Guia Output Columns

Este slide mostra a guia Output > Columns. Ele mostra os metadados da coluna
de saída para as colunas especificadas na guia Properties. É possível editar os
nomes da coluna e os tipos padrão.

Tipo de agregação Calculation
Coluna-chave de
agrupamento
Tipo de agregação
Calculation
Cálculos e nomes da
coluna de saída
Coluna para
cálculo
Mais cálculos
Tipo de agregação Calculation

Neste exemplo, foi selecionado o tipo de agregação Calculation. Quando esse tipo
é selecionado, é preciso selecionar uma ou mais colunas sobre as quais os
cálculos serão executados junto com as colunas de resultados para os cálculos.
Neste exemplo, os cálculos estão sendo executados sobre os valores na coluna
Item. O Maximum é obtido e colocado em uma coluna chamada ItemMax. O
Minimum é obtido e colocado em uma coluna chamada ItemMin.

Métodos de agrupamento
• Hash (padrão)
 Os cálculos são feitos para todos os grupos e armazenados na memória
− Estrutura da hashtable (portanto, o nome)
 Os resultados são gravados depois de todas as colunas na partição terem
sido processadas
 A entrada não precisa ser classificada
 É necessário ter memória suficiente para armazenar todos os grupos de
dados a serem processados
• Sort
 Requer que os dados de entrada sejam classificados por chaves de
agrupamento
− Não executa a classificação! Espera a classificação
 Somente um único grupo é mantido na memória por vez
− Depois de um grupo ser processado, o resultado do grupo é gravado
 Precisa apenas de memória suficiente para armazenar o grupo processado
no momento
Métodos de agrupamento
Há dois métodos de agrupamento no estágio Aggregator. Isso resume seus recursos e
diferenças. O método padrão é Hash. Quando esse método é selecionado, o estágio
Aggregator faz os cálculos para todos os grupos e armazena os resultados na
memória. Dito de outra forma, todos os dados de entrada são lidos e processados. Se
não houver memória suficiente para ler e processar todos os dados na memória, o
estágio usará o disco utilizável, que torna o processo consideravelmente mais lento.
Esse método não exigiu a pré-classificação dos dados.
O método Sort requer que os dados sejam pré-classificados. O estágio em si não
executa a classificação. Quando Sort é selecionado, o estágio somente armazena um
único grupo na memória por vez. Assim, é necessária muito pouca memória. O estágio
Aggregator também funciona mais rapidamente, uma vez que os dados foram pré-
processados.

Method = Hash
Chave Col 4 4X
4 X
3 Y
1 K 3 3Y 3C 3D
3 C
2 P 1 1K 1A
3 D
1 A 2 2P 2L
2 L
Method = Hash
Este diagrama ilustra o método Hash.
Quando o Method é igual a Hash, todos os grupos de dados devem ser colocados na
memória. Isso é ilustrado pelo círculo em torno de todos os grupos. A estrutura na
memória é uma estrutura com chave para retorno rápido dos resultados.

Method = Sort
Chave Col
1 K
1K 1A
1 A
2 P
2 L
2P 2L
3 Y
3 C
3 D 3Y 3C 3D
4 X
4X
Method = Sort
Este diagrama ilustra o método Sort.
Quando Method é igual a Sort, apenas o grupo atual precisa ser colocado na
memória. Isso é ilustrado pelos círculos ao redor dos grupos individuais.

Remoção de duplicatas
• por estágio Sort
 Uso de uma única opção
− Não há escolha quanto a qual duplicata manter
−A classificação estável sempre retém a primeira linha no grupo
−A classificação não estável é indeterminada
OU
• por estágio Remove Duplicates

 Tem maneiras mais sofisticadas de remover duplicatas
− Pode escolher reter a primeira ou a última
Remoção de duplicatas
Há várias maneiras de remover duplicatas em uma tarefa do DataStage. Ao classificar,
é possível especificar que as duplicatas sejam removidas, esteja você classificando
usando um estágio Sort ou executando uma classificação em estágio. Como
alternativa, a tarefa pode usar o estágio Remove Duplicates. A vantagem de usar o
estágio Remove Duplicates é que você pode especificar se a primeira ou a última
duplicata deve ser retida.

Tarefa do estágio Remove Duplicates
Estágio Remove
Duplicates
Tarefa do estágio Remove Duplicates

Aqui está um exemplo de tarefa do DataStage com um estágio Remove Duplicates.
Como o estágio Sort, ele tem um link de entrada e um link de saída.

Propriedades do estágio Remove Duplicates
Colunas que
definem duplicatas
Duplicatas a
reter
Opcionalmente, inclua
mais colunas-chave
Propriedades do estágio Remove Duplicates

Este slide mostra a guia Properties do estágio Remove Duplicates. A principal
exigência é especificar as colunas Key que definem o que conta como um registro
duplicado (dois registros com valores da chave correspondentes). É importante
observar que uma duplicata não significa que todos os dados são correspondentes
no registro. Significa apenas que todos os dados nas colunas-chave especificadas
correspondem. As colunas-chave definem o que significa ser uma duplicata.
A outra propriedade-chave no estágio é a propriedade Duplicate to Retain. Essa
propriedade não está disponível no estágio Sort.

1. Que estágio é usado para executar cálculos de valores de coluna
agrupados de maneiras específicas?
2. Quais são os dois modos possíveis de executar classificações?
3. O que é uma classificação estável?
4. Quais são dois tipos de agregações que podem ser executados?


1. Estágio Aggregator
2. Uso do estágio Sort. Classificações em estágio.
3. A classificação estável preserva a ordem de valores não chave.
4. Contagem de linhas e cálculos.

Demonstração 1

 Criar uma tarefa que use os estágios Sort, Aggregator e Remove Duplicates
 Criar um design de tarefa de bifurcação-junção
Demonstração 1: Estágios de processamento de grupo

Demonstração 1:
Propósito:
Para entender como os grupos de dados são processados, você criará uma
tarefa que use os estágios Sort, Aggregator e Remove Duplicates. Também
criará um design de bifurcação-junção.
NOTA:
Etapas:
exibida.

Tarefa 1. Crie o design de tarefa.

1. Abra uma nova tarefa paralela e salve-a como ForkJoin. Inclua estágios e links
e nomeie-os conforme mostrado. Você localizará Sort , Aggregator ,
Copy , Join , and Remove Duplicates em Palette > Processing.
2. Edite o estágio Sequential File Selling_Group_Mapping_Dups para ler do

arquivo Selling_Group_Mapping_Dups.txt. Ele tem o mesmo formato que o
arquivo Selling_Group_Mapping.txt.

3. Edite o estágio Sort Sort_By_Code. Execute uma classificação ascendente

por Selling_Group_Code. A classificação não deve ser estável. Envie todas
as colunas através do estágio.
4. No estágio Copy, especifique que todas as colunas se movam pelo estágio

para o link CopyToJoin.

5. Especifique que apenas a coluna Selling_Group_Code se mova através do

estágio Copy para o estágio Aggregator.
6. Edite o estágio Aggregator. Especifique que os registros devem ser agrupados

por Selling_Group_Code.
7. Especifique que o tipo de agregação é Count Rows.
8. Especifique que o valor da agregação irá para uma coluna chamada
CountGroup.
Selecione Sort como o método de agregação, pois os dados foram
classificados pela coluna-chave de agrupamento.
Em seguida, você deseja definir as colunas.

9. Na guia Output > Mapping, arraste ambas as colunas para AggToJoin.

Queremos incluir o Selling_Group_Code para podermos fazer a junção das
saídas no estágio Join mais tarde.
10. Na guia Output > Columns, defina CountGroup como um número inteiro,
comprimento 10.
11. Edite o estágio Join. A chave de junção é Selling_Group_Code. O tipo de

junção é Left Outer.

12. Verifique, na guia Link Ordering, que o link CopyToJoin é o link esquerdo.
13. Na guia Output > Mapping, mapeie todas as colunas. Clique em Yes para a
mensagem sobre a substituição do valor, se solicitado.

14. Edite o estágio Sort_By_Handling_Code. A coluna-chave do

Selling_Group_Code já foi classificada, assim, especifique Don't Sort
(Previously Sorted) para ela. Inclua Special_Handling_Code como uma
chave de classificação adicional. Desative a classificação estável.
15. Na guia Output > Mapping, mova todas as colunas pelo estágio.
16. Na guia Input > Partitioning, selecione Same para garantir que o
particionamento que está indo para o estágio não mude.

17. Edite o estágio Remove Duplicates. Agrupe por Selling_Group_Code.

Retenha o último registro em cada grupo.
18. Na guia Output > Mapping, mova todas as colunas pelo estágio.
19. Edite o estágio Sequential de destino. Grave em um arquivo chamado
Selling_Group_Code_Deduped.txt no diretório Temp dos arquivos de
laboratório. Na guia Partitioning, colete os dados usando Sort Merge com
base nas duas colunas pelas quais os dados foram classificados, clicando nas
colunas para movê-las para a caixa Selected.
20. Compile e execute. Visualize o log da tarefa para verificar se há problemas.

21. Visualize os resultados. Deve haver menos linhas indo para o estágio de
destino do que o número saindo do estágio de origem, uma vez que os
registros duplicados foram eliminados.
22. Visualize os dados no estágio de destino. Dê uma olhada no CountGroup para

ver se você está recebendo várias contagens duplicadas para algumas linhas.
Resultados:
Para entender como os grupos de dados são processados, você criou uma
tarefa que usa os estágios Sort, Aggregator e Remove Duplicates. Além
disso, você também criou um design de bifurcação-junção.

Design de tarefa de bifurcação-junção
Bifurcação
de dados
Junção de dados
Design de tarefa de bifurcação-junção

O estágio Copy bifurca os dados em dois fluxos de saída. Um fluxo vai para o estágio
Aggregator, no qual os cálculos são executados em todos os grupos de dados na
entrada. Os resultados são, então, reunidos de volta para cada linha de dados da
bifurcação esquerda.

Resumo da unidade
• Classificar dados usando classificações em estágio e o estágio Sort
• Combinar dados usando o estágio Aggregator
• Combinar dados usando o estágio Remove Duplicates
Resumo da unidade

Unidade 10 Estágio Transformer
Estágio Transformer

U n i d a d e 1 0 E s t á g i o Tr a n s f o r m e r

• Usar o estágio Transformer em tarefas paralelas
• Definir restrições
• Definir derivações
• Usar variáveis de estágio
• Criar um conjunto de parâmetros e usar seus parâmetros em
restrições e derivações
Estágio Transformer © Copyright IBM Corporation 2015
Esta unidade foca no estágio primário para implementar lógica de negócios em uma
tarefa do DataStage, a saber, o Transformer.

• Estágio principal para filtrar, direcionar e transformar dados
 Apenas linhas que satisfazem a condição especificada podem passar o link
 Use para filtrar dados
− Por exemplo, apenas gravar linhas para clientes localizados na Califórnia
 Use para direcionar dados por links de saída diferentes com base nas condições
especificadas
− Por exemplo, enviar a clientes não registrados um link e a clientes registrados, outro
 Derivar um valor de saída de várias colunas de entrada e gravá-los em uma
variável de estágio ou coluna
• Compila em um operador customizado no OSH
 É por isso que o DataStage requer um compilador C++
• Opcionalmente, inclui um link de rejeição
 Captura linhas que o estágio Transformer não pode processar
Aqui, são listados os principais recursos do estágio Transformer, que é o estágio
primário para filtragem, direcionamento e transformação de dados.
Em um estágio Transformer, é possível especificar restrições para quaisquer links de
saída. As restrições podem ser usadas para filtrar dados ou para restringir os dados à
execução em um link de saída específico.
Em um estágio Transformer, é possível definir derivações para qualquer coluna ou
variável de saída. Uma derivação define o valor que deve ser gravado na coluna ou
variável.

Tarefa com um estágio Transformer
Transformer
Entrada única
Link de
rejeição
Várias
saídas
Tarefa com um estágio Transformer

Este slide mostra um exemplo de uma tarefa com um estágio Transformer.
Neste exemplo, as linhas que são gravadas no estágio Transformer são direcionadas
por um dos dois links de saída com base nas restrições definidas no estágio. As linhas
que não podem ser processadas pelo estágio Transformer são capturadas por um link
de rejeição.

Por dentro do estágio Transformer
Variáveis
de estágio
Loops
Colunas
do link de
entrada Derivações
Colunas
de saída
Definições
de coluna

Este slide mostra a parte interna do estágio Transformer e destaca seus principais
recursos, que são descritos em mais detalhes nas próximas páginas.
Na parte superior esquerda, há colunas do link de entrada indo para o Transformer. As
definições para essas colunas são exibidas na parte inferior esquerda.
Na parte superior direita, há colunas para cada um dos links de saída do estágio. As
colunas para cada link de saída estão localizadas em janelas separadas dentro do
estágio. As definições para essas colunas são exibidas e editadas na parte inferior
direita.

Elementos do estágio Transformer (1 de 2)

• Colunas do link de entrada
 Nomes de colunas são listados na janela do link de entrada no lado esquerdo
 Metadados da coluna (nome, tipo, capacidade de anulação) são especificados
nas guias na parte inferior
− Uma guia por janela do link
• Colunas do link de saída
 Os nomes das colunas de link são listados nas janelas do link de saída no lado
direito
 Metadados da coluna (nome, tipo, capacidade de anulação) são especificados
nas guias na parte inferior
 Há uma janela do link de saída para cada link de saída
− Título é o nome do link de saída. (Certifique-se de nomear seus links de saída!)
• Células de derivação
 Células à esquerda de cada variável de estágio ou coluna de saída
 Clique duas vezes na célula para abrir o editor de expressão
Elementos do estágio Transformer

Aqui, são descritos os principais recursos do estágio Transformer identificados na
página anterior.

Elementos do estágio Transformer (2 de 2)

• Restrições
 Clique duas vezes à direita da palavra "Constraint" na parte superior de uma
janela de link de saída para abrir a janela Transformer Stage Constraints
− Como alternativa, clique no ícone Constraints na parte superior (segundo da esquerda)
• Janela Stage variables: Parte superior direita
 Lista as variáveis de estágio definidas na ordem de execução
 Clique com o botão direito do mouse, então clique em Stage Variable Properties
para definir novas variáveis de estágio
• Janela Loop Condition: Segundo na parte superior direita
 Clique com o botão direito, então clique em Loop Variable Properties para definir
novas variáveis de loop
 Clique duas vezes à direita de Loop While para abrir o editor de expressão para
definir a condição Loop While
• Propriedades do estágio Transformer
 Clique no ícone no canto superior esquerdo da janela
Continua da descrição dos recursos do estágio Transformer identificados na página

anterior.

Restrições
• O que é uma restrição?
 Definida para cada link de saída
 Especifica uma condição sob a qual uma linha de dados pode fluir para fora do
link
• Usos
 Filtrar dados: Funciona como uma cláusula SQL WHERE
 Direciona os dados por diferentes links de saída com base nas restrições
definidas nos links
• Construído usando o editor de expressão
• Especificado na janela Constraints
 Lista os nomes dos links de saída
 Clique duas vezes na célula à direita do nome do link para abrir o editor de
expressão do estágio para definir a restrição
 Links de saída sem restrições definidas produzem todas as linhas como saída
Restrições
Descreve os principais recursos das restrições: o que são, como são utilizados e como
são construídos.
Uma restrição é uma condição. É verdadeira ou falsa. Quando é verdadeira
(cumprida), os dados podem fluir através do link de saída. Apenas se a restrição for
atendida, as derivações para cada uma das colunas de saída do link serão
executadas.

Exemplo de restrições
• Aqui, códigos de manipulação baixos são direcionados por um link de
saída e códigos de manipulação altos, pelo outro
• No Transformer, as restrições são definidas para ambos os links de saída
Exemplo de restrições
Este slide exibe uma tarefa paralela com um estágio Transformer. Há dois links de
saída. No Transformer, as restrições são definidas para ambos os links de saída.
Neste exemplo, códigos de manipulação baixos são direcionados por um link de saída
e códigos de manipulação altos, pelo outro.
Uma linha de dados pode cumprir uma ou mais de uma restrição de link de saída. Será
gravado cada link de saída cuja restrição seja atendida. Todas as linhas serão
gravadas para links que não tenham restrições.

Definição de uma restrição
Links de saída
Selecione a coluna
de entrada no menu

Clique duas vezes na célula à direita do nome do link para abrir o editor de expressão
do estágio Transformer para definir a restrição. Este slide mostra um exemplo de uma
restrição definida no editor de expressão. Selecione os itens do menu para criar a
restrição.
Clique no ícone Constraints no alto do Transformer (cadeia amarela) para abrir a
janela Transformer Stage Constraints.

Utilização do editor de expressão

• Clique com o botão direito do mouse no ponto em que deseja inserir
um item (por exemplo, uma coluna de entrada)
• Selecione o tipo de item a inserir na expressão
• Selecione na lista de itens apresentados
Utilização do editor de expressão

Aqui, é discutido o modo de construção de restrições. No exemplo mostrado na
captura de tela, uma coluna de entrada está sendo inserida na expressão. O menu
fornece uma lista de todos os itens (colunas de entrada, parâmetros da tarefa,
variáveis do sistema e assim por diante) que você pode inserir na expressão.
Como alternativa, é possível digitar manualmente os nomes desses itens, mas saiba
que alguns itens, como colunas de entrada, têm prefixos que fazem parte dos seus
nomes completos. As colunas de entrada são prefixadas pelos nomes dos seus links
de entrada.
O local do cursor determina o tipo de item disponível para inserção. Se o cursor estiver
localizado no lugar referente ao operador, o menu exibirá uma lista de operadores
disponíveis (>, <, = e assim por diante).

Links Otherwise para integridade de dados

• Suponha que uma linha contenha um código de manipulação especial
fora do intervalo de valores válidos
• É possível incluir um link otherwise para capturar essas linhas de
dados inválidos
 Inclua outro link
 Configure o link para ser o último na ordenação de link
 Marque a caixa Otherwise ao lado do nome do novo link
• A restrição otherwise captura todas as linhas que não atendem a
nenhuma das restrições executadas anteriormente
Links Otherwise para integridade de dados

Os links Otherwise podem ser incluídos para promover a integridade dos dados.
Suponha, por exemplo, que uma linha contenha um código de manipulação especial
fora do intervalo de valores válidos. É possível incluir um link otherwise para capturar
essas linhas de dados inválidos.
Um link otherwise é o mesmo que qualquer outro link de entrada, exceto que ele não
tem uma restrição explicitamente codificada definida para ele. Não confunda um link
otherwise com um link de rejeição. Este é um tipo especial de link de saída, indicado
pela linha quebrada.

Exemplo de link Otherwise

• O link RangeErrors tem como objetivo capturar quaisquer linhas
com códigos fora do intervalo aceitável
• Aqui, presume-se que as linhas que não atendem à restrição
LowCode ou HighCode são dados inválidos
Link
Otherwise
Exemplo de link Otherwise

Este slide mostra um link otherwise saindo de um Transformer. Ele é um link de saída
adicional. Ele vai capturar linhas que não percorrem os links de saída Lowcode e
Highcode.
Páginas subsequentes mostrarão como configurar RangeErrors para ser um link
otherwise.

Especificação da ordenação do link

• Os links de saída têm uma ordem de execução
 Uma linha é testada com relação à primeira restrição do link de saída,
então a segunda, e assim por diante
• Os links Otherwise devem ficar por último na ordem de execução
• Clique no ícone superior direito para abrir a guia Link Ordering
Link
Otherwise
Especificação da ordenação do link

Links Otherwise devem ser colocados por último na ordem de execução. Este slide
mostra a guia Link Ordering, em que a ordenação dos links de saída pode ser
especificada. Observe que RangeErrors fica por último na lista. Use os controles à
direita para mudar a ordenação de qualquer um dos links.
Clique no ícone Stage Properties no canto superior esquerdo do Transformer para
abrir a janela Transformer Stage Properties.

Especificação da restrição do link Otherwise

• Marcar esta caixa leva a duas ações:
 Captura linhas não processadas por links de saída anteriores
 Grava uma mensagem de aviso no log de qualquer linha percorrer o
link Otherwise
• Não codifique a restrição na célula Constraint
 Se você codificar uma restrição, ela atuará como uma restrição
comum, mas incluirá uma mensagem de aviso ao log se for atendida
Link Otherwise
Especificação da restrição do link Otherwise

Para criar um link Otherwise, marque a caixa Otherwise/Log ao lado do nome do link
na janela Transformer Stage Constraints, exibida aqui.
Não codifique uma restrição para um link Otherwise. Esse não é seu propósito e faz
com que ele se comporte como um link de saída comum.

Demonstração 1

 Definir restrições em uma tarefa
 Criar um link Otherwise
Demonstração 1: Definição de uma restrição

Demonstração 1:
Propósito:
Você deseja definir restrições no estágio Transformer de uma tarefa. Mais
adiante, você definirá um link Otherwise.
NOTA:
Etapas:
2. Selecione a opção Import selected e selecione a tarefa desejada na lista exibida.
de importar a versão do arquivo de soluções de laboratório.
Tarefa 1. Defina restrições do Transformer.
1. Crie uma nova tarefa paralela e salve-a como TransSellingGroup.
2. Inclua um estágio Sequential File (disponível em Palette > File), um estágio
Transformer (disponível em Palette > Processing) e dois estágios Sequential
File de destino à tela. Nomeie os links e estágios como mostrado.

3. Abra o estágio Sequential File de origem. Edite-o para ler os dados do arquivo
Selling_Group_Mapping_RangeError.txt. Ele tem os mesmos metadados
que o arquivo Selling_Group_Mapping.txt.
4. Abra o estágio Transformer. Arraste todas as colunas de entrada para ambas
as janelas do link de saída.
5. Clique duas vezes à direita da palavra Constraint em qualquer uma das

janelas do link de saída. Isso abre a janela Transformer Stage Constraints.

6. Clique duas vezes na célula Constraint para LowCode para abrir o

Expression Editor. Clique na caixa de reticências e selecione Input Column.
Comece selecionando Special_Handling_Code no menu Input Column.
Clique com o botão direito à direita do item incluído para usar o Editor para
definir uma condição que selecione somente linhas com códigos de
manipulação especial entre 0 e 2, inclusive.
7. Clique duas vezes na célula Constraint à direita do nome do link HighCode
para abrir o Expression Editor. Usando o mesmo processo que na etapa
anterior, defina uma condição que selecione apenas linhas com códigos de
manipulação especial entre 3 e 6, inclusive.
8. Edite o estágio Sequential File de destino LowCode para gravar um arquivo

chamado LowCode.txt no diretório Temp dos arquivos de laboratório.
9. Edite o estágio Sequential File de destino HighCode para gravar um arquivo
chamado HighCode.txt no diretório Temp dos arquivos de laboratório.
11. Visualize os dados nos arquivos de destino para verificar se cada um deles
contém as linhas certas. Aqui estão os dados do arquivo LowCode.txt.
Observe que ele contém apenas linhas com códigos de manipulação especial
entre 0 e 2.

Tarefa 2. Use um link Otherwise para capturar erros de

intervalo nos dados.
1. Salve sua tarefa como TransSellingGroupOtherwise.
2. Inclua um link adicional do Transformer para outro estágio Sequential File e
etiquete o novo estágio e link como RangeErrors.
3. No Transformer, arraste todas as colunas de entrada para o novo link de

destino.
4. Na barra de ferramentas, clique em Output Link Execution Order .

5. Reordene os links de modo que o link RangeErrors fique por último na

ordenação do link de saída. (Dependendo de como você traçou seus links,
esse link pode já ser o último.)
6. Abra a janela Constraints. Selecione a caixa Otherwise/Log à direita de

RangeErrors.
7. Edite o estágio Sequential File RangeErrors conforme necessário para gravar

no arquivo RangeErrors.txt no diretório Temp dos arquivos de laboratório.

8. Compile e execute sua tarefa. Deve haver alguns erros de intervalo.
Resultados:
Você definiu restrições no estágio Transformer de uma tarefa. Mais adiante,
você definiu um link Otherwise.

Derivações
• As derivações são expressões que derivam um valor
• Como expressões para restrições, elas são construídas a partir de itens:
 Colunas de entrada
 Parâmetros da tarefa
 Funções
 Variáveis de estágio
 Variáveis do sistema
• Como as derivações diferem de restrições
 As restrições são:
− Expressões true ou false
− Aplicam-se a linhas
 Derivações:
− Retornam um valor gravado em uma variável de estágio ou coluna de saída
− Aplicam-se a colunas
Derivações
Aqui estão os principais recursos de derivações. As derivações são expressões que
retornam um valor.
As derivações são construídas usando o mesmo editor de expressão com o qual as
restrições são construídas. Em sua maioria, elas contêm os mesmos tipos de itens. A
diferença é que as restrições são condições avaliadas para true ou false. Derivações
retornam um valor (que não true ou false) que pode ser armazenado em uma coluna
ou variável.

Destinos de derivação
• Os resultados da derivação podem ser gravados em:
 Colunas de saída
 Variáveis de estágio
 Variáveis de loop
• As derivações são executadas na ordem, de cima para baixo
 As derivações da variável de estágio são executadas primeiro
 As derivações da variável de loop são executadas em seguida
 As derivações da coluna de saída são executadas por último
− Executadas apenas se as restrições do link de saída forem atendidas
−A ordenação do link de saída determina a ordem entre os conjuntos das variáveis
do link de saída
Destinos de derivação
Os valores resultantes de derivações podem ser gravados em diferentes destinos:
colunas de saída, variáveis de estágio, variáveis de loop. (As variáveis de loop são
discutidas mais adiante nesta unidade.)

Variáveis de estágio
• Funcionam como colunas de destino, mas não são produzidos como
saída (diretamente) do estágio
• As variáveis de estágio são um item que pode ser referido em
derivações e restrições
 Em derivações, funcionam de maneira similar que colunas de entrada
• Têm muitos usos, incluindo:
 Simplificar derivações complexas
 Reduzir o número de derivações
−A derivação na variável de estágio é executada uma vez, mas pode ser usada
muitas vezes
Variáveis de estágio
As variáveis de estágio funcionam como colunas de destino, mas não são produzidas
como saída (diretamente) do estágio. As variáveis de estágio são um item (entre
outros) que pode ser referido em derivações e restrições. Elas têm muitos usos,
incluindo: simplificar derivações complexas e reduzir o número de derivações.
As variáveis de estágio são chamadas de variáveis de "estágio" porque seu escopo é
limitado ao Transformer em que são definidas. Por exemplo, uma derivação em um
Transformer não pode fazer referência a uma variável de estágio definida em outro
Transformer.

Definições da variável de estágio

• Clique no ícone Stage Properties (bem à esquerda)
 Clique na guia Stage Variables
• Definição da variável de estágio
 Nome
 Precisão e tipo SQL
 Valor inicial
− Valor antes do processamento de qualquer linha pelo estágio
Definições da variável de estágio

Definir uma variável de estágio é como definir uma coluna. Você especifica um nome,
um tipo e uma precisão. Diferente de colunas, porém, é possível inicializar a variável
de estágio com um valor. Esse é o valor que terá quando a primeira linha for lida pelo
estágio Transformer para ser processada.
Variáveis de estágio não são atualizadas automaticamente quando novas linhas são
lidas. Elas retêm seus valores até que as derivações mudem de valor. Esse é um
recurso-chave das variáveis de estágio. Isso torna possível comparar os valores de
linhas anteriores a valores na linha atual.

Criação de uma derivação

• Clique duas vezes na célula à esquerda da variável de estágio ou
na coluna de saída para abrir o editor de expressão
• Selecione as colunas de entrada, as variáveis de estágio, as
funções e outros elementos necessários na sua derivação
 Não tente digitar manualmente os nomes das colunas de entrada
−É fácil cometer um erro
− As colunas de entrada são prefixadas pelo nome de link
 As funções são divididas em categorias: Date & Time, Number, String,
Type conversion, e assim por diante
− Ao inserir uma função vazia, ela exibe sua sintaxe e tipos de parâmetro
Criação de uma derivação

Como ocorre com restrições, as derivações são construídas usando o editor de
expressão. Clique duas vezes na célula à esquerda da variável de estágio ou na
coluna de saída para abrir o editor de expressão.
Para evitar erros em derivações, geralmente é preferível inserir itens na expressão
usando o menu do editor de expressão, em vez de digitando seus nomes
manualmente.

Definição de uma derivação

Coluna de entrada
Sequência de Operador de
caracteres entre aspas concatenação (:)
(simples ou duplas)
Definição de uma derivação

Esse slide mostra um exemplo de uma derivação sendo definida no editor de
expressão. Use o menu para inserir itens na expressão.
Essa expressão contém constantes de sequência de caracteres. As constantes de
sequência de caracteres devem ficar entre aspas simples ou duplas. Os dois pontos (:)
são o operador de concatenação. Use-o para combinar duas sequências de caracteres
em uma única sequência. Na concatenação acima, é mostrada uma coluna
(Special_Handling_Code). Para essa expressão funcionar, essa coluna deve ser um
tipo de sequência de caracteres: char ou varchar. Não é possível concatenar, por
exemplo, um número inteiro com uma sequência de caracteres (a menos que o
número inteiro seja uma sequência de caracteres numérica, como "32").

Derivação IF THEN ELSE

• Use IF THEN ELSE para derivar um valor de modo condicional
• Formato:
 IF <condition> THEN <expression1> ELSE <expression2>
 Se a condição for avaliada para true, o resultado da expression1 será
gravado
 Se a condição for avaliada para false, o resultado da expression2 será
gravado
• Exemplo:
 suponha que a coluna de origem tenha o nome In.OrderID e a coluna de
destino tenha o nome Out.OrderID
 Para substituir os valores de In.OrderID de 3000 por 4000:
 IF In.OrderID = 3000 THEN 4000 ELSE In.OrderID
Derivação IF THEN ELSE

As derivações IF THEN ELSE são usadas com frequência para expressar regras de
negócios. Usando-as, é possível expressar qual valor condicionalmente irá para uma
coluna de saída ou variável.
Um uso típico é substituir um valor de dados por outro. Isso pode ser usado quando o
nome ou o identificador de um produto ou serviço muda. Observe, no exemplo, como
isso é feito. Não é possível codificar a derivação como IF In.Order ID = 3000.
Uma derivação deve, em cada caso, retornar um valor. Sem uma cláusula ELSE, ela
não retornará um valor quando o antecedente IF for falso. Uma vez que você precisa
ter ELSE, é preciso produzir algum valor como saída. Assim, você produz o valor
inalterado na coluna.

Funções de sequência de caracteres e operadores

• Operador de subsequência
 Formato: "String" [loc, length]
 Exemplo:
− Suponhaque In.Description contenha a sequência de caracteres "Orange Juice"
− InDescription[8,5] = "Juice"
• UpCase(<string>) / DownCase(<string>)
 Exemplo: UpCase(In.Description) = "ORANGE JUICE"
• Len(<string>)
 Exemplo: Len(In.Description) = 12
Funções de sequência de caracteres e operadores

Um tipo comum de função que você pode precisar usar nas suas derivações são
funções de sequência de caracteres. Aqui você vê algumas das muitas funções de
sequência de caracteres que pode usar nas suas derivações.
UpCase e DownCase são funções muito úteis quando é necessário comparar
sequências de caracteres. Por exemplo, suponha que você precise comparar uma
sequência de caracteres em uma coluna com uma sequência de caracteres em um
parâmetro da tarefa. Para garantir que a comparação funcione quando uma sequência
de caracteres estiver em letras maiúsculas e a outra, em maiúsculas e minúsculas, é
possível "padronizar" ambas as sequências de caracteres primeiro aplicando as
funções UpCase ou DownCase a elas.

Manipulação de nulo
• Nulos podem entrar no fluxo de dados:
 Por meio de consultas (falhas de consulta)
 Por meio de dados de origem contendo nulos
• Nulos gravados em colunas de saída não
anuláveis causam a interrupção da tarefa
• Os nulos podem ser manipulados usando as
funções de manipulação de nulo do
Transformer:
 Testar quanto ao nulo na coluna ou variável
− IsNull(<column>)
− IsNotNull(<column>)
 Substituir nulo por um valor

− NullToValue(<column>, <value>)
 Configurar para nulo: SetNull()
− Exemplo: IF In.Col = 5 THEN SetNull() ELSE In.Col
Manipulação de nulo
Este slide mostra as funções de manipulação de nulo padrão disponíveis no editor de
expressão do Transformer.
Os nulos no fluxo de função precisam ser manipulados ou a função pode ser
interrompida ou produzir resultados inesperados. Por exemplo, um valor nulo gravado
em uma coluna não anulável causará a interrupção da tarefa. Esse tipo de erro de
tempo de execução pode ser difícil de capturar, especialmente porque a função pode
ser executada sem problemas por um tempo antes de ser interrompida em decorrência
do nulo.
Ainda, lembre-se de que nulos gravados em um arquivo sequencial serão rejeitados
pelo estágio Sequential File, a menos que sejam manipulados. Embora esses nulos
possam ser manipulados no estágio Sequential File, eles também podem ser
manipulados anteriormente em um Transformer.

Nulos não manipulados

• O que acontece se uma coluna de entrada em uma derivação contiver
nulo, mas não for manipulada, por exemplo, usando NullToValue(in.col)?
 Isso é determinado pela configuração de processamento de nulo anterior
− Se estiver configurada, a linha é eliminada ou rejeitada
• Use um link de rejeição para capturar essas linhas
− Se não estiver configurada, a derivação retornará nulo
• Exemplo: Presuma que in.col seja anulável e que, para esta linha, seja
nulo
 5 + NullToValue(in.col, 0) = 5
 5 + in.col = nulo, se o processamento de nulo anterior não estiver configurado
 5 + in.col = linha é rejeitada ou eliminada se o processamento de nulo anterior
estiver configurado
• Melhor prática
 Quando o processamento de nulo anterior está configurado, crie um link de
rejeição
Nulos não manipulados

A configuração Legacy null processing determina como os nulos são manipulados
no Transformer. Se estiver configurada, a linha será eliminada ou rejeitada, assim
como ocorria em versões anteriores do DataStage. Use um link de rejeição para
capturar essas linhas. Se não estiver configurada, a derivação retornará nulo. Esse
recurso foi incluído no DataStage v8.5.
Observe que está relacionado a como os nulos são manipulados dentro de
expressões, se uma expressão envolvendo nulo retorna nulo ou é rejeitada. Em
qualquer caso, um valor nulo nunca pode ser gravado em uma coluna não anulável.

Processamento de nulo anterior

• Quando configurado, a linha é rejeitada quando ocorre um nulo não
manipulado
 Configurado na guia Stage Properties > General
• Se Abort on unhandled Null estiver configurado além do processamento
de nulo anterior, os nulos não manipulados farão a tarefa ser interrompida
Processamento
de nulo anterior Interromper em
nulo não manipulado
Processamento de nulo anterior

Este slide mostra onde a opção Legacy null processing é configurada, a saber, na
guia General da janela Transformer Stage Properties.
Por padrão, essa opção estará ativada para tarefas paralelas de importação criadas
antes da v8.5. Isso é feito para garantir que essas funções comportem-se como se
comportavam ao serem criadas inicialmente. Por padrão, as tarefas criadas na v8.5 e
posteriores terão essa opção desativada.

Link de rejeição do estágio Transformer

• Capturar nulos não manipulados
• Para criar, trace um link de saída. Clique com o botão direito sobre
o link e selecione Convert to reject
Link de
rejeição
Link de rejeição do estágio Transformer

Este slide mostra um Transformer com um link de rejeição para capturar nulos não
manipulados. Como mencionado anteriormente, se você estiver usando
processamento de nulo anterior, a melhor prática é ter links de rejeição para
Transformers. Caso contrário, quaisquer linhas rejeitadas desaparecerão. É muito
difícil dizer se alguma linha foi rejeitada por um Transformer se não houver linhas de
rejeição para capturá-las.

Demonstração 2
Definir derivações

 Definir uma variável de estágio
 Criar uma derivação de formatação
 Usar funções em derivações
 Criar uma derivação de substituição condicional
 Especificar opções de processamento de nulo
 Capturar rejeições
Demonstração 2: Definir derivações

Demonstração 2:
Definição de derivações
Propósito:
Você deseja definir derivações no estágio Transformer.
NOTA:
Etapas:
exibida.
Tarefa 1. Crie uma derivação de formatação.
1. Abra a tarefa TransSellingGroupOtherwise e salve-a como
TransSellingGroupDerivations.

2. Abra o Transformer.
3. Na barra de ferramentas, clique em Stage Properties e depois clique na

guia Stage > Stage Variables.
4. Crie uma variável de estágio chamada HCDesc. Configure seu valor inicial
para a sequência de caracteres vazia. Seu tipo SQL é VarChar, precisão 255.
5. Feche a janela Transformer Stage Properties. O nome da variável de estágio

aparece na janela Stage Variables.

6. Clique duas vezes na célula à esquerda da variável de estágio HCDesc. Defina

uma derivação que coloque o código de manipulação especial de cada linha
dentro de uma sequência de caracteres da seguinte forma:
"Handling code = [xxx]". Aqui, "xxx" é o valor na coluna Special_Handling_Code.
7. Crie uma nova coluna VarChar(255) chamada Handling_Code_Description

para cada um dos links de saída LowCode e HighCode. É possível criá-los
nas guias correspondentes na parte inferior da janela do Transformer.
8. Arraste o valor da variável de estágio HCDesc para cada uma dessas colunas
de link.

9. Compile e execute. Visualize os dados nos arquivos de saída.
Tarefa 2. Use uma função em uma derivação.

2. Na derivação para a coluna de destino Distribution_Channel_Description no
link de saída LowCode, coloque o texto de saída em letras maiúsculas e corte
quaisquer espaços em branco da sequência de caracteres.

3. Compile, execute e visualize os resultados.
Tarefa 3. Crie uma derivação de substituição condicional.

2. Grave uma derivação para as colunas Selling_Group_Desc de destino nos
links de saída LowCode e HighCode que substitua "SG055" por "SH055",
deixando o restante da descrição como está. Em outras palavras,
"SG055 Live Swine", por exemplo, se torna "SH055 Live Swine".
NOTA: use o operador IF THEN ELSE. Ainda, pode ser necessário usar o
operador de subsequência e as funções Len.
3. Compile, execute e teste sua tarefa. Aqui está parte da saída do estágio
HighCode. Observe especificamente a linha (550000), que mostra a
substituição de SG055 por SH055 na segunda coluna.

Tarefa 4. Capture rejeições.

1. Salve sua tarefa como TransSellingGroupRejects.
2. Inclua outro link de saída a um estágio Peek. Dê ao link o nome Rejects e ao
estágio, Peek_Rejects.
3. Clique com o botão direito sobre o link e clique em Convert to reject.

4. Abra o Transformer e clique no ícone Stage Properties (parte superior

esquerda). Selecione a caixa Legacy null processing (se ainda não tiver sido
selecionada).

Você provavelmente não terá rejeições.
Resultados:
Você definiu derivações no estágio Transformer.

Processamento de loop
• Para cada linha lida, o loop é processado
 Várias linhas de saída podem ser gravadas para cada linha de entrada
• Um loop consiste em:
 Condição de loop: o loop continua a ser iterado enquanto a condição for
verdadeira
− Variável do sistema @ITERATION:
• Mantém uma contagem do número de vezes que o loop iterou, começando em 1
• Redefinida para 1 quando a nova linha é lida
− Limite de aviso de iteração de loop
• Aviso gravado no log quando o limite é atingido
 Variáveis de loop:
− Executadas na ordem, de cima para baixo
− Similares às variáveis de estágio
− Definidas na guia Loop Variables
Com loops, várias linhas de saída podem ser gravadas para cada linha de entrada. Um
loop consiste em uma condição de loop e variáveis de loop, que são similares a
variáveis de estágio. Desde que a condição de saída seja atendida, as derivações da
variável de loop continuarão sendo executados de cima para baixo.
A condição de loop é uma expressão que é avaliada para verdadeiro ou falso (como
uma restrição). É avaliada uma vez depois de a linha ser lida, antes da execução das
derivações da variável de loop. Você deseja garantir que a condição de loop acabe
sendo avaliada para falso. Caso contrário, seu loop continuará em execução para
sempre. O limite de aviso de iteração de loop é projetado para capturar alguns desses
casos. Depois de um determinado número de avisos, sua tarefa será cancelada.

Funções usadas no processamento de loop

• Detecção de quebra de chave
− Quando os seus dados estiverem agrupados e classificados em uma coluna,
você poderá detectar a última linha em um grupo usando a função
LastRowInGroup(In.Col)
• In.Col é a coluna pela qual os dados são agrupados
• Quando várias colunas fizerem parte da chave, escolha a mais interna
• Count(In.col, "sub-string")
 Conta o número de ocorrências de uma subsequência de caracteres em
In.col
 Exemplo: Count("Red|Blue|Green", "|") = 2
• Field(In.col, "|", n)
 Recupera o enésimo subcampo de uma sequência de caracteres, em que
o delimitador de subsequência de caracteres neste exemplo é "|"
− Exemplo: Field("abc|de|fghi", "|", 2) = "de”
Funções usadas no processamento de loop

Aqui estão algumas funções geralmente usadas no processamento de loop. Se os
seus dados estiverem agrupados e classificados em uma coluna, você poderá detectar
a última linha em um grupo usando a função LastRowInGroup(In.Col). É possível
usar a função Count para contar o número de ocorrências de uma subsequência de
caracteres. É possível usar a função Field para recuperar o
enésimo campo em uma sequência de caracteres.

Exemplo de processamento de loop

• Cada linha de origem contém um campo que contém uma lista de
cores de item
 Exemplo: 23,Red|Green|Black
• Para cada linha, separe as cores em linhas separadas
 Exemplo:
− 23,Red
− 23,Green
− 23,Black
Exemplo de processamento de loop

Neste exemplo, cada linha de origem contém um campo que contém uma lista de
cores de item, como mostra o exemplo. É possível usar a função Field para analisar
cores individuais na lista.

Tarefa de exemplo de processamento de loop
Dados de origem
Resultados
Tarefa de exemplo de processamento de loop

Esse slide exibe a tarefa de exemplo de processamento de loop. Ele mostra os dados
de origem e os resultados finais. A linha de dados de origem 16, por exemplo, contém
uma lista de quatro cores. Nos resultados de saída, quatro linhas de item 16 são
gravadas, uma para cada cor.
Para cada linha lida, o loop vai iterar através das cores na lista.

Conta o número
de cores
Itera pela lista de

cores

Esta apresentação de slides mostra o interior do estágio Transformer. A condição de
loop faz referência à variável do sistema @ITERATION, que rastreia a iteração atual
através do loop. A função Field é usada para analisar cores individuais da lista para a
variável de loop Color. A variável de loop Color é mapeada para uma coluna de saída.
Cada iteração então é gravada.
A variável do sistema de @ITERATION é incrementada após cada iteração através do
loop. Por fim, ela atingirá o número contido na variável de estágio NumColors e,
então, a condição de loop se tornará falsa.

Demonstração 3

 Criar uma tarefa que produz como saída várias linhas para cada linha de
entrada
 Usar um loop para iterar em uma lista de cores contidas em uma única
coluna da entrada
Demonstração 3: Processamento de loop

Demonstração 3:
Propósito:
Você deseja criar variáveis e condições de loop. Você também deseja
processar linhas de entrada através de um loop.
NOTA:
Etapas:
2. Selecione a opção Import selected e selecione a tarefa desejada na lista exibida.
Tarefa 1. Transforme.
1. Abra C:\CourseData\DSEss_Files\ColorMappings.txt no WordPad.
Esse é seu arquivo de origem. Cada número de item é seguido por uma lista de
cores.

2. Crie uma nova tarefa paralela chamada TransPivot. Nomeie os links e

estágios como mostrado.
3. Importe a definição de tabela para o arquivo ColorMappings.txt. Armazene-o

na pasta _Training>Metadata.
4. Abra o estágio ColorMappings. Edite o estágio de modo que ele leia do
arquivo ColorMappings.txt. Verifique se consegue visualizar os dados.
5. Abra o estágio Transformer. Arraste a coluna Item para o link de saída

ItemColor.

6. Crie uma nova coluna VarChar(10) chamada Color.
7. Crie uma nova variável de estágio de número inteiro chamada NumColors.

Isso armazenará o número de cores na lista de cores.
8. Em seguida, clique na caixa Derivation ao lado da variável de estágio
NumColors para configurar a variável. Use a função de sequência de
caracteres Count para contar o número de ocorrências da subsequência de
caracteres "|" na coluna de entrada Colors.
Observe que o número de delimitadores "|" na lista de cores é um a menos que
o número de cores.
9. Abra a janela Loop Condition. Clique duas vezes na caixa branca ao lado da
caixa Loop While para abrir o Expression Editor. Especifique uma condição de
loop que itere para cada cor. O número total de iterações é armazenado na
variável de estágio NumColors. Use a variável do sistema @ITERATION.

10. Crie uma nova variável de loop VarChar(10) chamada Color.
11. Para cada iteração, armazene a cor correspondente da lista de cores na

variável de loop Color. Use a função Field para recuperar a cor da lista de
cores.
12. Arraste a variável de loop Color para a célula de derivação ao lado da coluna
do link de saída Color.

13. Edite o estágio de destino para gravar em um arquivo sequencial chamado

ItemColor.txt no diretório Temp dos arquivos de laboratório. Certifique-se de
que o arquivo de destino seja gravado com uma primeira linha de nomes de
coluna.
14. Compile e execute sua tarefa. Você deve ver mais linhas indo para o arquivo
de destino que vindo do arquivo de origem.
15. Visualize os dados no estágio de destino. Você deve ver várias linhas para
cada número de item.
16. Teste se você tem os resultados corretos. Por exemplo, conte o número de
linhas para o item 16.
Resultados:
Você criou variáveis e condições de loop. Você também processou linhas de
entrada através de um loop.

Processamento de grupo
• LastRowInGroup(In.Col) pode ser usada para determinar quando a
última linha em um grupo está sendo processada
 O estágio Transformer deve ser precedido por um estágio Sort que
classifique os dados pelas colunas-chave do grupo
• Variáveis de estágio podem ser usadas para calcular agregações e
resumos de grupo
Processamento de grupo
No processamento de grupo, a função LastRowInGroup(In.Col) pode ser usada para
determinar quando a última linha em um grupo está sendo processada.
Essa função requer que o estágio Transformer seja precedido por um estágio Sort que
classifique os dados pelas colunas-chave do grupo.

Exemplo de processamento de grupo

• Para usar a função LastRowInGroup(In.Col), um estágio Sort é necessário
antes do Transformer
• Aqui, o arquivo ItemColor.txt contém itens vendidos com suas cores
individuais
• Para cada item, você deseja uma lista de todas as cores que ele pode ter
Classificar por
chave de grupo
Exemplo de processamento de grupo

Esse slide mostra a tarefa de exemplo de processamento de grupo. Observe o estágio
Sort anterior ao estágio Transformer. Isso é necessário ao usar a função
LastRowInGroup(). O estágio Sort não precisa preceder imediatamente o
Transformer, mas o compilador DataStage deve poder determinar do fluxo de trabalho
que os dados sejam agrupados da maneira certa.

Resultados da tarefa
Antes Depois
Resultados da tarefa
Esses slides mostram os resultados da tarefa antes e depois. Observe que as cores
individuais para o grupo de registros Item aparecem nos resultados como uma lista de
cores.
Os dados de origem são agrupados por número de item. Os dados também são
classificados por número de item, mas isso não é necessário. A função
LastRowInGroup() é usada para determinar que, por exemplo, a linha 16 da cor
branca seja a última linha no grupo. Neste ponto, os resultados para o grupo podem
ser concluídos e gravados. Neste exemplo, o resultado do grupo consiste em uma lista
de todas as cores no grupo. Porém, este é apenas um exemplo. É possível produzir
qualquer tipo de agregação de grupo de maneira similar.

Lógica do Transformer
LastRowInGroup()
TotalColorList
CurrentColorList
Neste exemplo, a variável de estágio IsLastInGroup é usada como uma sinalização.
Quando é igual a "Y", a última linha está sendo processada no momento. A função
LastRowInGroup() é usada para configurar a sinalização.
O valor para a variável de estágio TotalColorList é construído concatenando a cor
atual para a CurrentColorList. Quando a sinalização IsLastInGroup é configurada, a
CurrentColorList contém toda a lista, exceto a linha atual.
A CurrentColorList é construída conforme cada linha no grupo é processada. Quando
a última linha é processada, mas após a criação de TotalColorList, ela é inicializada
para a sequência de caracteres vazia.

Loop através de linhas de entrada salvas

• A função SaveInputRecord() pode ser usada para salvar uma cópia
da linha de entrada atual em uma fila para recuperação posterior
 Localizada na pasta Utility de funções
 Retorna o número de linhas salvas na fila
 Somente pode ser chamada em uma derivação de variável de estágio
• A função GetSavedInputRecord() pode ser usada para recuperar
linhas na fila
 Localizada na pasta Utility de funções
 Retorna o índice da linha na fila
 Somente pode ser chamada em uma derivação de variável de loop
• Pode usar essas funções para iterar em um conjunto de linhas salvas
incluindo os resultados do grupo em registros de grupo individuais
Loop através de linhas de entrada salvas

O estágio Transformer oferece suporte para loop através das linhas de entrada salvas.
A função SaveInputRecord() pode ser usada para salvar uma cópia da linha de
entrada atual em uma fila para recuperação posterior. A função
GetSavedInputRecord() pode ser usada para recuperar linhas na fila. É possível usar
essas funções para iterar por um conjunto de linhas salvas, incluindo os resultados do
grupo em registros de grupo individuais.

Resultados da tarefa de exemplo
Antes Depois
Resultados da tarefa de exemplo

Esses slides mostram os resultados de antes e depois para a tarefa de exemplo. Aqui,
por exemplo, há dois registros do item 25. Na saída, a lista total de cores dos registros
do item 25 é incluída a cada registro individual. Assim, há duas linhas do item 25, cada
uma contendo as cores do item 25 da lista total.
Isso é similar ao que pode ser feito usando um design de tarefa de bifurcação-junção.

Salvar linha
de entrada
Iterar nas linhas

salvas quando a
última linha do grupo
for processada
Recuperar linha salva
Saída
Esse slide mostra a lógica do Transformer. Depois de salvar os registros em um grupo,
os registros serão recuperados em um loop. Uma linha de saída é gravada para cada
iteração através do loop. Isso consiste em dados da linha recuperada mais a lista de
cores total.

Depurador de tarefa paralela

• Configure pontos de interrupção em links em uma tarefa paralela
• Especifique uma condição sob a qual um ponto de interrupção é ativado
 Cada enésima linha
 Expressão
− As expressões podem incluir colunas de entrada, operadores e constantes de
sequência de caracteres
• Examine os dados nas colunas de link quando o ponto de interrupção
estiver ativado
 Visualizados na janela de depuração
 Os dados podem ser visualizados para cada um dos nós em que o
estágio/operador está em execução
• Opcionalmente, inclua colunas à lista de observação
 Exiba valores para cada nó com pontos de interrupção ativados
Depurador de tarefa paralela

Um ponto de interrupção é um ponto na tarefa em que o processamento é suspenso.
Os pontos de interrupção são configurados nos links. Quando os dados fluem pelo link,
o ponto de interrupção suspende o processamento se a condição do ponto de
interrupção for atendida.
Quando o ponto de interrupção é ativado, as colunas de link de dados são exibidas na
janela Debug.
Em geral, as tarefas estão em execução em várias partições (nós). As colunas de link
de dados são exibidas para cada nó.

Definição de pontos de interrupção

Janela Debug
Configurar ponto
de interrupção
Ícone
Breakpoint
Definição de pontos de interrupção

Para configurar um ponto de interrupção, selecione o link e clique no ícone Toggle
Breakpoint na janela Debug. Para abrir a janela Debug, clique em Debug>Debug
Window.
Use os ícones na barra de ferramentas da janela Debug para configurar e editar
pontos de interrupção, incluir variáveis de observação, executar a tarefa dentro do
depurador e outras operações.
Quando um ponto de interrupção é configurado em um link, um ícone pequeno é
incluído ao link no diagrama, conforme indicado.

Edição de pontos de interrupção

• Selecione o link e, então, clique em Edit Breakpoints
• As expressões podem incluir colunas de entrada, operadores e
colunas de entrada
Condições do
ponto de
interrupção
Edição de pontos de interrupção

A condição do ponto de interrupção é Every N Rows ou uma expressão criada usando
o editor de expressão. As expressões podem incluir colunas de entrada, operadores
(=, <> e assim por diante) e constantes da sequência de caracteres.
A janela Edit Breakpoints exibe todos os pontos de interrupção que são configurados
na tarefa. É possível editar a condição do ponto de interrupção para qualquer ponto de
interrupção selecionado na tarefa.

Execução de uma tarefa paralela no depurador

• Clique no ícone Start/Continue na janela Debug
 Como alternativa, clique em Run to End para executar a tarefa até a conclusão
• A tarefa para no próximo ponto de interrupção ativado
• Os dados nas colunas de link são exibidos
 Uma guia por nó
Ícone
Start/Continue
Guia Node 1
Ponto de Dados das

interrupção colunas de link
ativado
Execução de uma tarefa paralela no depurador

Clique no ícone Start/Continue na barra de ferramentas da janela Debug para abrir a
tarefa para o próximo ponto de interrupção ativado. O ponto de interrupção no link em
que o ponto de interrupção está ativado é enfatizado de maneira gráfica, como se pode
ver no diagrama.
Na janela Debug, aqui estão guias separadas para cada um dos nós em que os
pontos de interrupção estão ativados. Clique na guia para visualizar os dados das
colinas de links naqueles dados.

Inclusão de colunas na lista de observação

• Clique com o botão direito sobre a
coluna a incluir
 Selecione Add to Watch List
• A lista de observação exibe valores
para todos os nós com pontos de
interrupção ativados
Lista de
observação
Inclusão de colunas na lista de observação

É possível incluir colunas a uma lista de observação. Elas normalmente são as colunas
de dados em que você está mais interessado. Os dados para cada um dos nós ativos
é exibido horizontalmente ao lado do nome da coluna.

Demonstração 4
Processamento de grupo em um Transformer

 Usar a função LastRowInGroup() para determinar quando você está
processando a última linha em um grupo
 Usar as variáveis de estágio para acumular os resultados do grupo
 Usar as funções SaveInputRecord() e GetSavedInputRecord() para incluir
resultados de grupo em registros individuais
 Usar o depurador de tarefa paralela para depurar uma tarefa paralela
 Definir pontos de interrupção
 Editar condições do ponto de interrupção
 Incluir variáveis de observação
 Visualizar dados da coluna em pontos de interrupção
Demonstração 4: Processamento de grupo em um Transformer

Demonstração 4:
Processamento de grupo em um Transformer
Propósito:
Você deseja processar grupos de linhas de dados em um Transformer. Mais
adiante, você usará o depurador de tarefa paralela.
NOTA:
Etapas:
exibida.
Tarefa 1. Processe grupos em um Transformer.
1. Crie uma nova tarefa chamada TransGroup. Nomeie os links e estágios como
mostrado.

2. Importe uma definição de tabela para o arquivo ItemColor.txt criado no

laboratório anterior. Lembrete: esse arquivo está localizado no diretório Temp,
e não no diretório DSEss_Files. (Se você não tiver criado esse arquivo
anteriormente, pode usar o arquivo ItemColor_Copy.txt no diretório de
arquivos de laboratório.)
A seguir, uma parte do arquivo é exibida.
3. Edite o estágio Sequential File de origem para ler dados do arquivo

ItemColor.txt.
4. Na guia Format, remova a propriedade Record delimiter na pasta Record
level. Então, inclua a propriedade Record delimiter string e configure seu
valor para DOS format.
Isso acontece porque o arquivo criado no diretório Temp usa o formato
Windows DOS.
5. Certifique-se de poder visualizar os dados.

6. Edite o estágio Sort. Classifique os dados pela coluna Item.
7. Na guia Output > Mapping do estágio Sort, arraste todas as colunas.

8. Na guia Sort Input > Partitioning, faça o hash da partição pela coluna Item.
9. Abra o estágio Transformer. Arraste a coluna Item para o link de saída. Defina
uma nova coluna chamada Colors como VarChar(255).
10. Crie uma variável de estágio Char(1) chamada IsLastInGroup. Inicialize com
'N' (significando "Não").
11. Crie uma variável de estado VarChar(255) chamada TotalColorList. Inicialize-a
com a sequência de caracteres vazia.

12. Crie uma variável de estado VarChar(255) chamada CurrentColorList.

Inicialize-a com a sequência de caracteres vazia.
13. Para a derivação para IsLastInGroup, use a função LastRowInGroup() na

coluna Item para determinar se a linha atual é a última no grupo de itens atual.
Se for, retorne 'Y' (significando "Sim"); caso contrário, retorne 'N'.
14. Para a derivação de TotalColorList, retorne a conjunção da cor atual para

CurrentColorList quando a última linha no grupo estiver sendo processada.
Caso contrário, retorne a sequência de caracteres vazia.
15. Para a derivação de CurrentColorList, retorne a conjunção da cor atual para

CurrentColorList quando a última linha no grupo não estiver sendo
processada. Quando a última linha estiver sendo processada, retorne a
sequência de caracteres vazia.
16. Arraste a variável de estágio TotalColorList para baixo para a célula ao lado
de Colors no link de destino.

17. Em seguida, defina uma restrição para o link de destino. Inclua a restrição
IsLastInGroup = 'Y' para gerar como saída uma linha quando a última linha do
grupo estiver sendo processada.
18. Clique em OK para fechar o Transformer.

19. Edite o estágio Sequential File de destino. Grave em um arquivo chamado

ColorMappings2.txt no diretório Temp nos arquivos de laboratório.

20. Compile e execute sua tarefa. Verifique se há mensagens de erro no log da

tarefa.
Visualize os dados no seu estágio de destino. Para cada conjunto de linhas de

Item no arquivo de entrada, é preciso ter uma única linha no arquivo de destino
seguida por uma lista de cores delimitada por vírgula.
Tarefa 2. Inclua resultados do grupo em registros de grupo

individuais.
1. Salve sua tarefa como TransGroupLoop.
2. Abra o estágio Transformer.

3. Inclua uma nova variável de estágio de número inteiro chamada

NumSavedRows.
4. Para sua derivação, chame a função SaveInputRecord(), localizada na pasta

Utility.
Isso salva uma cópia da linha na fila do estágio Transformer.
5. Defina a condição de loop. Itere nas linhas salvas depois de atingir a última
linha no grupo.
6. Defina uma variável de loop de número inteiro chamada SavedRowIndex.

7. Para sua derivação, chame a função GetSavedInputRecord() na pasta Utility.

Isso recupera uma cópia da linha da fila do estágio Transformer.
8. Arraste a coluna Color do link de entrada para o link de saída de destino.

Coloque a segunda coluna na lista de colunas de saída.
9. Remova a restrição do link de saída clicando com o botão direito na restrição

em ColorMappings2 e abrindo a caixa de diálogo Constraints. Clique duas
vezes na definição de restrição e desmarque-a.
10. Compile e execute. Verifique se há erros no log da tarefa. Visualize os dados

no resultado.

Tarefa 3. Depurador de tarefa paralela do DataStage.

1. Abra a tarefa do TransSellingGroupOtherwise e salve-a como
TransSellingGroupDebug.
NOTA: Se você não tiver uma cópia funcional da tarefa

TransSellingGroupOtherwise, importe a tarefa
TransSellingGroupOtherwise.dsx no diretório dsxfiles dos arquivos de
laboratório.
2. Abra o estágio de origem. Configure o estágio para ler do arquivo
Selling_Group_Mapping_Debug.txt.
3. Em Job Properties, crie um parâmetro da tarefa chamado Channel. Torne-o
uma sequência de caracteres com um valor padrão de "Food Service", com as
aspas.

4. No Transformer, abra a janela Constraints. Inclua às restrições LowCode and

HighCode a condição de que o valor de coluna
Distribution_Channel_Description corresponde ao valor do parâmetro
Channel.
5. Compile a tarefa.
6. No menu do Designer, clique em Debug > Debug Window.
Selecione o link de saída LowCode e clique em Toggle Breakpoint na

janela Debug. Repita para os links HighCode e RangeErrors. Selecione o
ícone de ponto de interrupção incluído aos links no diagrama.
7. Selecione o link RangeErrors e clique em Edit Breakpoints na janela

Debug.

8. Configure a Expression do ponto de interrupção para ser interrompida quando

Distribution_Channel_Description for igual "Food Service".
9. De modo similar, configure as expressões de ponto de interrupção LowCode e

HighCode para serem interrompidas quando
Distribution_Channel_Description não for igual a "Food Service".
10. Clique em Start/Continue na janela Debug.

11. Quando solicitado a informar o valor do parâmetro da tarefa, aceite o padrão de

"Food Service" e clique em OK.
Observe que depurador para no link RangeErrors. Os valores da coluna são

exibidos na janela Debug.
12. Clique nas guias Node 1 e Node 2 para visualizar ambos os valores de dados
para ambos os nós. Observe que cada um parece ter o valor correto na coluna
Distribution_Channel_Description. E o Special_Handling_Code não está
fora do intervalo. Então por que esses valores estão saindo do link otherwise,
em vez de percorrerem o link Lowcode?

13. Na janela Debug, clique com o botão direito na coluna

Distribution_Channel_Description e depois clique em Add to Watch List.
Dessa forma, é possível destacar os valores para a coluna em ambos os nós.
14. Na janela Debug, clique em Run to End para ver para onde as outras
linhas vão.
A tarefa é concluída e todas as linhas percorrem o link otherwise. Mas por quê?
Isso não deve acontecer.
Nota: para ver rapidamente quantos itens são gravados em cada arquivo
sequencial, clique com o botão direito em qualquer lugar da tela e garanta que
haja uma marca de seleção ao lado de Show performance statistics.

15. Na janela Debug, clique no ícone Start/Continue Debugging para reiniciar a

tarefa. Desta vez, remova as aspas de "Food Service" quando solicitado a
informar o valor de parâmetro da tarefa.
16. A situação definitivamente parece melhor desta vez. Mais linhas passaram pelo
link LowCode e o ponto de interrupção para o link LowCode não foi ativado. O
ponto de interrupção para o link otherwise foi ativado. Uma vez que o valor do
Special_Handling_Code está fora do intervalo, é assim que deve ser.
17. Na janela Debug, clique em Run to End para continuar a tarefa.

Desta vez, a tarefa é concluída.

18. Visualize os dados no arquivo LowCode para verificar se eles contêm apenas
linhas "Food Service".
19. Visualize os dados no arquivo RangeErrors para verificar se ele não contém
nenhuma linha "Food Service" que não esteja fora do intervalo.
Parece haver várias linhas "Food Service" que deveriam ter saído do link
LowCodes.
20. Veja se você consegue corrigir os erros restantes na tarefa.

Sugestão: tente recodificar as restrições no Transformer.
Resultados:
Você processou grupos de linhas de dados em um Transformer. Depois, usou
o depurador de tarefa paralela para examinar os dados.

1. O que ocorre primeiro? Derivações ou restrições?
2. As variáveis de estágio podem ser referidas em restrições?
3. Que função se pode usar em um Transformer para determinar
quando você está processando a última linha em um grupo? Que
estágio adicional é necessário para usar essa função?
4. Que função se pode usar em um Transformer para salvar cópias de
linhas de entrada?
5. Que função se pode usar em um Transformer para recuperar linhas
salvas?


1. Restrições.
2. Sim.
3. Função LastRowInGroup(In.Col).
O estágio Transformer deve ser precedido por um estágio Sort que
classifique pelas colunas-chave do grupo.
4. SaveInputRecord().
5. GetSavedInputRecord().

Resumo da unidade
• Usar o estágio Transformer em tarefas paralelas
• Usar variáveis de estágio
• Criar um conjunto de parâmetros e usar seus parâmetros em
restrições e derivações
Resumo da unidade


Unidade 11 Funções de repositório
Funções de repositório


• Executar uma busca simples
• Executar uma busca avançada
• Executar uma análise de impacto
• Comparar as diferenças entre duas definições de tabela
• Comparar as diferenças entre duas tarefas
Funções de repositório © Copyright IBM Corporation 2015

Busca rápida
Nome com caractere

curinga (*)
Inclusão de
correspondências
nas descrições de
Execução
objeto
da busca
Busca rápida
Este slide mostra um exemplo de uma busca rápida. Ela procura objetos que
correspondem ao nome na caixa Name to find. O asterisco (*) é um caractere curinga
que representa zero ou mais caracteres.
Busca rápida destaca o primeiro objeto que corresponde na janela Repository. É
possível clicar em Find repetidamente para alternar entre mais objetos
correspondentes.
Se a caixa Include descriptions estiver marcada, o texto nas descrições Short
descriptions e Long será procurado junto com os nomes dos objetos.

Resultados localizados
Clique para
Clique em Next para
abrir a janela
destacar o item
Advanced Find
seguinte
Item
localizado
Resultados localizados
Esse slide mostra os resultados de Quick Find. O primeiro item localizado é
destacado. Clique em Next para ir para o próximo item localizado.
É possível mover para a janela Advanced Find clicando no botão Adv.... A janela
Advanced Find lista todos os resultados localizados em uma lista.

Janela Advanced Find
Itens
localizados
Opções de procura
Janela Advanced Find

A janela Advanced Find lista todos os resultados em uma única janela, como mostra
esse slide.
Também é possível iniciar procuras nesta janela. A janela Advanced Find dá suporte
a mais opções de procura que Quick Find. Essas opções são listadas e descritas na
próxima página.

Opções Advanced Find

• Type: tipo de objeto
 Selecione a lista de tipos de objetos a procurar: Definições de tabela, estágios
etc.
• Creation:
 Selecione por um intervalo de datas e/ou usuários que criaram o objeto
− Por exemplo, até uma semana atrás
• Last modification:
 Selecione por um intervalo de datas da última modificação
• Where used: objetos que usam os objetos procurados
 Por exemplo, uma tarefa que usa uma definição de tabela especificada
• Dependencies of: objetos que são dependências de objetos
 Por exemplo, uma definição de tabela que é referida em uma tarefa
especificada
• Options
 Distinção entre maiúsculas e minúsculas
 Procurar dentro do último conjunto de resultados
Opções Advanced Find

Isso lista e descreve as opções Advanced Find. Como acontece com Quick Find, é
possível selecionar os tipos de objetos que você deseja procurar. Além disso, é
possível especificar várias opções sobre como o objeto foi criado: Quando ele foi
criado? Por quem? E assim por diante.
As opções Where used e Dependencies of criam relatórios de análise de impacto,
que são discutidos mais adiante nesta unidade.

Uso dos resultados localizados
Comparação
de objetos
Criação de
análise de
impacto
Exportação
para um
arquivo
Uso dos resultados localizados

Depois de ter capturado um conjunto de resultados, é possível usar o conjunto de
resultados localizados de várias maneiras. Por exemplo, é possível comparar os
objetos, exportá-los para um arquivo ou criar análises de impacto. Para iniciá-los,
selecione os objetos e, então, clique com o botão direito do mouse. Selecione a
operação no menu exibido.

Realização de uma análise de impacto

• Localize onde um objeto é usado
 Localize as tarefas ou os estágios em que uma definição de tabela é usada
 Localize as sequências de tarefas em que uma tarefa está
 Localize as tarefas, as definições de tabela, os estágios em que as colunas
são usadas
• Localize dependências do objeto
 Localize os estágios de que uma tarefa depende
• Clique com o botão direito sobre um objeto para abrir o menu
• A dependência pode ser exibida de maneira textual ou gráfica
Realização de uma análise de impacto

Uma análise de impacto tem como objetivo determinar o impacto de fazer uma
mudança em um objeto (definição de tabela, tarefa). Quais outros objetos serão
afetados se a mudança for feita? Um dos usos mais comuns disso é quando um
arquivo ou tabela do qual uma tarefa lê ou grava deve ser mudado. Talvez uma coluna
tenha sido incluída ou removida. A definição de tabela que descreve essa tabela ou
arquivo também mudou. Isso afeta qualquer tarefa que use definição de tabela. A
análise de impacto fornecerá uma lista de todas as tarefas que precisam ser
modificadas e testadas novamente.
É possível executar uma análise de impacto das duas direções. É possível descobrir
onde um objeto é usado, que exibe os objetos que dependem de um objeto
selecionado. Ou você pode procurar dependências de objeto.
Um gráfico de dependência dos resultados pode ser exibido textual ou graficamente.

Início de uma análise de impacto
Localização de tarefas
em que uma definição
de tabela é usada
Início de uma análise de impacto

É fácil iniciar uma análise de impacto. Selecione o objeto e depois clique com o botão
direito do mouse. Se estiver procurando outros objetos que dependem da tarefa
selecionada, clique em Find where used. Se estiver procurando objetos dos quais o
objeto selecionado depende, clique em Find dependencies. Então, é possível
selecionar os tipos de objetos em que você está interessado.
Há duas versões de cada um desses comandos. A versão deep difere apenas no
intervalo de tipos diferentes de objetos entre os quais você pode selecionar.

Resultados no formato de texto
Resultados
Guia Results
Resultados no formato de texto

Há dois formatos em que o gráfico de dependência pode ser apresentado. Esse slide
mostra os resultados detalhados de uma análise de impacto exibida em formato de
texto.

Resultados no formato gráfico
Resultados
Tarefas que
dependem
da definição
Visualização
de tabela
“Birds Eye”
Guia Graphical
Results
Resultados no formato gráfico

Esse slide mostra os resultados gráficos de uma análise de impacto.
Clique na guia Results - Graphical na parte inferior da janela para exibir esse formato.
Os resultados mostram que há duas tarefas (à esquerda) que dependem da definição
de tabela à direita.
A janela Bird’s Eye View aparece no canto inferior direito. Ela exibe como o diagrama
se encaixa na tela. Isso revelará se há alguma parte do diagrama que se estenda para
fora da área de visualização.
Na parte superior da janela há controles para aumentar e reduzir o zoom.

Exibição do gráfico de dependência

• Exibe em detalhes como um objeto (por exemplo, uma tarefa)
depende de outro objeto (uma definição de tabela)
• Selecione a dependência na lista Results (textual ou gráfica) e
clique em Show dependency path to '...'
Mostrar gráfico de
dependência
Exibição do gráfico de dependência

Esse slide mostra como exibir um gráfico de dependência para uma definição de
tabela. Um gráfico de dependência exibe em detalhes como um objeto (por exemplo,
uma tarefa) depende de outro objeto (por exemplo, uma definição de tabela).

Exibição do caminho de dependência
Definição
de tabela
Tarefa contendo
(dependente de)
Exibição do caminho de dependência

Esse slide mostra o gráfico de dependência. À esquerda está a tarefa. Bem à direita
está a definição de tabela. Esse gráfico responde a pergunta "Como esta tarefa
depende desta definição de tabela?" A resposta é a seguinte. A tarefa contém um
estágio, que contém um link de saída, que contém colunas que estão na definição de
tabela.

Geração de um relatório HTML

• Where used:
 \_Training\Metadata\Range_Description.txt
− Sem distinção entre maiúsculas e minúsculas: sim
− Localizar no último conjunto de resultados: não
− Correspondência de nome e descrição: nome ou descrição pode corresponder
Descrições do
caminho de
dependência
Nome Amostra de caminho de Caminho da Tipo

dependência pasta
• LookupWarehouseItemRangeRef->
Range_Description->
LookupWarehouseItemRangeRef \Training\Jobs Parallel Job
Range_Description-> EndItem->
EndItem->Range_Descriptions.txt
• LookupWarehouseItemRangeStream->
Range_Description->
LookupWarehouseItemRangeStream \Training\Jobs Parallel Job
Range_Description-> EndItem->
EndItem->Range_Descriptions.txt
Geração de um relatório HTML

Visualização do fluxo de dados no nível da coluna

• Exibição de como os dados fluirão na tarefa
 Como os dados fluirão para uma coluna selecionada
 Como os dados fluirão de uma coluna selecionada
• A análise é baseada em mapeamentos da coluna no tempo de design
 O Ambiente de trabalho de Metadados do Information Server pode
fornecer relatórios com base em análises do tempo de execução
• O fluxo é exibido graficamente no diagrama por meio de destaque
• Também é possível rastrear o fluxo de dados de coluna das
definições de tabela do Repository
 Selecione a definição de tabela no Repository
 Clique com o botão direito em Find where column used
 Selecione as colunas a rastrear
Visualização do fluxo de dados no nível da coluna

O fluxo de dados no nível da coluna mostra como as colunas de entrada são
mapeadas para colunas de saída na tarefa. É possível rastrear como os dados em
uma coluna em particular se moverão pela tarefa.
Para criar uma análise de fluxo de dados no nível da coluna, abra uma tarefa.
Então, selecione um estágio. Clique com o botão direito em
Show where data flows to / originates. Selecione um link fluindo para dentro ou para
fora do estágio ou da definição de tabela do estágio. Então, selecione uma ou mais
colunas no link. Também é possível clicar com o botão direito fora de qualquer estágio
e selecionar Configure data flow view.
É possível rastrear para adiante de uma coluna ou retrocedendo de uma coluna. A
última opção responde a pergunta "De onde vieram os dados nesta coluna?" A
primeira opção responde a pergunta "Para onde os dados nesta coluna estão indo?".

Localização da origem de uma coluna
Selecione e
depois clique em
Show where data
originates from
Selecione
as
colunas
Localização da origem de uma coluna

Esse slide mostra um exemplo de tarefa. Uma coluna no estágio Data Set de destino
foi selecionada. Você quer saber de onde vêm os dados nesta coluna.
Descobrir para onde os dados fluem envolve um processo similar. Selecione um
estágio com um link de saída. Clique em Show where data flows to. Selecione as
colunas que deseja rastrear.

Resultados exibidos
Resultados exibidos
Esse slide mostra a tarefa depois da geração do gráfico. O caminho do estágio
Sequential File Items para o estágio Data Set de destino é destacado em amarelo.

Descoberta da diferença entre duas tarefas

• Exemplo: Job1 é salva como Job2. Alterações são feitas a Job2.
Quais alterações foram feitas?
 Job1 pode ser uma tarefa de produção.
 Job2 é uma cópia da tarefa de produção após aprimoramentos ou outras
alterações terem sido feitas a ela.
Descoberta da diferença entre duas tarefas

Às vezes é muito útil determinar as diferenças entre duas tarefas.
Aqui, por exemplo, Job1 pode ser uma tarefa de produção. Job2 é uma cópia da tarefa
de produção após aprimoramentos ou outras mudanças terem sido feitas a ela. Agora
você deseja comparar a versão aprimorada da tarefa com a versão anterior.

Início da comparação
Tarefa com
as mudanças
Início da comparação
Esse slide mostra como iniciar uma comparação entre duas tarefas. Selecione uma
das tarefas. Clique com o botão direito do mouse e depois clique em Compare
against...

Resultados da comparação
Clique no item
sublinhado para abrir
o editor de estágio
Clique no estágio e
nas referências do
link para destacar as
tarefas abertas
Resultados da comparação
Esse slide mostra os resultados da comparação e destaca determinados recursos no
relatório. Neste exemplo em particular, o relatório lista as mudanças ao nome da tarefa,
aos valores de propriedade dentro de estágios e às definições de coluna.
Observe que alguns itens estão sublinhados. É possível clicar neles para abrir o item
em um editor de estágio.

Salvamento em um arquivo HTML
Clique quando a
janela Comparison
Results estiver ativa
Salvamento em um arquivo HTML

Os resultados da comparação podem ser salvos em um arquivo HTML. Esse slide
mostra como iniciar essa operação. Clique em File > Save As com a janela
Comparison Results aberta.

Comparação de definições de tabela

• Mesmo procedimento que para comparar tarefas
Comparação de definições de tabela

Também é possível comparar definições de tabela. Esse slide mostra os resultados de
comparar duas definições de tabela de exemplo.

1. É possível comparar as diferenças entre quais dois tipos de objetos?
2. Quais caracteres "curinga" podem ser usados em uma busca?
3. Você tem uma tarefa cujo nome começa com "abc". Você não
consegue se lembrar do restante do nome ou de onde a tarefa está
localizada. Qual seria a maneira mais rápida de exportar a tarefa
para um arquivo?
4. Cite três filtros que você pode usar em Advanced Find.
Escreva suas respostas aqui:


1. Tarefas. Definições de tabela.
2. Asterisco (*). Representa qualquer zero ou mais caracteres.
3. Faça uma busca por objetos correspondendo a "abc*". Filtre por
tipo de tarefa. Localize a tarefa no conjunto de resultados, clique
com o botão direito do mouse sobre ele e clique em Export.
4. Tipo de objeto, intervalo de datas de criação, intervalos da última
data de modificação, onde usado, dependências de, outras opções
incluindo distinção entre maiúsculas e minúsculas e procura dentro
do último conjunto de resultados.

Demonstração 1

 Executar uma busca rápida
 Executar uma busca avançada
 Gerar um relatório
 Executar uma análise de impacto
 Localizar as diferenças entre tarefas
 Localizar as diferenças entre definições de tabela
Demonstração 1: Funções de repositório

Demonstração 1:
Propósito:
Você deseja usar as funções de repositório para localizar objetos do
DataStage, gerar um relatório e executar uma análise de impacto. Por fim,
deseja localizar as diferenças entre duas tarefas e entre duas definições de
tabela.
NOTA:
que iniciam com tarefas que você foi instruído a criar em atividades anteriores.
Se você não tiver conseguido concluir a tarefa anterior, pode importá-la do
arquivo DSEssLabSolutions_v11_5_1.dsx no diretório de arquivos
Etapas:
exibida.
Tarefa 1. Execute uma busca rápida.
1. No painel esquerdo, na janela Repository, clique em Open quick find na
parte superior.
2. Na caixa Name to find, digite Lookup*.

3. Na lista Types to find, clique em Unselect all e depois, em Jobs, selecione
Parallel Jobs.
4. Selecione a caixa Include descriptions.

5. Clique em Find. O primeiro item localizado será destacado.

Nota: os resultados podem diferir um pouco das capturas de tela mostradas
nesta unidade, uma vez que dependem do que cada pessoa fez no próprio
sistema.
6. Clique em Next para destacar o item seguinte.

Tarefa 2. Execute uma busca avançada.
1. Clique no botão Adv. Isso abre a janela Repository Advanced Find.
2. No campo Name to find, escolha Lookup* no menu suspenso. Se Lookup*
não estiver disponível, digite essa sequência no campo.
3. Na caixa Type, assegure que Parallel Jobs e Table Definitions estejam
selecionados.
4. No painel Last modification, especifique os objetos modificados na última
semana pelo seu ID do usuário, student.
5. No painel Where used, selecione DSProject\_Training\Metadata\
Definição de tabela Range_Descriptions.txt.
Isso reduz a lista de itens localizados àqueles que usam essa definição de
tabela.

6. Clique em Find.
7. Selecione os itens localizados, clique com o botão direito neles e clique em

Export.
8. Exporte essas tarefas para um arquivo chamado LookupJobs.dsx na pasta
Temp de arquivos de laboratório.
9. Feche a janela Repository Export.
10. Clique na guia Results – Graphical.
Em seguida, você deseja explorar algumas das ferramentas gráficas.

11. Expanda o gráfico e mova-o mantendo o botão direito do mouse pressionado

sobre o gráfico e arrastando-o. Arraste o gráfico movendo o ícone na janela
Bird's Eye View. Explore.
Tarefa 3. Gere um relatório.
1. Clique em File > Generate report para abrir uma janela da qual gerar um
relatório descrevendo os resultados da busca avançada.
2. Clique em OK para gerar o relatório e depois clique no link superior para
visualizá-lo.
Esse relatório é salvo no Repository, no qual você pode visualizá-lo efetuando
login no Reporting Console.
3. Percorra o relatório para visualizar seu conteúdo.

Tarefa 4. Execute uma análise de impacto.

1. Na janela gráfica de resultados, clique com o botão direito em
LookupWarehouseItemRangeRef. Clique em Show dependency path to
'Range_Descriptions.txt'.
2. Se necessário, use o controle Zoom para ajustar o tamanho do caminho de

dependência de modo que ele caiba na janela.
3. Mantenha o botão direito do mouse pressionado sobre um objeto gráfico e

mova o caminho.
4. Feche a janela Advanced Search.

Tarefa 5. Localize as diferenças entre duas tarefas.

1. Abra a tarefa LookupWarehouseItemRangeRef e salve-a como
LookupWarehouseItemRangeRefComp na sua pasta _Training > Jobs.
2. Faça as seguintes mudanças na tarefa
LookupWarehouseItemRangeRefComp:
 Abra o estágio de arquivo sequencial Range_Description e, na guia
Columns, mude o comprimento da primeira coluna (StartItem) para 111.
Na guia Properties, mude First Line is Column Names para False.
 Mude o nome do link que vai para o estágio Sequential File de destino
Warehouse_Items para WAREHOUSE_ITEMS.
 Abra o estágio Lookup. Na janela de restrições, mude a condição
Lookup Failure para Drop.
3. Salve as mudanças na sua tarefa.
4. Abra as tarefas LookupWarehouseItemRangeRef e
LookupWarehouseItemRangeRefComp. Clique em Tile no menu de janelas
para exibir ambas as tarefas no modo de quadrado.

5. Na janela Repository, clique com o botão direito na tarefa

LookupWarehouseItemRangeRefComp e selecione Compare Against.
6. Na janela Compare, clique na tarefa LookupWarehouseItemRangeRef e
depois clique em OK.
A janela Comparison Results aparece como mostrado.
7. Clique em um estágio ou link no relatório, por exemplo, Range_Description.

Observe que o estágio é destacado em ambas as tarefas.
8. Clique em uma das palavras sublinhadas.
Observe que o editor é aberto para o item de referência.
9. Com a janela Comparison Results selecionada, clique em File > Save as e
salve o relatório como um arquivo html na pasta DSEss_Files\Temp.
10. Abra o arquivo html em um navegador para ver como ele é.

Tarefa 6. Localize as diferenças entre duas definições de

tabela.
1. No painel Repository no lado esquerdo, na pasta _Training\Metadata, clique
com o botão direito na definição de tabela Warehouse.txt e depois clique em
Create copy para criar CopyOfWarehouse.txt.
2. Abra CopyOfWarehouse.txt e, na guia General, atualize o campo Short

description para refletir seu nome.
3. Na guia Columns, mude o nome da coluna Item para ITEM_ZZZ e mude seu
tipo e comprimento para Char(33).
4. Clique em OK e clique em Yes se solicitado.
5. Clique com o botão direito sobre sua cópia da definição de tabela e depois
selecione Compare Against.
6. Na janela Comparison, selecione sua tabela Warehouse.txt original.
7. Clique em OK para exibir a janela Comparison Results.
Resultados:
Você usou as funções de repositório para localizar objetos do DataStage,
gerar um relatório e executar uma análise de impacto. Por fim, localizou as
diferenças entre duas tarefas e entre duas definições de tabela.

Resumo da unidade
• Executar uma busca simples
• Executar uma busca avançada
• Executar uma análise de impacto
• Comparar as diferenças entre duas definições de tabela
• Comparar as diferenças entre duas tarefas
Resumo da unidade


Unidade 12 Trabalho com dados relacionais
Trabalho com
dados relacionais


• Importar as definições de tabela para tabelas relacionais
• Criar conexões de dados
• Usar os estágios ODBC e DB2 Connector em uma tarefa
• Usar o SQL Builder para definir instruções SQL SELECT e INSERT
• Usar vários links de entrada em estágios Connector para atualizar
diversas tabelas dentro de uma única transação
• Criar links de rejeição de estágios do conector para capturar linhas
com erros de SQL
Trabalho com dados relacionais © Copyright IBM Corporation 2015

Importação de definições de tabela relacional

• Pode importar usando ODBC ou usando definições de esquema
Orchestrate
 Com as definições de esquema Orchestrate, pode importar apenas uma
tabela por vez
 Com ODBC, é possível importar várias tabelas por vez
− Requer conexão de origem de dados ODBC
• Import > Table Definitions > Orchestrate Schema Definitions
• Import > Table Definitions > ODBC Table Definitions
Importação de definições de tabela relacional

Há dois métodos principais para importar tabelas relacionais: o utilitário orchdbutil,
importações do ODBC.
O utilitário orchdbutil está limitado à importação de uma tabela por vez. Porém, esse
utilitário também está disponível como um utilitário de linha de comando que cujo script
pode ser definido para importar um grande número de definições de tabela.
Dentro do Designer, o ODBC oferece uma maneira simples de importar definições de
tabela.

Importação do esquema Orchestrate
Importação da tabela
de banco de dados
Nome da tabela
Seleção do Tipo Nome do banco

DBMS de dados
Importação do esquema Orchestrate

Esse slide mostra a janela Import Orchestrate Schema. Ele destaca as propriedades
a configurar para a importação de uma definição de tabela. Como seria de esperar, é
preciso fornecer informações, incluindo o nome da tabela, o tipo de banco de dados, o
nome do banco de dados e um ID de usuário e senha autorizados a acessar a tabela
de banco de dados.
Dependendo de como o DataStage é configurado, também pode ser necessário
especificar o servidor de banco de dados.

Importação do ODBC
Seleção do nome de Começar a
origem de dados ODBC importação
Selecione tabelas
a importar
Pasta do Repository de
Importação do ODBC
Esse slide mostra a janela ODBC Import Metadata. A origem de dados ODBC que
acessa o banco de dados contendo as tabelas a serem importadas foi definida
anteriormente.
Selecione uma ou mais tabelas a importar. Na caixa To folder, selecione a pasta
Repository na qual armazenar as definições de tabela importadas.

Estágios Connector
• Os tipos do Connector incluem:
 ODBC
 DB2
 Oracle
 Teradata
• Todos os estágios Connector têm exatamente a mesma aparência e o
mesmo conjunto central de propriedades
 Alguns tipos incluem propriedades específicas do tipo de banco de dados
• As propriedades da tarefa podem ser inseridas em qualquer
propriedade
• As propriedades requeridas são identificadas visualmente
• Suporte paralelo para leitura e gravação
 Leitura: conexões paralelas ao servidor e consultas SQL modificadas para
cada conexão
 Gravação: conexões paralelas ao servidor
Estágios Connector
Existem estágios Connector para todos os principais tipos de banco de dados, e tipos
adicionais são incluídos continuamente. Todos os tipos de Connector têm exatamente
a mesma aparência e o mesmo conjunto central de propriedades.
Existem outros estágios para acessar dados relacionais (por exemplo, estágios
Enterprise), mas, na maioria dos casos, os estágios Connector oferecem a máxima
funcionalidade e o melhor desempenho.
Os estágios Connector oferecem suporte paralelo para leitura e gravação em tabelas
de banco de dados. Isso é verdadeiro, não importa se o sistema de banco de dados
em si implementa paralelismo.

Leitura de tabelas do banco de dados
ODBC Connector
para leitura
Leitura de tabelas do banco de dados

Esse slide mostra uma tarefa paralela que lê de uma tabela de banco de dados usando
o estágio ODBC Connector. O conector ODBC pode ler de qualquer origem de dados
que tenha uma origem de dados ODBC definida.

GUI do estágio Connector
Propriedades Colunas
Testar
conexão
Visualizar
dados
GUI do estágio Connector

Esse slide mostra o interior do estágio ODBC Connector e destaca alguns dos seus
recursos. Aqui é mostrado o ODBC Connector, mas outros estágios Connector têm a
mesma aparência.
Na parte superior esquerda, está a caixa de nome do link. Use-a para selecionar um
link e exibir suas propriedades. Isso é útil quando há vários links de entrada e/ou saída.
Assim como ocorre com os outros estágios, os estágios Connector têm uma guia
Columns em que as definições da tabela podem ser importadas.

Painel Navigation
• Guia Stage
 Exibe o subconjunto de propriedades em comum a todos os usos do
estágio, não importa seus links de entrada e saída
 Por exemplo, propriedades de conexão do banco de dados
• Guia Output / Input
 Exibe propriedades relacionadas ao link de saída ou entrada
 Por exemplo, o nome da tabela da qual o link de saída está lendo
ou na qual o link de entrada está gravando
Painel Navigation
Use o painel Navigation para destacar um link ou estágio no painel para exibir as
propriedades associadas a ele.

Propriedades da conexão
• Propriedades da conexão ODBC
 Nome da origem de dados ou nome do banco de dados
 Nome de usuário e senha
 Requer uma origem de dados ODBC definida no DataStage Server
• Propriedades da conexão DB2
 Instância
− Não é necessário se um padrão for especificado nas variáveis de ambiente
 Banco de dados
 Arquivo de biblioteca do cliente DB2
• Use Test para testar a conexão
• Pode carregar as propriedades da conexão de um objeto de
conexão de dados (discutido mais adiante)
O conjunto específico de propriedades da conexão depende do tipo de estágio. Todos
exigem uma origem de dados ou um nome de banco de dados e nome de usuário e
senha. Alguns tipos de estágios Connector incluirão propriedades de conexão
adicionais. O estágio Connector do DB2 tem propriedades para especificar o nome da
instância do DB2, se não for possível determiná-la pelas configurações da variável de
ambiente, e para especificar o local do arquivo de biblioteca do cliente do DB2, se não
for possível determiná-lo pelas configurações da variável de ambiente.
Quando você tiver especificado as propriedades da conexão, clique em Test para
verificar a conexão.

Propriedades de uso – Generate SQL

• Fazer com que o estágio gere o SQL?
 Se Yes, o estágio gera SQL com base nas definições de coluna e no nome
de tabela especificado
− Nome da tabela
• Se o nome do esquema não for especificado, ele assumirá o ID de usuário
do DataStage
• Por exemplo: ITEMS torna-se STUDENT.ITEMS
 Se No, é preciso especificar o SQL
• Cole-o
• Digite-o manualmente
• Chame o SQL Builder
Propriedades de uso – Generate SQL

A pasta de propriedades Usage contém a propriedade Generate SQL. Use essa
propriedade para especificar se você deseja que o estágio gere o SQL com base nas
suas outras configurações de propriedade e na coluna de definição de tabela
importada ou se irá construir ou fornecer o SQL.
Se você escolher construir o SQL, pode criá-lo fora do estágio e colá-lo manualmente,
digitá-lo no estágio ou fazer o utilitário SQL Builder construir o SQL. O utilitário SQL
Builder é chamado de dentro do estágio Connector.

Propriedades de uso – transação

• Define a Unidade de trabalho quando ocorre um COMMIT
• Contagem de registros
 Número de registros a processar antes da confirmação da transação atual
• Tamanho da matriz
 Número de linhas a transferir em cada operação de leitura ou gravação
 A contagem de registros deve ser um múltiplo de Array Size
• Fim da onda
 Um marcador inserido nos dados para indicar o fim de uma unidade de
trabalho
 A unidade de transação é confirmada quando o fim do marcador de onda
tiver passado pela tarefa
− Os dados são gravados em conjunto de dados de saída ou tabelas de banco de
dados como um lote de linhas (contagem de registros) quando o fim da onda
marcada é atingido
Propriedades de uso – transação

A pasta de propriedades Usage no estágio Connector contém um conjunto de
propriedades da transação. Uma transação define a unidade de trabalho. Ou seja,
especifica o número de linhas escritas pelo estágio antes de os dados serem
confirmados na tabela. Um valor de 0 na propriedade Record count direciona o
estágio para gravar todas as linhas antes da confirmação.
O Array Size determina o número de linhas transferidas em cada operação de leitura
ou gravação. Quanto maior for o tamanho da matriz, menos gravações físicas haverá
e, portanto, melhor o desempenho.

Propriedades de uso – Session e Before / After SQL

• Session
 Nível de isolamento:
− Leitura não confirmada: linhas que são lidas durante uma transação podem ser
alteradas por outros processos
− Leitura confirmada: linhas que são lidas durante uma transação podem ser
alteradas por outros processos, mas não podem ser lidas até que a transação
seja concluída
− Leitura repetida: não é possível alterar as linhas por outros processos até que
a transação seja concluída
− Serializável:
não é possível ler ou alterar as linhas por outros processos até
que a transação seja concluída
• Before / After SQL
 A instrução SQL a ser processada antes ou depois de os dados serem
processados pelo estágio Connector
 Por exemplo, use para criar ou eliminar índices secundários
Propriedades de uso – Session e Before / After SQL

A pasta Usage também contém uma pasta de propriedades de Session. Aqui, é
possível especificar um nível de isolamento.
Os estágios Connector dão suporte a Before / After SQL. Essas são instruções SQL
que devem ser executadas seja antes de o estágio começar a processar os dados ou
depois de o estágio processar os dados.

Gravação em tabelas de banco de dados
DB2 Connector para

gravação
Gravação em tabelas de banco de dados

Esse slide mostra uma tarefa que grava em uma tabela DB2 usando o estágio
Connector do DB2. Os estágios Connector dão suporte a vários links de entrada e links
de rejeição. Isso é discutido mais adiante nesta unidade.

GUI do DB2 Connector
Modo de gravação
SQL gerado
Ação da tabela
GUI do DB2 Connector

Esse slide mostra a parte interna do estágio DB2 Connector e destaca algumas das
suas propriedades principais. Observe que o estágio DB2 Connector tem a mesma
aparência básica que o estágio ODBC Connector. A única diferença é que ele tem
apenas algumas propriedades adicionais.

Propriedades de gravação do Connector

• O modo de gravação inclui:
 Inserir
 Atualizar
 Inserir depois atualizar
− Se a inserção falhar, tente atualizar
 Atualizar depois inserir
− Se a atualização falhar, tente inserir
 Carregamento em massa
− Chame o utilitário de carregamento em massa DB2
• Ação da tabela
 Anexar: anexe dados a uma tabela existente
 Truncar: exclua dados existentes antes de gravar
 Criar: crie a tabela
 Substituir: crie uma tabela ou substitua uma tabela existente
Propriedades de gravação do Connector

Estágios Connector usados para gravações de tabela têm uma propriedade
Write mode. Use essa propriedade para especificar o tipo de operação de gravação.
O estágio tem suporte para inserções e atualizações. Também oferece suporte a
inserções e atualizações combinadas. Escolha Insert then update se a sua tarefa for
realizar mais inserções do que atualizações. Escolha Update then insert se a sua
tarefa for realizar mais atualizações do que inserções. Os resultados são os mesmos
em qualquer caso. O que você escolhe é uma questão de desempenho.
Se o tipo de banco de dados, como DB2, tiver suporte para carregamento em massa,
você pode fazer o estágio Connector chamar esse utilitário.
Use a propriedade Table action para especificar se as linhas gravadas devem ser
incluídas às linhas existentes na tabela (Append) ou se substituem as linhas
existentes (Truncate). Também é possível direcionar o estágio Connector para criar ou
recriar a tabela antes de gravar as linhas.

Objetos de conexão de dados

• Armazena os valores da propriedade da conexão como um objeto
Repository:
−A senha é criptografada
 Origem de dados ou nome do banco de dados
 Outras propriedades da conexão específicas ao tipo de conexão
• Os objetos de conexão de dados são vinculados a um tipo
específico de Connector ou outro tipo de estágio do banco de dados
• Os valores do objeto de conexão de dados podem ser carregados
no estágio Connector de uma tarefa
 Link de carregamento dentro do estágio
 Botão direito do mouse > seleção de menu Load Data Connection
 Também é possível salvar valores de estágio existentes em um objeto de
conexão de dados

Os objetos de conexão de dados armazenam os valores da propriedade de conexão
em um objeto Repository nomeado. Essas propriedades da conexão então podem ser
carregadas para o estágio Connector como um conjunto. Isso evita a tarefa de inserir
manualmente os valores para as propriedades de conexão. Também permite aos
desenvolvedores inserir propriedades da conexão em um estágio Connector sem
conhecerem a senha real, que é criptografada.
Os objetos de conexão de dados são vinculados a um tipo específico de Connector.
Quando um objeto de conexão de dados é criado, é selecionado o tipo de estágio
Connector em que ele será usado.


Seleção do tipo
de estágio
relacional
Valores da propriedade
do conector

Esse slide mostra a parte interna de um objeto de conexão de dados. Observe que ele
fornece valores da propriedade de conexão para um tipo de estágio DB2 Connector.

Criação de um novo objeto de conexão de dados
Nova
conexão de
dados
Criação de um novo objeto de conexão de dados

Esse slide mostra como criar um novo objeto de conexão de dados. Clique em New e
depois selecione a pasta Other.
Também é possível salvar os parâmetros e os valores especificados em um estágio
Connector existente em um novo objeto de conexão de dados.

Carregamento da conexão de dados
Carregar a Criar a
conexão de conexão de
dados dados
Carregamento da conexão de dados

Esse slide mostra uma maneira de carregar um objeto de conexão de dados
em um estágio. Clique com o botão direito do mouse sobre o estágio e clique em
Load Data Connection.
Outra maneira de carregar a conexão de dados é arrastá-la e soltá-la no estágio. Outra
maneira ainda é clicar no botão Load dentro do estágio.
Clique em Save data connection para salvar os valores da propriedade de conexão
no estágio em um novo objeto de conexão de dados.

Demonstração 1
Leitura e gravação em tabelas relacionais

 Criar um objeto de conexão de dados para um tipo de estágio
DB2 Connector
 Criar e carregar uma tabela DB2 usando o estágio DB2 Connector
 Importar uma definição de tabela usando ODBC
 Ler de uma tabela do DB2 usando o estágio ODBC Connector
Demonstração 1: Leitura e gravação em tabelas relacionais

Demonstração 1:
Leitura e gravação em tabelas relacionais
Propósito:
Você deseja ler e gravar em um banco de dados. Para fazer isso, primeiro
você criará um objeto Data Connection, então criará e carregará uma tabela
DB2. Por fim, você lerá da tabela DB2 e gravará em um arquivo.
NOTA:
Etapas:
exibida.
Tarefa 1. Crie um objeto Data Connection.
1. Clique em New e depois em Other.

2. Clique em Data Connection e depois em OK para abrir a janela Data

Connection.
3. Na caixa de nome Data Connection, digite DB2_Connect_student.
4. Clique na guia Parameters e, na caixa Connect using Stage Type, clique nas
reticências para selecionar o tipo de estágio DB2 Connector:

5. Clique em Open e insira os valores de parâmetro para os três primeiros

parâmetros:
 ConnectionString: SAMPLE
 Username: student
 Password: student
6. Clique em OK e salve o conjunto de parâmetros na pasta Metadata.

Tarefa 2. Crie e carregue uma tabela DB2 usando o estágio
DB2 Connector.
1. Crie uma nova tarefa paralela chamada relWarehouseItems. O estágio de
origem é um estágio Sequential File. O estágio de destino é um estágio DB2
Connector, que você localizará em Palette > Database. Nomeie os links e
estágios como mostrado.
2. Edite o estágio Sequential File Warehouse para ler dados do arquivo

Warehouse.txt. Certifique-se de poder visualizar os dados.
Em seguida, você deseja editar o estágio DB2 Connector.

3. Clique duas vezes no estágio DB2 Connector e depois, no canto direito do

painel Properties, clique no link Load para carregar as informações de
conexão do DB2_Connect_student que você criou anteriormente.
Isso configura a propriedade Database para SAMPLE e configura as
propriedades de nome do usuário e senha.
4. Configure a propriedade Write mode como Insert. Configure Generate SQL
para Yes. O Table name é ITEMS.
NOTA: também é possível digitar STUDENT.ITEMS, pois o esquema DB2 para
esse banco de dados é STUDENT.

5. Role para baixo e configure a propriedade Table action como Replace. Mude
também o número de linhas por transação (Record count) para 1. Depois de
mudar o valor, também é preciso configurar Array size para 1 (porque o
número de linhas por transação deve ser um múltiplo do tamanho da matriz).
6. Compile e execute, então veja se há erros no log da tarefa.

Em seguida, você deseja ver os dados na tabela.
7. Clique com o botão direito em ITEMS e depois em visualizar dados do
Warehouse.

Tarefa 3. Importe uma definição de tabela usando ODBC.

1. No menu do Designer, clique em Import > Table Definitions > ODBC Table
Definitions.
2. Na caixa DSN, selecione SAMPLE
3. Nas caixas User name e Password, digite student/student.
4. Clique em OK.
5. Especifique To folder para apontar para a pasta _Training > Metadata.
Selecione a tabela STUDENT.ITEMS.
NOTA: se você tiver dificuldade para localizar, digite STUDENT.ITEMS na
caixa Name Contains e clique em Refresh.
6. Clique em Import.
7. Abra a definição de tabela STUDENT.ITEMS no painel Repository e clique na
guia Columns para examinar as definições de coluna. Se a coluna ITEM
contiver um tipo SQL ímpar, mude o tipo SQL para NVarChar.

8. Clique na guia Locator e digite EDSERVER na caixa Computer.

9. Verifique se os campos schema e table estão preenchidos corretamente,
como mostrado.
Esses metadados são salvos no Repository com a definição de tabela e usados
pelas ferramentas e pelos componentes do Information Server, incluindo o SQL
Builder.
10. Clique em OK para fechar a definição de tabela.

Tarefa 4. Crie uma tarefa que leia de uma tabela do DB2
usando o estágio ODBC Connector.
1. Crie uma nova tarefa paralela chamada relReadTable_odbc. Use o estágio
ODBC Connector para ler da tabela ITEMS criada em uma tarefa anterior.
Grave em um estágio Data Set.
2. Abra o estágio Connector ITEMS na guia Properties. Digite SAMPLE na caixa

Data source. Especifique o nome de usuário e a senha do banco de dados –
neste caso, student/student. Clique em Test para testar a conexão.
3. Configure a propriedade Generate SQL para Yes.

4. Digite o nome da tabela: STUDENT.ITEMS.
5. Clique na guia Columns. Carregue a definição de tabela STUDENT.ITEMS.

Verifique se as definições de coluna correspondem ao que você vê a seguir.

6. Na guia Properties, verifique se consegue visualizar os dados.

7. No estágio Transformer, mapeie todas as colunas de ITEMS para ItemsOut.
8. No estágio Data Set de destino, grave em um arquivo chamado ITEMS.ds no
diretório Temp.
9. Compile e execute sua tarefa. Verifique se há erros no log da tarefa. Certifique-
se de poder visualizar os dados no arquivo do conjunto de dados de destino.
Resultados:
Primeiro, você criou um objeto Data Connection, então criou e carregou uma
tabela DB2. Por fim, você leu da tabela DB2 e gravou em um arquivo Data Set.

Vários links de entrada

• Grave linhas em várias tabelas dentro da mesma unidade de trabalho
 Use o painel de navegação no estágio para selecionar as propriedades
do link
 É possível especificar a ordem dos registros de entrada para links
de saída
− Propriedade Record ordering
• All records: todos os registros do primeiro link, então o link seguinte etc.
• First record: um registro de cada link é processado por vez
• Ordered: ordenação especificada pelo usuário
• Os links de rejeição podem ser criados para cada link de entrada
 Pode ser baseado em:
− Erro de SQL
− Linha não atualizada
 As colunas ERRORCODE e ERRORTEXT podem ser incluídas a cada
linha de rejeição
− Contém código de erro e texto do erro, respectivamente
Vários links de entrada

Vários links de entrada gravam linhas em várias tabelas dentro da mesma unidade de
trabalho. Os links de rejeição podem ser criados para cada link de entrada. As linhas
podem ser capturadas com base em duas condições: a ocorrência de um erro de SQL
e uma falha de atualização. A primeira ocorreria se uma inserção falhasse devido a um
valor de coluna corresponder a um valor de coluna-chave de linha existente. A
segunda ocorreria se uma atualização falhasse devido a não haver uma linha existente
com um valor da chave correspondente.
Ao usar vários links de entrada, a ordem em que as linhas são gravadas pode ser
especificada usando a propriedade Record ordering. Selecione All records para
gravar todos os registros do primeiro link antes de gravar os registros do link seguinte.
Selecione First record para gravar um registro por vez em cada link. Selecione
Ordered para especificar uma ordenação personalizada.

Tarefa com vários links de entrada e links de rejeição
Vários links Links de

de entrada rejeição
Tarefa com vários links de entrada e links de rejeição

Esse slide mostra uma tarefa gravando em duas tabelas DB2 usando o estágio DB2
Connector com vários links de entrada. Também são mostrados os links de rejeição
correspondentes a cada um dos links de entrada. Assim, por exemplo, o link de
rejeição superior chamado SGM_DESC_Rejects irá capturar os erros de SQL
ocorridos no link de entrada SGM_DESC.

Especificação das propriedades do link de entrada
Seleção do link
de entrada
Parâmetro da
tarefa
Clique para
criar o parâmetro
da tarefa
Especificação das propriedades do link de entrada

Esse slide mostra o interior do estágio Connector. É possível clicar em um link de
entrada em particular na caixa de nome do link para exibir suas propriedades. Neste
exemplo, o link de entrada SGM_DESC foi selecionado. A ação da tabela especificada
aplica-se a esse link.
Observe, ainda, que um parâmetro da tarefa está sendo usado para especificar a ação
da tabela. Clique no ícone indicado para criar um parâmetro da tarefa para a
propriedade dentro do estágio Connector.

Propriedade Record ordering
Propriedades
do estágio
Ordenação
de registro
Propriedade Record ordering

Esse slide mostra as propriedades do estágio para o estágio Connector. É aqui que
você especifica a ordenação dos registros para vários links de entrada usando a
propriedade Record ordering.

Especificação do link de rejeição
Link de
rejeição
Condições Inclusão
do link de na linha de
rejeição rejeição
Associação
do links de
rejeição
Especificação do link de rejeição

Selecione um link de rejeição na caixa de nome do link para exibir suas propriedades.
Na janela à esquerda, abaixo da caixa de nome do link, especifique as condições
capturando linhas no link de rejeição. Na janela à direita, é possível especificar se as
informações de erro serão incluídas junto com a linha rejeitada. Se, por exemplo, você
marcar ERRORCODE, uma coluna chamada ERRORCODE será incluída a cada linha
de rejeição. Essa nova coluna conterá o código de erro SQL que ocorreu.
Cada link de rejeição é associado a um link de entrada. Você especifica isso na caixa
Reject From Link na parte inferior da janela.

Demonstração 2
Estágios Connector com vários links de entrada

 Criar uma tarefa com vários links de entrada em um estágio Connector
 Criar parâmetros da tarefa para propriedades do estágio Connector
 Criar links de rejeição do estágio Connector
Demonstração 2: Estágios Connector com vários links de entrada

Demonstração 2:
Estágios Connector com vários links de entrada
Propósito:
Você vai atualizar tabelas relacionais usando vários links de entrada do
Connector em uma única tarefa.
NOTA:
Etapas:
exibida.
Tarefa 1. Crie uma tarefa com vários links de entrada do
Connector.
1. Crie uma nova tarefa paralela chamada relMultInput. Nomeie os links e
estágios como mostrado. Trabalhe da esquerda para a direita ao criar seu fluxo
de trabalho de tarefa, incluindo seus elementos e conectores.

2. Abra o estágio Sequential File de origem. Edite-o de modo que leia do arquivo
Selling_Group_Mapping.txt. Certifique-se de poder visualizar os dados.
3. Abra o Transformer. Mapeie os campos Selling_Group_Code e

Selling_Group_Desc para o link de saída SGM_DESC. Mapeie os campos
Selling_Group_Code, Special_Handling_Code e
Distribution_Channel_Description para o link de saída SGM_CODES.
A Distribution_Channel_Description apresenta um problema. O nome da
coluna é longo demais para o DB2.
4. Mude o nome da coluna de saída para Distribution_Channel_Desc.

5. Abra o estágio DB2 Connector.

6. Clique na guia Stage no canto superior esquerdo.
Isso exibe as propriedades Connection.
7. Clique no link Load. Selecione o objeto Data Connection
DB2_Connect_student criado em um laboratório anterior.
8. Clique na guia Input.

9. Na caixa Input name (upstream stage), selecione SGM_DESC (Split).

Configure a propriedade Write mode como Insert, defina Generate SQL para
Yes e digite SGM_DESC para Table name, como mostrado.
10. Clique em Table action para selecionar a linha, então clique em Use Job
Parameter .
11. Clique em New Parameter e crie um novo parâmetro da tarefa chamado
TableAction, com um valor padrão de Append.

12. Clique em OK.

Isso inclui o parâmetro da tarefa entre cerquilhas (#).
13. Clique na guia Columns. Selecione a caixa Key ao lado de

Selling_Group_Code.
Isso definirá a coluna como uma coluna-chave quando a tabela é criada.

14. Na caixa Input name (upstream stage) na parte superior esquerda do estágio,
selecione SGM_CODES (Split).
15. Na guia Properties, configure a propriedade Write mode como Insert, a
propriedade Generate SQL para Yes, a propriedade Table name para
SGM_CODES e Table action para #TableAction#, como mostrado.
16. Clique na guia Columns. Selecione a caixa Key ao lado da caixa

Selling_Group_Code.
Isso definirá a coluna como uma coluna-chave quando a tabela é criada.
17. Clique na guia Output e selecione SGM_DESC_Rejects

(Peek_SGM_DESC_Rejects) na lista suspensa Output name (downstream
stage).

18. Na caixa Reject From Link, selecione SGM_DESC.

19. Selecione as caixas SQL error, ERRORCODE e ERRORTEXT.
20. Na lista suspensa, selecione SGM_CODES_Rejects

(Peek_SGM_CODES_Rejects).
21. Na caixa Reject From Link, selecione SGM_CODES.

22. Selecione as caixas SQL error, ERRORCODE e ERRORTEXT.
23. Clique em OK para fechar a estágio Connector.

24. Compile seu trabalho.

25. Execute sua tarefa.

A janela Job Run Options é exibida.
26. Na primeira vez que você executar essa tarefa, selecione Create como a Table
action, de modo que as tabelas de destino sejam criadas.
27. Clique no botão Run.

28. Visualize o log da tarefa. Observe as mensagens do estágio DB2 Connector
que exibem informações sobre os números de linhas inseridas e rejeitadas.

29. No log, abra a mensagem que descreve a instrução usada para gerar a tabela.
Observe que a instrução CREATE TABLE inclui a opção PRIMARY KEY.
30. Agora, vamos testar os links de rejeição. Execute a tarefa novamente, desta
vez selecionando uma Table action de Append.

31. Observe que todas as linhas são rejeitadas, pois elas têm chaves duplicadas.
32. No log da tarefa, abra uma das mensagens Peek de rejeição e visualize as
informações que ela contém. Observe que ela contém duas colunas adicionais
de informações (RejectERRORCODE, RejectERRORTEXT) que possuem
informações de erro SQL.
Resultados:
Você atualizou tabelas relacionais usando vários links de entrada do
Connector em uma única tarefa.

SQL Builder
• Usa a definição de tabela
 Certifique-se de que as informações da guia Locator estejam
corretas
− Nomes de esquema e tabela são baseados nas informações da guia
Locator
• Arraste as definições de tabela para a tela SQL Builder
• Arraste colunas da definição de tabela para selecionar a tabela das
colunas
 Opcionalmente, especifique a ordem de classificação
• Defina expressões da coluna
• Defina a cláusula WHERE
SQL Builder
Os estágios Connector contêm um utilitário chamado SQL Builder que pode ser usado
para construir o SQL usado pelo estágio. O SQL é construído usando as operações da
GUI, como arrastar e soltar em uma área da tela. Usando o SQL Builder, é possível
construir instruções SQL complexas sem saber como construí-las manualmente.

Guia Locator da definição de tabela

Guia
Locator
Nome do esquema
da tabela
Nome da
tabela
Guia Locator da definição de tabela

Se você for usar o SQL Builder, é importante que a definição de tabela que você irá
arrastar para a tela SQL Builder para especificar a cláusula SELECT tenha as
informações corretas na guia Locator. O SQL Builder usa algumas dessas
informações na construção do SQL. Em particular, assegure-se de que o nome do
esquema da tabela e o nome da tabela estejam corretos, uma vez que não se podem
editá-los diretamente de dentro do SQL Builder.

Abertura do SQL Builder
Abrir o
SQL Builder
SQL
construído
Abertura do SQL Builder

Esse slide mostra como abrir o SQL Builder de dentro de um estágio Connector. O
botão Tools está bem à direita da linha da instrução SQL. Neste exemplo, a instrução
SELECT foi construída usando o SQL Builder. Como alternativa, é onde você digitaria
ou colaria manualmente em uma instrução SQL.

Janela SQL Builder
Arrastar definição
de tabela
Arrastar
colunas
Cláusula WHERE ORDER BY
Janela SQL Builder

Esse slide mostra a janela SQL Builder.
Você constrói a consulta na guia Selection, que é a primeira janela que se vê ao abrir
o SQL Builder. Comece arrastando uma definição de tabela para a tela da janela
Repository mostrada na parte superior esquerda. Verifique se as informações na guia
Locator da definição de tabela estão corretas. Em particular, assegure-se de que o
nome e o esquema da tabela estejam especificados corretamente.
Na definição de tabela, é possível arrastar colunas para baixo para a janela Select
columns para construir a cláusula SQL SELECT. Use a janela Construct filter
expression para construir sua cláusula WHERE.

Criação de uma coluna calculada

Seleção do editor Alias da
de expressão coluna
Função Selecione a função Parâmetros da função
Criação de uma coluna calculada

Esse slide mostra como construir uma coluna calculada no SQL Builder. Primeiro, abra
o editor de expressão para uma nova célula Column Expression. Nessa janela,
selecione um predicado (Functions, Calculation) e então comece a construir a
expressão.
Neste exemplo, a função SUBSTRING foi selecionada na lista Expression Editor.
Então, os parâmetros para essa função foram especificados à direita. A sequência de
caracteres à qual a função é aplicada é uma coluna da tabela ITEMS. A subsequência
de caracteres começa no caractere 1 e vai até 15 caracteres.

Construção de uma cláusula WHERE
Selecionar o Parâmetro Incluir condição

predicado da tarefa à cláusula
Incluir segundo
parâmetro da tarefa
Construção de uma cláusula WHERE

Esse slide ilustra como construir uma cláusula WHERE no SQL Builder. Construa a
expressão como mostra este exemplo. Então, clique em Add para incluir a expressão
à janela de expressão. Então, é possível criar expressões adicionais para incluir à
cláusula WHERE.
Observe que os parâmetros da tarefa podem ser usados dentro de uma expressão.
Neste exemplo, o parâmetro da tarefa #WarehouseLow# define o valor baixo de um
intervalo.

Classificação dos dados
Segunda
coluna pela
Classificar na ordem qual classificar
ascendente/decrescente
Primeira
coluna pela
qual classificar
Classificação dos dados

Esse slide ilustra como criar uma cláusula ORDER BY na instrução SQL. Na janela de
colunas Select, especifique a ordenação das colunas-chave de classificação na coluna
Sort Order. Para cada uma delas, é possível especificar Ascending ou Descending
na coluna Sort.

Visualização do SQL gerado
Somente leitura
Guia SQL
Visualização do SQL gerado

A qualquer momento, é possível visualizar o SQL que foi gerado até aquele ponto. A
guia SQL é somente leitura. Não é possível editar o SQL manualmente.
Observe o SQL da cláusula FROM, em que o nome da tabela e o nome do esquema
são usados. Eles vieram da guia Locator da definição de tabela.

1. Quais são as três maneiras de compilar instruções SQL em
estágios Connector?
2. Qual das seguintes instruções pode ser especificada nos estágios
Connector? Select, Insert, Update, Upsert, Create Table.
3. Quais são duas maneiras de carregar metadados de conexão
de dados em um estágio do banco de dados?


1. Manualmente. Usando o SQL Builder. Fazer o estágio Connector
gerar o SQL.
2. Todas as alternativas anteriores.
3. Clique com o botão direito do mouse sobre o estágio e clique em
Load Data Connection. Arraste a conexão de dados do
Repository e largue-a no estágio.

Demonstração 3
Construção de SQL usando o SQL Builder

 Chamar o SQL Builder
 Construir a cláusula SELECT
 Construir a cláusula ORDER BY
 Criar a expressão da coluna
 Definir uma cláusula WHERE
Demonstração 3: Construção de SQL usando o SQL Builder

Demonstração 3:
Construção de SQL usando o SQL Builder
Propósito:
Você deseja construir uma instrução SQL SELECT usando o SQL Builder.
NOTA:
Etapas:
exibida.
Tarefa 1. Crie uma instrução SQL SELECT usando o SQL
Builder.
1. Abra sua tarefa relReadTable_odbc e salve-a como
relReadTable_odbc_sqlBuild.

2. Abra sua definição de tabela STUDENT.ITEMS. Clique na guia Locator. Edite

ou verifique se as caixas schema e table contêm o nome do esquema e o
nome da tabela corretos, respectivamente.
3. Abra a janela Job Properties, então crie dois parâmetros de tarefa:

 WarehouseLow como um tipo inteiro, com um valor padrão de 0
 WarehouseHigh como um tipo inteiro, com um valor padrão de 999999

4. Abra o estágio de origem do Connector. Na pasta Usage, configure a

propriedade Generate SQL para No. Observe o novo aviso ao lado de Select
statement.
5. Clique na linha Select statement e depois em Tools. Clique em Build new

SQL (ODBC 3.52 extended syntax).
Isso abre a janela do SQL Builder.
6. Arraste a definição de tabela STUDENT.ITEMS para a tela.
7. Selecione todas as colunas, exceto ALLOCATED e HARDALLOCATED,

então arraste-as para o painel Select columns.

8. Classifique por ITEM e WAREHOUSE, em ordem ascendente. Para fazer isso,

selecione Ascending na coluna Sort. Especifique a ordem de classificação na
última coluna.
9. Clique na guia SQL na parte inferior da janela para visualizar o SQL com base
nas suas especificações até o momento.
10. Clique em OK para salvar e fechar a sua instrução SQL e o SQL Editor.
11. Você pode receber algumas mensagens de aviso. Clique em Yes para aceitar
o SQL como gerado e permitir ao DataStage mesclar as colunas selecionadas
do SQL Builder com as colunas na guia Columns.
12. Clique na guia Columns. Assegure que as colunas ALLOCATED e
HARDALLOCATED sejam removidas, já que não são referidas no SQL.
Verifique também se as definições de coluna correspondem ao que você vê a
seguir.

13. Clique na guia Properties.

Observe que a instrução SQL criada usando o SQL Builder foi colocada na
propriedade da instrução Select.
14. Abra o Transformer. Remova as colunas de saída em vermelho, já que elas

não são mais usadas.
15. Compile e execute com padrões. Visualize o log da tarefa.
16. Verifique se consegue visualizar os dados no estágio de destino.
Tarefa 2. Use o editor de expressão SQL Builder.
1. Salve sua tarefa como relReadTable_odbc_expr.
2. Abra o estágio ODBC Connector de origem e, ao lado da instrução SELECT
gerada anteriormente, clique no botão Tools.
3. Clique em Edit existing SQL (ODBC 3.52 extended syntax).
4. Clique na célula Column Expression vazia ao lado de *. Na lista suspensa,
selecione Expression Editor.
Isso abre a janela Expression Editor Dialog.
5. Na caixa Predicates, selecione o predicado Functions e depois selecione a
função SUBSTRING na caixa Expression Editor. Especifique que se devem
selecionar os primeiros 15 caracteres da coluna ITEM.
6. Clique em OK.

7. Para a nova coluna calculada, especifique um alias de coluna de

SHORT_ITEM.
8. Na janela Construct filter expression (WHERE clause), construa uma

cláusula WHERE que selecione o seguinte: Warehouses com números entre
#WarehouseLow# e #WarehouseHigh#, em que #WarehouseLow# e
#WarehouseHigh# são parâmetros da tarefa.
9. Clique no botão Add para incluí-lo na janela SELECTION.
10. Clique na guia SQL na parte inferior do SQL Builder para visualizar o SQL
construído. Verifique se está correto.
11. Clique em OK para retornar à guia Properties. Uma mensagem é exibida

informando que suas colunas no estágio não correspondem às colunas na
instrução SQL. Clique em Yes para incluir a coluna SHORT_ITEM nos seus
metadados.
12. Na guia Columns, especifique o tipo correto para a coluna SHORT_ITEM, a
saber Varchar(15).

13. Abra o estágio Transformer e mapeie a nova coluna SHORT_ITEM. Remova

as colunas ONHAND e ONORDER da saída.

15. Visualize os resultados.
Resultados:
Você construiu uma instrução SQL SELECT usando o SQL Builder.

Resumo da unidade
• Importar as definições de tabela para tabelas relacionais
• Criar conexões de dados
• Usar os estágios ODBC e DB2 Connector em uma tarefa
• Usar o SQL Builder para definir instruções SQL SELECT e INSERT
• Usar vários links de entrada em estágios Connector para atualizar
diversas tabelas dentro de uma única transação
• Criar links de rejeição de estágios do conector para capturar linhas
com erros de SQL
Resumo da unidade


Unidade 13 Controle da tarefa
Controle da tarefa


• Usar o sequenciador de tarefas do DataStage para compilar uma
tarefa que controle uma sequência de tarefas
• Usar links e estágios do sequenciador para controlar a sequência de
execução de um conjunto de tarefas
• Usar acionadores e estágios do sequenciador para controlar as
condições de execução das tarefas
• Enviar informações em parâmetros da tarefa da tarefa controladora
principal para as tarefas controladas
• Definir variáveis de usuário
• Ativar reinicialização
• Manipular erros e exceções
Controle da tarefa © Copyright IBM Corporation 2015

O que é uma sequência de tarefas?

• Uma tarefa de controle principal que controla a execução de um
conjunto de tarefas subordinadas
• Transmite valores para os parâmetros da tarefa subordinada
• Controla a ordem de execução (links)
• Especifica condições sob as quais as tarefas subordinadas são
executadas (acionadores)
• Especifica um fluxo de controle complexo
 Loops
 Todos/alguns
 Esperar pelo arquivo
• Executar atividades do sistema
 E-mail
 Executar comandos do sistema e executáveis
• Pode incluir pontos de verificação de reinicialização
O que é uma sequência de tarefas?

Uma sequência de tarefas é uma tarefa de controle principal que controla a execução
de um conjunto de tarefas subordinadas. Uma sequência de tarefas é um tipo de tarefa
especial que tem a própria tela e conjunto de estágios que podem ser arrastados para
a tela.
A sequência de tarefas gerencia e controla o conjunto de tarefas subordinadas. Os
valores de parâmetro podem ser enviados da sequência de tarefas para as tarefas
individuais. Dessa forma, as sequências de tarefas podem fornecer uma única
interface para todo um conjunto de tarefas.
A sequência de tarefas controla quando suas tarefas subordinadas são executadas e a
ordem em que são executadas. Também há vários estágios separados que podem ser
usados para controlar o fluxo de tarefas.
Além de controlar e executar tarefas, outras atividades do sistema podem ser
realizadas.

Fundamentos para criar uma sequência de tarefas

• Abertura de uma nova sequência de tarefas
 Especificação se ela é reinicializável
• Inclusão de estágios
 Estágios para executar tarefas
 Estágios para executar comandos do sistema e executáveis
 Estágios para propósito especial
• Inclusão de links
 Especificação da ordem em que as tarefas devem ser executadas
• Especificação de acionadores
 Acionadores especificam a condição sob a qual o controle passa
através de um link
• Especificação de manipulação de erros
• Ativação/desativação de pontos de verificação de reinicialização
Fundamentos para criar uma sequência de tarefas

Para criar uma sequência de tarefas, primeiro abra uma nova tela da sequência de
tarefas. Então, você inclui estágios e links, assim como para tarefas paralelas. Porém,
os estágios e os links têm um significado diferente. Os estágios são usados para
executar tarefas e para executar outras atividades. Os links são usados para
especificar a ordem em que as tarefas são executadas.
Para cada link, é possível especificar uma condição de acionamento sob a qual o
controle deve poder passar para o próximo estágio.

Estágios de sequência de tarefas

• Execução de estágios
 Atividade de tarefa: Execução de uma tarefa
 Execução de um comando: Execução de um
comando do sistema
 Atividade de notificação: Envio de um e-mail
• Estágios de controle de fluxo
 Sequenciador: Go if All / Some
 Espera por arquivo: Go when file exists /
doesn’t exist
 StartLoop / EndLoop
 Condição aninhada: condição Go if cumprida
• Manipulação de erros
 Manipulador de exceções
 Terminador
• Variáveis
 Variáveis de usuário
Estágios de sequência de tarefas

Os estágios da sequência de tarefas mostrados no slide à esquerda podem ser
colocados em diferentes categorias, como mostrado. Alguns estágios são usados para
executar tarefas e executar outros tipos de atividades. Alguns estágios são usados
para o fluxo de controle complexo. São usados dois estágios para manipulação de
erros. O estágio User Variables fornece um mecanismo para passar dados para
parâmetros de tarefa individuais.
Esses estágios são discutidos nas páginas seguintes.

Exemplo de sequência de tarefas
Espera
pelo
arquivo
Execução
Execução
de um
de uma
comando
tarefa
Envio de
um e-mail
Manipulação
de exceções
Exemplo de sequência de tarefas

Esse slide exibe um exemplo de uma sequência de tarefas. Ele contém muitos dos
diferentes estágios disponíveis. Esses diferentes tipos de estágios são destacados
pelas chamadas.
Observe a coloração dos links. Diferentes cores indicam diferentes condições de
acionamento, que são discutidas nas páginas a seguir. Por exemplo, um link vermelho
passa o controle para o estágio seguinte quando uma tarefa ou outra atividade falha.
Um link verde passa o controle para o estágio seguinte quando uma tarefa ou outra
atividade é bem-sucedida.

Propriedades de sequência de tarefas
Reinicialização Opções de log

da tarefa
Estágio de exceção
para manipular
Controle da tarefa
interrupções © Copyright IBM Corporation 2015
Propriedades de sequência de tarefas

Esse slide mostra as propriedades de sequência de tarefas que podem ser
configuradas. Um recurso-chave das sequências de tarefas é que eles podem ser
reinicializados. Ou seja, se uma das tarefas falhar, depois de várias terem sido
executadas com sucesso, a execução começará no ponto da falha quando a
sequência for reinicializada. Para ativar a capacidade de reinicialização, marque a
caixa Add checkpoints so sequence is restartable on failure.

Propriedades do estágio Job Activity
Tarefa a ser executada
Modo de execução
Parâmetros da
tarefa e seus valores
Propriedades do estágio Job Activity

Esse slide mostra a guia Job do estágio Job Activity e destaca os principais recursos.
Um estágio Job Activity é usado para executar uma tarefa. O campo Job name
especifica a tarefa.
A Execution action especifica como a tarefa deve ser executada. O modo de
execução Reset if required, then run reconfigurará uma tarefa cancelada na
execução anterior para uma condição executável.
Os parâmetros da tarefa para a tarefa a ser executada são listados na parte inferior,
junto com os valores que devem ser passados para elas. Expressões de valor para
esses parâmetros podem incluir os parâmetros da sequência de tarefas. Dessa forma,
quando a sequência é executada, os valores passados para a sequência de tarefas
serão passados para as tarefas individuais que ela controla.

Acionador do Job Activity

Nomes de link
de saída
Lista de tipos
de acionador
Compilação de expressões
de acionador customizadas
Acionador do Job Activity

Esse slide exibe a guia Triggers de um estágio Job Activity. A maioria dos estágios de
sequência de tarefas tem uma guia Triggers.
Um acionador pode ser especificado para cada link que sai do estágio. Uma lista dos
tipos de acionadores é mostrada na parte inferior esquerda. Neste exemplo, um
acionador Custom está sendo definido. A expressão do acionador é construída
usando o editor de expressão. Um menu de itens que podem ser inseridos na
expressão é exibido.
Vários outros tipos de acionadores podem ser selecionados. O acionador OK passará
o controle para o link se a tarefa ou outra atividade for executada com sucesso. O
acionador Failed passará o controle para o link se a tarefa ou outra atividade falhar.

Estágio Execute Command
• Execute comandos do sistema, shell scripts e outros executáveis

• Use, por exemplo, para eliminar ou renomear tabelas de banco de
dados
Executável
Parâmetros a
passar
Estágio Execute Command

Esse slide mostra a parte interna do estágio Execute Command, que é usado para
executar os comandos do sistema, shell script e outros executáveis.
O comando para executar o executável é especificado na caixa Command. Neste
exemplo, o script Echo_Script.sh será executado.
Os parâmetros podem ser enviados para o executável. Os valores dos parâmetros são
listados na caixa Parameters.

Estágio Notification Activity
Inclusão de
informações de
status da tarefa no
corpo do e-mail
Estágio Notification Activity

Esse slide exibe a parte interna do estágio Notification Activity. O estágio Notification
Activity é usado para enviar e-mails. São fornecidas caixas nas quais especificar os
endereços de e-mail do remetente e dos destinatários. Uma linha de assunto e anexos
também pode ser especificada.
Selecione a caixa Include job status in email para incluir um relatório de status sobre
as atividades na sequência de tarefas no e-mail.

Estágio User Variables
Estágio User Variável

Variables
Expressão definindo
o valor para a
variável
Estágio User Variables

Esse slide mostra uma sequência de tarefas com um estágio User Variables Activity. A
parte interna do estágio User Variables Activity é mostrada. Uma única variável é
definida junto com a expressão que especifica seu valor. Essa variável pode ser
passada para qualquer uma das tarefas que a seguem. Por exemplo, essa variável
pode ser passada para seqJob1 ou seqJob3.

Referência à variável de usuário
Variável
Referência à variável de usuário

Esse slide exibe a guia Job de um estágio Job Activity. O parâmetro PeekHeading é
passado para a variável de usuário mostrada na página anterior.

Estágio Wait for File
Arquivo
Opções
Estágio Wait for File

Mostra a parte interna do estágio Wait for File. Na caixa Filename, especifique um
arquivo que o estágio deve esperar aparecer ou desaparecer. Quando esse evento
acontece, o controle será passado para o estágio com base nas condições
especificadas do acionador.
Neste exemplo, o controle será passado para o estágio seguinte quando o arquivo
StartRun desaparecer.

Estágio Sequencer
• Sequencie várias tarefas usando o estágio Sequence
Pode ser
configurado
para All ou Any
Estágio Sequencer
Esse slide mostra um exemplo de uma sequência de tarefas com o estágio Sequencer.
Este estágio passa o controle para o estágio seguinte (PTPCredit) quando o controle
chega a ele de todos ou de alguns dos links de entrada. Ele tem dois modos: All/Any.
Se All for o modo ativo, o controle deve chegar a ele de todos os seus links de entrada
antes de passar o controle para o estágio seguinte. Se Some for o modo ativo, o
controle deve chegar a ele de pelo menos um dos seus links de entrada antes de
passar o controle para o estágio seguinte.

Estágio Nested Condition
Bifurcação baseada em
condições acionadoras
Condições
acionadoras
Estágio Nested Condition

Esse slide mostra o estágio Nested Condition em uma sequência de tarefas. Ele pode
ser usado para passar o controle através de um ou mais links com base nas condições
acionadoras. As condições acionadoras especificadas são exibidas na janela no canto
inferior esquerdo, como observado.
O estágio Nested Condition não executa nenhuma atividade. É usado para dividir o
fluxo de controle entre diferentes caminhos de saída.

Estágios de loop
Link de
referência
para iniciar
Valores do Passar valor

contador do contador
Estágios de loop
Esse slide mostra uma sequência de tarefas com um estágio de loop. Neste exemplo,
o estágio de loop processa cada uma das listas de valores na caixa Delimited Values
mostrada no canto inferior esquerdo. Os valores são delimitados por vírgulas. Neste
exemplo, o loop irá iterar três vezes. O valor para cada iteração será armazenado na
variável de estágio Counter que será passada para o estágio ProcessPayrollFiles Job
Activity no parâmetro FileName. Para cada iteração, a tarefa executada pelo estágio
Job Activity lerá do arquivo cujo nome está na variável de estágio Counter.

Manipulação de atividades que falham
Passar controle para

o estágio Exception
quando a atividade
falhar
Manipulação de atividades que falham

Esse slide mostra a janela Job Properties da sequência de tarefas. Se a caixa
Automatically handle activities that fail estiver selecionada, como mostrado aqui, o
controle será passado para o estágio Exception Handler quando qualquer atividade
falhar.

Estágio Exception Handler
O controle vai aqui

se a atividade falhar
Estágio Exception Handler

Esse slide mostra uma sequência de tarefas com um estágio Exception Handler, que
está destacado. Se uma das atividades executadas por um estágio Activity falhar (por
exemplo, Job_2 ou Execute_Command_27), o controle é passado imediatamente
para o estágio Exception Handler. Esse estágio inicia um conjunto de atividades. Neste
exemplo, a sequência envia um e-mail e finaliza normalmente as tarefas manipuladas
pela sequência de tarefas.

Ativação da reinicialização
Permita a inclusão
de pontos de
verificação
Ativação da reinicialização
Esse slide mostra a janela Job Properties da sequência de tarefas.
Se Add check points so sequence is restartable on failure estiver selecionada, a
sequência poderá ser reiniciada quando houver uma falha. A execução iniciará no
ponto da falha. As atividades que foram executadas com sucesso anteriormente e que
passaram por ponto de verificação não serão executadas novamente.

Desativação do ponto de verificação para um estágio
Não realizar o ponto de

verificação dessa atividade
Desativação do ponto de verificação para um estágio

Esse slide mostra a parte interna de um estágio Job Activity. A caixa Do not
checkpoint run é destacada. Se essa caixa for marcada, o estágio Job Activity será
executado cada vez que a sequência for executada, tenha ela sido executada com
sucesso na execução anterior ou não.

1. Qual estágio é utilizado para executar tarefas de execução em
uma sequência de tarefas?
2. O estágio Exception Handler tem suporte para um link de entrada?


1. Estágio Job Activity.
2. Não, o controle é passado automaticamente para o estágio quando
ocorre uma exceção (por exemplo, uma tarefa é interrompida).

Demonstração 1
Compilação e execução de uma sequência de tarefas

 Compilar uma sequência que executa três tarefas
 Passar parâmetros da sequência de tarefas para os estágios Job Activity
 Especificar acionadores customizados
 Definir uma variável de usuário
 Incluir um estágio Wait for File
 Incluir manipulação de exceção
 Executar uma sequência de tarefas
Demonstração 1: Compilação e execução de uma sequência de tarefas

Demonstração 1:
Compilação e execução de uma sequência de tarefas
Propósito:
Você deseja criar uma sequência de tarefas que execute três tarefas e
explorar como manipular exceções.
NOTA:
Etapas:
exibida.
Tarefa 1. Crie uma sequência de tarefas.
1. Importe o arquivo seqJobs.dsx para o diretório DSEss_Files\dsxfiles.
Esse arquivo contém as tarefas que você irá executar na sequência de tarefas:
seqJob1, seqJob2 e seqJob3.
2. Quando solicitado, importe tudo o que estiver listado no diálogo DataStage
Import.
3. Abra seqJob1. Compile a tarefa.

4. Na janela Repository, clique com o botão direito em seqJob2 e depois em

Multiple Job Compile.
A janela do DataStage Compilation Wizard agora é aberta.
5. Assegure que tanto seqJob2 quanto seqJob3 sejam incluídos na janela
Selected items.

6. Clique em Next duas vezes para ir para a janela Compile Process.
7. Clique em Start Compile.

8. Depois da compilação bem-sucedida das tarefas, clique em Finish. Se um
relatório for aberto depois da compilação, é possível simplesmente fechá-lo.
9. Volte para a tela seqJob1 aberta. Na janela Job Properties, clique na guia
Parameters e observe os parâmetros definidos para seqJob1. As outras
tarefas têm parâmetros similares.

10. Abra o estágio Transformer. Observe que o parâmetro da tarefa

PeekHeading prefixa a coluna de dados que serão gravados no log de tarefa
usando o estágio Peek.
11. Clique em New e selecione a pasta Jobs.
12. Abra uma nova Sequence Job e salve-a como seq_Jobs.

13. Em Palette, em Sequence, arraste os três estágios Job Activity para a tela,
vincule-os e nomeie os estágios e os links como mostrado. (Como alternativa, é
possível arrastar seqJob1, seqJob2 e seqJob3 para a tela.)

14. Abra a guia General na janela Job Properties. Revise e selecione todas as
opções de compilação.
15. Inclua parâmetros de tarefa à sequência de tarefas para fornecer valores aos
parâmetros da tarefa nas tarefas. Clique no botão Add Environment Variable
e, então, inclua $APT_DUMP_SCORE. Configure $APT_DUMP_SCORE
como True.
Dica: clique duas vezes na parte inferior da janela para classificar as variáveis.
16. Inclua três variáveis RecCount numeradas: RecCount1, RecCount2 e
RecCount3. Todas são uma sequência de tipos com um valor padrão de 10.
17. Abra o primeiro estágio Job Activity e configure e/ou verifique se o valor Job
name está definido para a tarefa que o estágio Activity deve executar.
18. Para o estágio Job Activity, configure os parâmetros da tarefa para os
parâmetros da tarefa correspondentes da sequência de tarefas. Para o valor
PeekHeading, use uma sequência de caracteres com um único espaço.

19. Configure Execution action para Reset if required, then run.

O resultado para seqJob1 aparece da seguinte maneira. Os outros são
similares.
20. Repita a configuração para os outros dois estágios usando os dois e três
valores correspondentes que correspondem ao estágio relevante.
Em cada um dos dois primeiros estágios Job Activity, você quer configurar os
acionadores de tarefa de modo que as últimas tarefas sejam executadas
apenas se as tarefas anteriores tiverem sido executadas sem erros, embora
possivelmente com avisos. Isso significa que DSJS.JOBSTATUS é
DSJS.RUNOK ou DSJS.RUNWARN.
Para fazer isso, é preciso criar um acionador customizado que especifique que
o status da tarefa anterior é igual a um dos dois valores acima.
21. Para seqJob1, na guia Triggers, na caixa Expression Type, selecione Custom
- (Conditional).
22. Clique duas vezes na célula Expression, clique com o botão direito, clique em
Activity Variable e, então, insira $JobStatus.
23. Clique com o botão direito para inserir "=", clique com o botão direito, clique em
DS Constant e, então, insira DSJS.RUNOK.
24. Clique com o botão direito para inserir Or.
25. Clique com o botão direito para inserir "=", clique com o botão direito, clique em
DS Constant e, então, insira DSJS.RUNWARN.

26. Pressione Enter.

O resultado para seqJob1 aparece da seguinte maneira:
27. Repita a etapa anterior para seqJob2 para incluir a expressão customizada.
O resultado para seqJob2 aparece da seguinte maneira:
28. Compile e execute a sequência de tarefas.

29. Visualize o log da tarefa para a sequência. Verifique se cada tarefa foi
executada com sucesso e examine a mensagem de resumo da sequência de
tarefas e as mensagens de relatório da tarefa individual.
Tarefa 2. Inclua uma variável de usuário.

1. Salve sua sequência de tarefas como seq_Jobs_UserVar. Inclua um estágio
User Variables Activity conforme mostrado.

2. Abra o estágio User Variables e depois a guia User Variables. Clique com o
botão direito no painel e depois clique em Add Row. Crie uma variável de
usuário chamada varMessagePrefix.
3. Clique duas vezes na célula Expression para abrir o Expression Editor.
Concatene a constante da sequência "Date is " com DSJobStartDate
DSMacro, seguida por uma barra entre espaços (" | ").
4. Abra cada estágio Job Activity. Para cada parâmetro PeekHeading, insira o
parâmetro varMessagePrefix na célula Value Expression.
Você deseja confirmar que sua variável de usuário seja incluída em cada item
de cabeçalho peek.

6. Em Tools > Run Director, clique duas vezes na tarefa seqJob1.

O seguinte mostra que PeekHeading é incluído, mas não mostra que o valor foi
incluído a todos os itens. Mais detalhes são necessários.
7. Feche o diálogo Job Status Detail, então clique com o botão direito em
seqJob1 e clique em View Log.
8. No log da tarefa, clique duas vezes no item Peek_0.0, conforme indicado.
Você agora vê que a variável de usuário "Date is: " prefixa os dados que vão
para a col1.

Tarefa 3. Inclua um estágio Wait for File.

Nesta tarefa, você modifica o seu design de modo que a tarefa espera para ser
executada até o arquivo StartRun.txt aparecer no diretório DSEss_Files/Temp.
1. Salve sua sequência de tarefas como seq_Jobs_Wait.
2. Inclua um estágio Wait for File Activity conforme mostrado.
3. Na página Job Properties, inclua um parâmetro da tarefa chamado StartFile

para passar o nome do arquivo pelo qual esperar. Especifique o valor padrão
StartRun.txt.
4. Editar o estágio Wait for File. Especifique que a tarefa deve esperar para
sempre até o arquivo #StartFile# aparecer no diretório DSEss_Files>Temp.

5. Na guia Triggers, especifique um acionador incondicional.

6. Compile e execute a sequência de tarefas. Agora, visualize o log da tarefa para
a sequência. Como se pode ver no log, a sequência está esperando o arquivo.
7. Agora, abra a tarefa seqStartSequence que faz parte do arquivo seqJobs.dsx

importado anteriormente. Essa tarefa cria o arquivo StartRun.txt no diretório
DSEss_Files/Temp.
8. Compile e execute a tarefa seqStartSequence para criar o arquivo
StartRun.txt. Então, volte para o log para a sua sequência para observar a
sequência continuar até o fim.
Tarefa 4. Inclua manipulação de exceção.
1. Salve sua sequência como seq_Jobs_Exception.
2. Inclua os estágios Exception Handler e Terminator Activity como mostrado.

3. Edite o estágio Terminator para que quaisquer tarefas em execução sejam

interrompidas quando ocorrer uma exceção.
4. Compile e execute sua tarefa. Para testar se ela manipula as exceções, faça
uma atividade falhar. Por exemplo, configure o parâmetro RecCount3 para -10.
Então, vá para o log da tarefa e abra a mensagem Summary. Verifique se o
estágio Terminator foi executado.
Resultados:
Você construiu uma sequência de tarefas que execute três tarefas e explorou
como manipular exceções.

Resumo da unidade
• Usar o sequenciador de tarefas do DataStage para compilar uma
tarefa que controle uma sequência de tarefas
• Usar links e estágios do sequenciador para controlar a sequência
de execução de um conjunto de tarefas
• Usar acionadores e estágios do sequenciador para controlar as
condições de execução das tarefas
• Enviar informações em parâmetros da tarefa da tarefa controladora
principal para as tarefas controladas
• Definir variáveis de usuário
• Ativar reinicialização
• Manipular erros e exceções
Resumo da unidade

Treinamento
IBM
© Copyright IBM Corporation 2015. Todos os direitos reservados

IBM - Guia Do Curso - Fundamentos Do IBM InfoSphere DataStage v11.5

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

IBM - Guia Do Curso - Fundamentos Do IBM InfoSphere DataStage v11.5

Enviado por

Direitos autorais:

Formatos disponíveis

®

Código do curso KM204 ERC 1.0

© Copyright IBM Corp. 2005, 2015 P-2

© Copyright IBM Corp. 2005, 2015 P-3

Verificação se o Information Server está em execução .................................... 2-11

© Copyright IBM Corp. 2005, 2015 P-4

Procedimento de importação do arquivo sequencial ........................................ 4-13

© Copyright IBM Corp. 2005, 2015 P-5

Detalhes da mensagem.................................................................................... 5-31

© Copyright IBM Corp. 2005, 2015 P-6

Utilitário Data Set Management ........................................................................ 6-45

© Copyright IBM Corp. 2005, 2015 P-7

Unidade 8 Combinação de dados.................................................................. 8-1

© Copyright IBM Corp. 2005, 2015 P-8

Ponto de verificação ......................................................................................... 8-55

© Copyright IBM Corp. 2005, 2015 P-9

Restrições ........................................................................................................ 10-9

© Copyright IBM Corp. 2005, 2015 P-10

Demonstração 4: Processamento de grupo em um Transformer ................... 10-67

© Copyright IBM Corp. 2005, 2015 P-11

Propriedades de uso – Generate SQL............................................................ 12-12

© Copyright IBM Corp. 2005, 2015 P-12

Referência à variável de usuário .................................................................... 13-14

© Copyright IBM Corp. 2005, 2015 P-13

Visão geral do curso

© Copyright IBM Corp. 2005, 2015 P-14

© Copyright IBM Corp. 2005, 2015 P-15

Recursos de treinamento adicional

© Copyright IBM Corp. 2005, 2015 P-16

Ajuda de produtos IBM

Orientada à Você está trabalhando no produto e Produto IBM - Link de ajuda

Manuais Você deseja usar mecanismos de Start/Programs/IBM

IBM na Web Você deseja acessar algum dos

© Copyright IBM Corp. 2005, 2015 P-17

© Copyright IBM Corp. 2005, 2015 P-18

IBM InfoSphere DataStage v11.5

© Copyright IBM Corporation 2015

© Copyright IBM Corp. 2005, 2015 1-2

Introdução ao DataStage © Copyright IBM Corporation 2015

© Copyright IBM Corp. 2005, 2015 1-3

O que é o IBM InfoSphere DataStage?

Introdução ao DataStage © Copyright IBM Corporation 2015

O que é o IBM InfoSphere DataStage?

© Copyright IBM Corp. 2005, 2015 1-4

O que é o Information Server?

Introdução ao DataStage © Copyright IBM Corporation 2015

O que é o Information Server

© Copyright IBM Corp. 2005, 2015 1-5

Backbone do Information Server

Information Information Information FastTrack DataStage / MetaBrokers

Introdução ao DataStage © Copyright IBM Corporation 2015

Backbone do Information Server

© Copyright IBM Corp. 2005, 2015 1-6

Console da web do Information Server

Introdução ao DataStage © Copyright IBM Corporation 2015

Console da web do Information Server

© Copyright IBM Corp. 2005, 2015 1-7

Administrator Designer Director

Introdução ao DataStage © Copyright IBM Corporation 2015

© Copyright IBM Corp. 2005, 2015 1-8

Introdução ao DataStage © Copyright IBM Corporation 2015

© Copyright IBM Corp. 2005, 2015 1-9

Introdução ao DataStage © Copyright IBM Corporation 2015