Web Service (com e sem SSL) para PostgreSQL

Objetivos

Neste artigo você aprederá a:

  1. Acessa web services com e sem certificação digital;
  2. Extrair dados de um web service e carregá-los em uma tabela no PostgreSQL.

Introdução

A utilização de web services é cada vez mais comum nos dias de hoje, pois a garantia da integração entre sistemas com plataformas totalmente distintas minimiza principalmente o grau de invasividade nos sistemas que precisam ser integrados.

Utilizaremos nesse artigo a operação ConsultaDadosFilhos do web service do Sistema de Informações Organizacionais do Governo – SIORG -.

O processo de carga desenvolvido no decorrer deste artigo será sem o uso de SSL, mas explicarei em um tópico extra como consumir um web service que necessite de certificação digital no Talend.

Conhecendo o Web Service

  • Nessa interface você pode executar testes do serviço, porém com interface gráfica.
    • Exemplo: Passar o valor 2981 no parâmetro de entrada da operação ( pCo_Orgao: 2981). Isso te retornará todos os órgãos vinculados ao Ministério do Planejamento.

Processo de Carga Parte 1 – Extração dos Dados do Web Service

Nessa seção descreverei como será o processo de carga para a extração dos dados da operação ConsultaDadosFilhos do web service do SIORG. Para isso, detalharei passo a passo a configuração de cada componente do processo.

Nota: Para criar o job, selecione com o botão direito a opção “Job Designs -> Create job” e dê um nome ao job, o chamarei de “TalendBrasil_WS_MySQL”.

tRowGenerator

  • Na paleta de componentes clique na pasta Misc, selecione e arraste para o job o componente tRowGenerator. Com este componente iremos gerar o cabeçalho de XML padrão automaticamente.

  • Clique duas vezes no componente para que o Editor do RowGenerator apareça.
  • (1*) Na janela de edição clique no botão adicionar e altere o nome da coluna para “CabecalhoXML”. O tipo dessa coluna deve permanecer sendo String.
  • (2*) Na coluna Functions altere a função para ‘ … ‘  (última opção da lista de funções)
  • (3*) No campo Number of Rows for RowGenerator coloque o valor “1”, para que o nosso cabeçalho seja gerado apenas uma vez.
  • (4*) Na parte inferior da janela clique na aba Function parameters e inclua o conteúdo abaixo na coluna Valor.
    • Valor: “<?xml version=\”1.0\” encoding=\”ISO-8859-15\”?>”

tWebServiceInput

  • Na paleta de componentes clique na pasta Internet, selecione e arraste para o job o componente tWebServiceInput, esse é o componente padrão para chamadas a Web Services.

  • Clique duas vezes no componente para configurá-lo.
  • No campo Method Name inclua o nome da operação que iremos invocar. Nesse caso, a operação chamasse “ConsultaDadosFilhos” .
  • Na última parte serão inseridos os parâmetros necessários para fazer a chamada ao serviço, essa operação tem apenas um parâmetro de entrada, então clique 1 vez no botão adicionar  e coloque o valor 2981 entre aspas “”.

  • Feito isso, vamos criar o esquema que irá armazenar os dados provenientes do Web Service. Clique na opção Edit schema e adicione 1 coluna, dê o nome de ConsultaDadosFilhos, ao finalizar aparecerá uma janela perguntando se você deseja propagar as mudanças, clique em Yes.

tUnite

  • Na paleta de componentes clique na pasta Orchestration, selecione e arraste para o job o componente tUnite, esse componente irá juntar o “Cabeçalho XML” com os dados de retorno da consulta ao web service.

  • Clique com o botão direito em cima do componente tRowGenerator e selecine a opção Row -> Main, arrastando a seta para o componenente tUnite .
  • Clique com o botão direito em cima do componente tWebServiceInput e selecine a opção Row -> Main, arrastando a seta para o componenente tUnite .

tFileOutputDelimeted

  • Na paleta de componentes clique na pasta File -> Output, selecione e arraste para o job o componente tFileOutputDelimeted, esse será nosso componente de saída temporária dos dados do web service. Esse procedimento se dá, pois precisamos mapear os “nós” do XML e através desse passo intermediário conseguimos realizar essa tarefa com maior facilidade e clareza.

  • Clique com o botão direito em cima do componente tUnite e selecine a opção Row -> Main, arrastando a seta para o componenente tFileOutputDelimited.
  • Clique duas vezes no componente para configurá-lo.
  • No campo File Name retire o conteúdo padrão e inclua o caminho onde você deseja salvar o arquivo. A extensão do arquivo tem que ser .xml
    • Exemplo: “C:/Users/yasmim/Desktop/TalendBrasil_WS_MySQL/consulta_dados_filhos.xml

A figura abaixo mostra como está o job até momento.

Feito isso vá até a aba Run(Job) ou simplesmente pressione F6 para executar o job e verifique se o arquivo .xml está sendo gerado com sucesso.

Processo de Carga Parte 2 – Carga dos Dados no PostgreSQL

Nessa seção descreverei como será o processo de carga dos dados no banco de dados PostgreSQL. Para isso, detalharei passo a passo a configuração de cada componente do processo.

tFileInputXML

  • Na paleta de componentes clique na pasta File -> Input, selecione e arraste para o job o componente tFileInputXML. Este é o componente que iremos utilizar como entrada para o arquivo XML gerado no Processo de Carga Parte 1.

  • Clique com o botão direito em cima do componente tFileOutputDelimited e selecine a opção Trigger -> OnComponenteOK, arrastando a seta para o componenente tFileInputXML.
  • Clique duas vezes no componente para configurá-lo.
  • No campo Filename/InputStream retire o conteúdo padrão e inclua o caminho onde você  salvou o arquivo .xml.
    • Exemplo: “C:/Users/yasmim/Desktop/TalendBrasil_WS_MySQL/consulta_dados_filhos.xml
  • No campo Loop XPath query retire o conteúdo padrão e inclua o valor abaixo. Nesse campo deve-se mapear qual o nó do XML que daremos o looping.
    • Exemplo: “/Filhos/DadosFilho”
  • Clique em Edit Schema para configurar os campos de saída para o banco.
  • Clique no botão adicionar e inclua 4 (quatro) colunas. Com os nomes abaixo.
    • Co_orgao
    • No_orgao
    • Sg_orgao
    • Da_lei_criacao

Nota: Todos os campos listados acima devem ficar com o tipo de dado String e com os respectivos tamanhos: 6, 56, 6 e 10.

  • Após esse passo preeencha os valores da coluna XPath query conforme apresentado abaixo.
    • “Co_orgao”
    • “No_orgao”
    • “Sg_orgao”
    • “Da_lei_criacao”

tPostgresqlOutput

  • Na paleta de componentes clique na pasta Base de Dados-> PostgreSQL , selecione e arraste para o job o componente tPostgresqlOutput. Este é o componente que iremos utilizar para fazer a carga dos dados extraídos do web service no banco de dados PostgreSQL.

  • Clique com o botão direito em cima do componente tFileInputXML e selecine a opção Row-> Main, arrastando a seta para o componenente tPostgresqlOutput.
  • Clique duas vezes no componente para configurá-lo.
  • Preencha os campos do componente conforme o detalhamento abaixo.
  1. Login: usuário do banco de dados;
  2. Password: senha do banco de dados;
  3. Server: IP do banco (se a conexão for local, pode usar localhost);
  4. Port: porta do banco de dados (já vem preenchido por padrão 5432, caso sua conexão seja em outra porta basta alterar);
  5. DataBase: nome da base de dados. Darei o nome de “Orgaos”;
  6. Schema: nome do schema do banco de dados. Esse parâmetro é opcional. Caso você não tenha criado um schema novo para a base de dados use o schema public.
  • No campo Action on table selecione a opção “Drop table if exists and create”.
  • No campo Action on data selecione a opção “Insert”.

Após esses passos vá até a aba Run(Job) ou simplesmente pressione F6 para executar o job e verique se os dados extraídos do web service foram carregados no banco de dados PostgreSQL.

Nota: Caso uma mensagem de erro apareça ao executar o job, verifique se os parâmetros de acesso ao PostgreSQL informados estão corretos e tente novamente.

Acessando Web Services com Certificação Digital

Para acessar um web service com SSL no Talend, existe um procedimento que deve ser realizado na máquina virtual java. Nessa seção descreverei tal procedimento.

Nota: Os caracteres <> devem só servem como destaque para o que deve ser alterado, ou seja, eles não fazem parte dos nomes e nem dos comando apresentados.

Criação da KeyStore

  • De posse do certificado digital do web service que deseje acessar (arquivo .cer ou .crt) salve o mesmo na máquina que irá executar o processo de carga.
    • Exemplo: c:\<nome_certificado>.cer
  • Acesse o prompt de comando do seu sistema operacional e execute o comando abaixo na pasta do java (..\jdk1.6.0_26\bin).
    • Comando 1: keytool -genkey -v -alias server -keyalg RSA -keystore <caminho do arquivo .cer> “CN=<url do site do certificado>,OU=Equipamento A1,O=ICP-Brasil,C=BR” -storepass password -keypass password
    • Comando 2: keytool -import -v -file <caminho do arquivo .cer> -keystore <caminho do arquivo .keystore> -storepass password
  • Copiar o arquivo ‘<nome_certificado>.cer’ para a pasta ..\jdk1.6.0_26\jre\lib\security
  • Acesse o prompt de comando do seu sistema operacional e execute o comando abaixo na pasta do java (..\jdk1.6.0_26\bin).
    • Comando 1: keytool -importcert -trustcacerts -alias <ALIAS> -keystore ..\jre\lib\security\cacerts -file ..\jre\lib\security\<nome_certificado>.cer
    • Comando 2: Informar a senha, por padrão é ‘changeit’
    • Você vai então receber a seguinte mensagem se tudo for bem sucedido – “Certificado foi adicionado ao keystore”.

Nota:  A pasta ‘jdk1.6.0_26’ muda de acordo com a versão do JDK que tiver instalado na máquina

Após esse procedimento, o certificado estará com o keystore importado e já poderemos ir para o Talend.

tWebServiceInput

  • Na paleta de componentes clique na pasta Internet, selecione e arraste para o job o componente tWebServiceInput, esse é o componente padrão para chamadas a Web Services.
  • Clique duas vezes no componente para configurá-lo.
  • No campo WSDL retire o conteúdo padrão e inclua o endereço do wsdl do web service que com certificado que deseje acessar.
  • No campo Method Name inclua o nome da operação que deseje  invocar.
    • Exemplo: “Operacao_com_Certificacao”
  • Selecione a opção “Trust server with SSL (Use tSetKeystore rather than this option”
  • No campo TrustStore file inclua o caminho do arquivo .keystore
    • Exemplo: “C:/certificado.keystore”
  • No campo TrustStore password inclua a senha caso possua. Caso contrário, deixe o valor default “password”
  • Na última parte insira os parâmetros necessários para fazer a chamada ao serviço.

  • Feito isso,  criae o esquema que irá armazenar os dados provenientes do Web Service. Clique na opção Edit schema e adicione 1 coluna, dê o nome da saida , ao finalizar aparecerá uma janela perguntando se você deseja propagar as mudanças, clique em Yes.

Conclusão

Bom, espero que com esse artigo você seja capaz de acessar qualquer tipo de web service com o Talend, seja com certificação digital ou não.

Um grande abraço a todos e até a próxima.

Anúncios

Otimizando extração e carga de dados utilizando componentes Bulk

Neste artigo vou demonstrar como otimizar a extração e carga de dados quando utilizando componentes Bulk. Para a maioria das tecnologias de bancos de dados suportadas pelo Talend existem os componentes BulkOutput, BulkExec e OutputBulkExec, estes componentes permitem a extração para arquivo (OutputBulk), carga do arquivo utilizando o método de load do próprio banco (BulkExec) e extração e carga utilizando o mesmo componente (OutputBulkExec).

O job de demonstração abaixo foi desenvolvido para a extração de dados de um banco de dados Oracle e carga em um Sybase IQ, mas alguns tweaks foram necessários para otimizar da performance do mesmo, pois apenas esta tabela possuia um volume na casa dos terabytes.

Para começar, primeiramente estabelecemos as conexões com os databases. Como este job executa mais de um subjob em paralelo (veremos adiante como ativar multithreads) temos de garantir que as conexões sejam estabelecidas antes da execução de qualquer outro subjob, para isso utilizamos o componente tPrejob, e por segurança caso a última execução tenha terminado sem sucesso deletamos os arquivos extraídos utilizando os componentes tFileList e tFileDelete. Além do tPrejob, existe o tPostjob, que garante que os subjobs ligados a ele através de triggers sejam executados somente após a execução dos demais subjobs não ligados a ele.

Job completo: clique para visualizar em tamanho real

Um subjob é um segmento do job que pode ser executado independentemente da execução de outros segmentos, ou pode estar conectado a outros através de triggers. Graficamente eles são delimitados por retângulos de fundo azul claro, laranja ou outra cor caso você tenha customizado.

Estabelecidas as conexões e removidos os arquivos de execuções anteriores, damos início à extração e carga de nossos dados.

O subjob logo abaixo do Prejob executa uma query no nosso banco destino, neste caso um Sybase IQ, obtendo o maior ID da tabela que pretendemos carregar, desta forma podemos extrair de nossa fonte apenas os registros novos, cujo ID seja maior que o carregado na última execução. O resultado desta query é propagado ao componente tJavaRow, que armazena o valor em uma variável de contexto.

Trabalhar com o tJavaRow é simples: clique em Sync Columns e então em Generate code, e o Talend irá gerar um código geralmente no padrão

output_row.MAX = input_row.MAX;

onde MAX é o nome de um dos campos do schema do componente (neste caso há apenas um campo), output_row é a saída do tJavaRow e input_row é a entrada, o que ele está recebendo do componente predecessor. Mas como não pretendemos propagar dados a partir deste componente, substituímos output_row por context.NOME_DA_VARIAVEL ficando desta forma:

context.NOME_DA_VARIAVEL = input_row.MAX;

Para criar variáveis de contexto vá até a view Contexts, adicione suas variáveis, defina seus tipos e valores default, você pode ver mais detalhes neste artigo: Usando variáveis de contexto.

Extraído este valor máximo e armazenado em uma variável, partimos para o subjob de extração dos dados da fonte e para garantir que esta etapa seja executada somente após a execução da etapa anterior, ligamos os dois subjobs com a trigger OnSubjobOk.

Este banco de dados que utilizamos como origem é um Oracle RAC (Real Application Cluster), um cluster de databases Oracle para garantir a alta disponibilidade. Como o Talend ainda não suporta a conexão a RAC especificando mais de um host (especificando um apenas funciona, mas não garante a alta disponibilidade) utilizamos uma conexão do tipo General JDBC, onde podemos editar a URL de conexão livremente (O suporte a conexão com RACs Oracle utilizando os componentes desta tecnologia está previsto para a versão 5.0).

Então editamos a query no database de origem, para trazer apenas os dados onde o ID seja maior do que o presente no database destino. Para isso selecione o componente de input e vá em Query, lá edite a query para que ela fique semelhante a esta:

"SELECT
...
...
FROM ORIGEM
WHERE ID > " + context.VARIAVEL

Observe como adicionamos a variável de contexto à query: como no fim das contas isso é uma String para a linguagem Java, colocamos a parte constante entre aspas e então concatenamos o conteúdo da variável, que será definido em tempo de execução, utilizando o operador +.

Dica de desempenho: em alguns componentes de Input de algumas tecnologias, existem opções que permitem otimizar a forma como os dados são extraídos. Nos componentes Oracle e JDBC (dentre outros) existe a opção Enable Cursor que em alguns casos permite obter um ganho de performance considerável. Já no componente de input do MySQL existe a opção Enable stream que também pode incrementar sua performance na extração de dados. Mas atenção: com a opção de stream no Mysql não é possível utilizar uma única conexão em modo multithread com a opção Use an existing connection.

E como modo de armazenamento intermediário destes dados obtidos do database de origem utilizamos arquivo(s) de texto puro. Neste caso utilizaríamos normalmente um componente OutputBulk, mas ao invés disso utilizamos um componente tFileOutputDelimited, que no fim das contas tem o mesmo propósito: gerar um arquivo de texto puro, mas além disso possui uma opção interessante: na guia Advanced do componente ativamos a opção Split output in several files que fará surgir uma outra opção chamada Rows in each output file, com estas opções especificamos que o conjunto de registros obtidos da fonte deverá ser dividido em vários arquivos com um número máximo de registros, cujo valor é definido por você. Neste caso defini um limite de 100 milhões de registros por arquivo. Assim teremos vários arquivos com o nome PRODUCTS1.dat, PRODUCTS2.dat…


O propósito de se dividir o resultset em vários arquivos você entenderá agora com a descrição do outro subjob, que é executado em paralelo ao que foi descrito até aqui.

Este subjob executa enquanto o outro subjob não tiver concluído sua execução. Para isso utilizamos o componente tLoop, onde podemos definir o tipo de Loop que pretendemos executar (for ou while) e as condições de sua execução. O loop “for” é recomendado quando você consegue estimar o número de execuções e o loop “while”, como o próprio nome já diz, é recomendado quando você deseja executar ENQUANTO uma condição for verdadeira. Utilizaremos o loop while e mais à frente irei mostrar como construíremos a condição de execução.

Após o tLoop temos o componente tSleep que permite pausarmos a execução deste subjob por um tempo pré determinado, neste caso um minuto. Observe que a ligação entre o tLoop e tSleep é feita através da linha Iterate, pois não há fluxo de dados sendo transmitido, apenas uma repetição de execuções.

Quando o componente tSleep termina a sua execução é chamado o componente tFileList através da trigger OnComponentOk, ou seja, quando a execução apenas deste componente (tSleep) tiver sido concluída, e então o tFileList irá listar o conteúdo de um diretório especificado por você, sendo que é possível adicionar uma máscara para os arquivos listados para que você filtre o resultado.

Estamos listando o conteúdo do diretório onde o componente tFileOutputDelimited está criando arquivos, então definimos uma máscara com o formato de nome que esperamos para estes arquivos, neste caso “PRODUCTS*.dat”, onde * é um caractere curinga onde esperamos a sequència de números que o tFileOutputDelimited irá inserir na criação dos arquivos.


O resultado dos arquivos listados pode ser obtido através de um loop mais uma vez utilizando a linha Iterate, desta forma conectamos o componente tFileList e tSystem.

Através do componente tSystem executamos comandos do sistema, independente do sistema onde o job está sendo executado, Windows, Linux, FreeBSD… quem sabe outros.. E neste especificamente executamos um comando pertencente a sistemas Unix e similares: o lsof, que lista os arquivos abertos no momento por algum processo.

Observe o comando sendo executado:

"sudo /usr/sbin/lsof " + ((String)globalMap.get("tFileList_1_CURRENT_FILEPATH"))

Chamamos o comando lsof e concatenamos à String o caminho do arquivo atual listado pelo componente tFileList, mas como obter este caminho?

Observe que no canto esquerdo inferior da suite, abaixo do repositório, existe uma view chamada Outline. Dentro desta view existem variáveis de retorno dos componentes que você está utilizando no job atualmente aberto, como número de linhas inseridas em um arquivo ou erro retornado por um componente. Para utilizar estas variáveis você simplesmente seleciona e arrasta para o local desejado, um campo de código livre como no tJava ou tJavaRow ou mesmo um campo de opção de algum componente, como iremos fazer agora.

Para obter os nomes dos arquivos que listamos no componente tFileList, incluindo o caminho de sua localização, e concatenar esta String ao comando lsof, vamos até a view Outline, expandimos a visão do componente que desejamos, neste caso o tFileList_1 e arrastamos a variável Current File Name with path para o campo onde executamos o comando do sistema no componente tSystem, concatenando as Strings com o operador +.

Atenção: Tome o cuidado de observar o nome único do componente na view Outline, neste job temos por exemplo os componentes tFileList_1 e tFileList_2. Você pode obter o nome único do componente clicando no mesmo e olhando o cabeçalho da view Component.

Agora que já listamos os arquivos criados naquele diretório e executamos o comando lsof sobre a lista obtida, partimos para a carga em si destes arquivos no database destino e então você entenderá o por que de tudo isso.

Como estamos gerando vários arquivos separados em 100 milhões de registros e em paralelo temos um subjob responsável pela carga destes arquivos no Sybase IQ, temos de garantir que a carga dos arquivos extraídos somente seja executada após a conclusão destes, ou seja, após o seu fechamento. Para isso executamos o comando lsof e, dependendo do resultado, saberemos se o arquivo está fechado, significando que o mesmo está pronto para carga, ou aberto, significando que a extração de registros para este arquivo ainda não foi concluída.

Então utilizamos o componente BulkExec da tecnologia destino, aqui um Sybase IQ, para carregar o arquivo do loop atual. Neste componente você define o schema da tabela destino e aponta para o arquivo a ser carregado, mais uma vez obtendo o nome do arquivo e caminho listado no tFileList através da view Outline.

E para garantir que sejam carregados apenas os arquivos fechados, conectamos o componente tSystem ao tSybaseIQBulkExec utilizando a trigger If, onde poderemos especificar uma condição para execução do componente sucessor. Como condição utilizamos o retorno do componente tSystem, que caso seja igual a 1 indica que o arquivo atual não foi listado, ou seja, não está aberto por nenhum processo e então podemos carregá-lo.

Por fim, chamamos os componentes tSybaseCommit e tFileDelete logo após a carga do arquivo, que como os próprios nomes descrevem, realizam o Commit da transação e exclusão do arquivo carregado (mais uma vez utilizamos a variável Current file with path do componente tFileList).

Agora os detalhes adicionais para conclusão deste job. Como condição de execução do componente tLoop, queremos que este subjob seja executado enquanto houver algum arquivo a carregar, então irei lhe mostrar como construir esta condição:

Procure pelo nome único do componente tFileOutputDelimited dentro de Outline (neste caso provavelmente haverá apenas tFileOutputDelimited1) e arraste a variável Number of line para o campo Condition do componente tLoop e compare o seu valor com null, ficando desta maneira:

(((Integer)globalMap.get("tFileOutputDelimited_1_NB_LINE")) == null)

Desta forma garantimos que o subjob continue sua execução mesmo se o seu início se der antes do subjob de extração dos dados, pois o número de linhas retornado pelo componente tFileOutputDelimited será igual a null. Mas isto não é suficiente: devemos agora testar se o componente tFileList retornou algum arquivo e para isto arrastamos a variável Number of files da view outline e separamos as condições pelo operador || , que significa OU. Ainda, damos uma margem caso o componente tFileList ainda não tenha sido executado, comparando o conteúdo da variável Number of files também com null e aglomeramos estes dois testes entre parenteses para que seja retornato true (verdadeiro) caso um ou o outro retorne true, mesmo que o outro teste retorne false.

(((Integer)globalMap.get("tFileList_1_NB_FILE")) >= 1 || ((Integer)globalMap.get("tFileList_1_NB_FILE")) == null)

Juntos, os três testes com compoem a condição do loop ficarão assim:

(((Integer)globalMap.get("tFileOutputDelimited_1_NB_LINE")) == null) || (((Integer)globalMap.get("tFileList_1_NB_FILE")) >= 1 || ((Integer)globalMap.get("tFileList_1_NB_FILE")) == null)

Para concluir, utilizamos o componente tPostJob para conectar os componentes tSybaseClose e tJDBCClose, que como os nomes já descrevem, fecham as conexões estabelecidas logo no início da execução do job.

Um último detalhe antes de pressionar F6 é habilitar a execução multithread. Vá até a view Job, entre em Extra e habilite a opção Multithread Execution.

Conclusão

Para muitas cargas quando se tratam de alguns megabytes não há a necessidade de um job como este, provavelmente você utilizará um “input” e um “outputbulkexec“, mas conforme o volume de dados aumenta, a complexidade dos jobs responsáveis por sua carga se eleva proporcionalmente se você quiser incrementar a performance.

Com esta abordagem o espaço em disco não precisa ser uma preocupação: imagine extrair alguns terabytes de dados em um único arquivo para só então carregar este arquivo, enquanto você pode consumir apenas alguns gigabytes para isso!

Além do espaço em disco, há um ganho de tempo considerável, pois o database destino não precisa ficar horas (ou dias!) esperando a extração ser concluída para só então realizar a carga, enquanto pode fazê-la em partes.

Por fim, a carga de dados a cada 100 milhões de registros torna o processo mais simples de se recuperar de qualquer execução falha: imagine se a 99% da extração dos dados da fonte a rede vai abaixo? Você tem a segurança de que ao menos algo em torno de 95% já tenha sido carregado no destino com sucesso e é esse o motivo de excluírmos quaisquer arquivos existentes no início do processo: pode haver algum registro truncado e então extraímos apenas os registros cujo ID seja maior do que o último carregado no destino.

SCD – Slowly Changing Dimensions

Hoje irei demonstrar como criar dimensões históricas – Slowly Changing Dimensions, ou simplesmente SCD – através do Talend. Este tipo de dimensão é interessante em muitos processos onde seja importante manter histórico dos dados.

Primeiramente, crie um arquivo de texto com o seguinte conteúdo:

ID;Funcionario;EstCivil;Cargo;SalBase;Comissao
33;Pedro Siqueira;Solteiro;Vendedor;2100.00;3

Em seguida, crie um novo metadado no repositório de seu projeto apontando para este arquivo.

O schema deste metadado deverá ficar conforme a imagem abaixo:

Feito isso, crie uma conexão com o banco de dados que você irá utilizar, neste tutorial estou utilizando o MySQL.

Crie um novo job e então selecione as duas conexões até este momento criadas e arraste para o mesmo, uma nova janela irá surgir para que você escolha em qual componente deseja utilizar cada conexão, selecione tMysqlSCD para a conexão com o banco de dados e tFileInputDelimited para o arquivo de texto.

Arraste o fluxo Main a partir do componente tFileInputDelimited até o componente tMysqlSCD (clique com o direito sobre o primeiro, vá ao submenu Row, clique em Main e então leve a seta até o componente de saída).

Selecione o componente tMysqlSCD e vá até a view Component, altere a opção “Action o table” para “Create table if not exists” e então vá até a opção “SCD Editor”.

Uma nova janela irá se abrir onde customizaremos o funcionamento de nossa SCD, mas primeiramente é necessário compreender o que são os Types SCD:

Os Types dentro do SCD determinam qual atitude desejamos tomar caso um determinado campo em um registro sofra alterações, os types utilizados no Talend são os seguintes:

Type 0 – Sem ação
Type 1 – Sem histórico
Type 2 – Histórico através de registros (linhas)
Type 3 – Histórico através de campos (colunas)

Além dos types, temos também a Surrogate key, que é a nossa chave substituta, afinal é uma boa prática ter uma chave diferente daquela do sistema de origem.

Vamos arrastar o campo ID de Unused para Source keys
Funcionario para Type 0
EstCivil para Type 1 pois desejamos atualizar este campo, mas não manter histórico
Cargo e SalBase para Type 2 pois desejamos manter histórico através de novos registros
Comissao para Type 3, pois desejamos manter a comissão anterior como histórico em outro campo no mesmo registro, altere também o nome do campo em previous value de previous_Comissao para Comissao_Anterior.

Vamos também marcar as opções version e active, para que sejam criados dois campos onde teremos o indicador de ativo e a versão do registro.

Por fim, vamos dar um nome à nossa Surrogate key, coloque SK e na opção creation deixe “Table max + 1”.

Execute o job.

Após a execução, abra o SQL Builder, selecionando o componente tMysqlSCD, indo até a view Component e clicando no botão com um par de óculos ao lado do campo “Table”.

Execute a query “select * from dm_funcionario”, a dimensão que acabamos de criar através deste componente. Observe o resultado, como as colunas estão desordenadas:

Uma possível solução a esse problema seria editar o schema do componente, no entanto parece que o editor SCD e o editor de schema não conversam muito bem e provavelmente você irá se deparar com o seguinte erro:

Isso acontece pois o previous value do type 3 é renomeado erroneamente para o mesmo nome do current value, e se você tentar renomear, o schema voltará à desordem anterior.

Existem alguns workarounds para este problema, vulgo gambiarras, e nós iremos evitá-las em pról da boa prática de criar nossos modelos de dados e tabelas previamente ao invés de encarregar as ferramentas de ETL.

Delete a tabela dm_funcionario criada pelo componente de SCD e crie novamente executando a seguinte query:

CREATE TABLE `demoproject`.`dm_funcionario` (
 `SK` int(11) NOT NULL,
 `ID` int(11) NOT NULL,
 `Funcionario` varchar(30) DEFAULT NULL,
 `EstCivil` varchar(10) DEFAULT NULL,
 `Cargo` varchar(15) DEFAULT NULL,
 `SalBase` float(10,3) DEFAULT NULL,
 `Comissao` float(3,2) DEFAULT NULL,
 `Comissao_Anterior` float(3,2) DEFAULT NULL,
 `scd_active` bit(1) NOT NULL,
 `scd_version` int(11) NOT NULL,
 `scd_start` datetime NOT NULL,
 `scd_end` datetime DEFAULT NULL,
 PRIMARY KEY (`SK`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1

Execute novamente o job e depois vá novamente ao SQL Builder e execute “select * from dm_funcionario”, veja que agora tomamos o controle da estrutura de nossa tabela por mais que o schema esteja desordenado.

Agora vamos realizar alguns experimentos alterando o nosso arquivo de entrada e observando os resultados.

Type 0

Primeiramente, experimente alterar o nome do funcionário: observe que mesmo que nenhuma alteração acontece em nossa tabela.

E se agora você alterar o ID do funcionário? Um novo registro será inserido em nossa tabela com o nome anteriormente alterado, pois o ID que é nossa chave na origem foi alterado, porém o registro anterior permanecerá ativo.

Type 1

Agora vamos alterar o campo EstCivil deste funcionário: o campo é atualizado, mas nenhum histórico é mantido. Experimente alterar o estado civil e o nome do funcionário ao mesmo tempo e observe que mesmo assim o nome do mesmo não é atualizado.

Type 2

Agora deixando o nome ainda alterado, experimente alterar os campos Cargo e/ou o SalBase do funcionário: um novo registro será inserido com estes campos atualizados, o registro anterior de mesmo ID será marcado como inativo (scd_active = 0) e terá atualizado o campo indicando o período de tempo pelo qual ele ficou ativo (scd_end). O novo registro será marcado como ativo (scd_active = 1) e terá a versão incrementada (scd_version = 2).

Além disso, uma observação importante e que você deverá levar em conta para tomá-la a seu favor: observe que o nome do funcionário foi atualizado! A explicação para isso é os dados a serem inseridos no novo registro são obtidos a partir do arquivo de entrada, e neste caso mesmo os campos marcados como type 0 irão se comportar como type 2. Use isso a seu favor: há situações nas quais determinados campos somente devem ser atualizados caso outros campos sejam alterados, nestes casos, utilize type 0 e type 2 em conjunto.

Type 3

Por fim, experimente alterar o campo Comissao no arquivo de entrada: observe que o valor anterior irá para o campo Comissao_Anterior e o novo valor será atualizado no campo Comissao.

É isso, qualquer dúvida, talendbrasil.com.br 🙂

Usando variáveis de contexto

Olá, neste job mostraremos como definir variáveis de contexto. Variáveis de contexto podem armazenar diretórios, configuração de banco de dados, em fim tipos de dados como string, interger, char, .. Se mostra útil no uso repetitivo de determinado valor. Imagine um job onde você utiliza repetidamente uma string que determina o caminho de um arquivo a ser o destino de nossos dados. Com uma variável de contexto guardando este valor a manutenção e possível mudança no job quanto ao diretório de destino será bastante simples e rápido, podendo alterar apenas a variável de contexto e alterar várias saídas.

Em posts anteriores já vimos como iniciar um projeto. Partiremos daqui.

Botão direito em Job Design‘create job’. Dê um nome ao nosso job, sugiro “usando vairiáveis de contexto”. Job criado, acesse a ‘paleta de componentes’ na aba Misc e selecione o componente tRowGenerator e clique na Job Design ou segure e arraste. Faça o mesmo para o componente tFileOutputDelimited localizado na aba File. Ligue os dois componentes usando o botão direito em tRowGenerator e selecionando ‘main’, ou segurando o botão direito arrastando até o segundo componente, tFileOutputDelimited. Assim criamos um ‘row link’, que será nosso duto para o fluxo de dados. Existem outros tipos de links, lógicos, que serão apresentados futuramente.

Clique duas vezes em tRowGenerator para abrir sua edição. Aqui temos dois grandes campos, sendo o primeiro para a criação e edição dos campos para nossos registros e o segundo para edição do parâmetros a serem utilizados no primeiro. No primeiro campo vamos configurar duas colunas, “company” e “randomNumber”. Na coluna ‘company’, escolha o tipo de dados como String, ‘…’ para a função, e então em parâmetros  digite “Client” em ‘value’. Já para a coluna ‘randomNumber’, escolha Integer para o tipo de dados, random para a função. Clique em ok. Aparecerá uma caixa de diálogo,

clique em Yes para sincronizar o esquema que criamos com o esquema de saída, ou seja, o esquema montado no arquivo. Clique duas vezes em tFileOutputDelimited para abrir sua edição na aba inferior ‘component view’. Clique em […] para determinar o diretório, nome e extensão do arquivo de saída. Use o diretório que entender melhor, com nome extensão, client1.csv.

Até aqui, temos nosso job desenvolvido em seu componentes e links. No componente de entrada, irá gerar registros da maneira como acabamos de configurar. Assim como o de saída, que já tem seu caminho configurado. Então vamos partir para o que interessa, as variáveis de contexto. Execute e job e verifique o arquivo criado, bem como seus dados, diretório, e nome, assim como foram setados. Crie as variáveis de contexto no repositório. Para isso, clique com o botão direito em Contexts na aba lateral de repositório de trabalho. Selecione Create constext group, dê um nome ao seu grupode contexto. Sugiro sempre usar um nome parecido ao do projeto. Clique em next. Estamos agora no campo onde poderemos criar e setar nossas variáveis. Para criar, clique em [+], três vezes,dê nomes as variáveis e indique seus tipos, company(String), diretory(Directory) e nbrows(int).  Clique na aba Values as tree e em Configure Contexts. Então, clique em New para adicionar novos contextos, sendo eles: contextClient1 e contextClient2. Dê OK. Ainda na aba Values as tree, defina vlaores para as variáveis de cada contexto.

Então, recaptulando, até aqui criamos um grupo de contexto. Neste grupo de contexto há três contextos, que serão nossas opções para execução do job final. E cada contexto é composto de trêsvariáveis de contexto.

Agora temos de disponibilizar estes contextos para o job que queiramos que trabalhe com estes. Clique no Context view (aba inferior). E Clique no botão de contexto para importar as variáveis. Então selecione todas as variávies de contexto que acabalmos de criar e dê OK. Então adicione o grupo de contexto em Add Context Group. Selecione os contextos e dê OK. Pronto, nossas variávies criadas já estão disponíveis na Context view.

Agora então, nos falta apenas usar nossas variáveis de contexto na execução dos jobs. Clique duas vezes no componente tRowGenerator para abrir seu editor. No campo, Number of Rows, coloque a variável de contexto nbrows, você pode fazer isso apenas digitando context.nbrows ou selecionando o campo e teclando Ctrl+Space, isso listará opções de sistema e contexto para que não precisse se preocupar em lembrar o nome da variável que usou. Faça o mesmo para o campo Parameter no campo de função de parametros do nosso esquema, setando a variável context.company. Dê OK.

Usamos duas das três variáveis de contexto. Falta apenas a variavel que indicava nosso diretório. Este será usado para não ter que ficarmos repetindo um diretório extenso para cada execução de nosso job. Isso facilita bastante. Pode imaginar o tempo que economizamos. Clique duas vezes no componente tFileOutputDelimited. No campo File Name, devemos passas do diretório, o nome do arquivo e ainda sua extensão. Assim usaremos nossas variáveis criadas. Lembrando que estamos lidando com Java, podemos concatenar Strings de forma a usar nossos contextos e gerar a String com diretório, nome e extensão para nosso arquivo de saída, assim:  context.directory+context.company+”.csv”.

Contextos criados, configurados e indicados para uso podemos rodar nossso job nos diversos contextos criados para que possamos ver o resultado. Para isso basta ir na aba inferior Run e dentro desta na aba de contexto selecionar um dos três contextos e clicar no botão de Run para executar nosso job usando o contexto selecionado. Fazendo isso para os três que criamos, podemos notar diferenças no númro de linhas criadas, na informção do campo company da nossas tabelas, e ainda no diretório e no nome do arquivo, isso tudo apenas usando as três variáveis de contextos que criamos. Essa se mostra uma boa prática, pois a mudança em cada um desses campos se mostra bem mais demorada que a simples criação dos variados contextos. E uma necessária re-execução se mostra ainda mais lenta.

Espero que tenha sido um post claro e útil.

O uso de variáveis de contexto se mostra muito mais ampla, segura e necessária que essas simples explicação. Mostraremos mais detalhes, principalmente sobre segurança, futuramente.

Um abraço a todos.

Acessando Web Services no Talend

Introdução

A utilização de Web Services é comumente usada na integração e comunicação entre sistemas. Nesse artigo começaremos com uma breve introdução sobre Web Services, o que são, seu formato padrão e como podem ser utilizados, posteriormente, iremos aprender como realizar requisições a um Web Service utilizando o Talend com um exemplo prático usando um Web Service de captura de endereço através do CEP.

Para o desenvolvimento desse artigo iremos utilizar um Web Service pertencente ao pessoal do Byjg, que é um site que possui diversos serviços para diversas situações, dentre eles está o serviço de consulta de CEP, no qual podemos passar um CEP para ter como retorno o endereço, e vice-versa.

 

Web Services

Os Web Services foram criados para construir aplicações que funcionem como serviços na internet, ou seja, que estejam disponíveis para outras aplicações independente da plataforma utilizada no seu desenvolvimento, e isso é possível devido a padronização da linguagem utilizada na comunicação entre Web Services. Todo Web Service só envia e recebe dados no formato XML, um formato universal, onde uma aplicação pode ser desenvolvida em qualquer linguagem, que, ao enviar ou receber os dados eles são convertidos para o formato XML, possibilitando assim a comunicação. Todo Web Service ao ser disponibilizado deve informar sua descrição, para o usuário saber como acessar, qual seu formato, o que ele retorna, etc. Essa descrição é feita no formato XML, utilizando um padrão, o WSDL (Web Service Description Language).

 

Conhecendo o Web Service

Para ter acesso ao serviço de CEP precisaremos realizar o cadastro no site. Para acessar entre aqui logo na página inicial, no canto direito superior selecione a opção área do usuário.

Na tela que aparece no canto direito selecione a opção crie agora.

Proceda com o cadastro normalmente e depois efetue o login, na primeira tela aparecerá a mensagem para ativar o serviço, clique em CEP na barra superior, nessa tela terminaremos de preencher os dados e marcaremos a opção Ativar WebService de consulta de CEP e basta confirmar as modificações.

Depois de finalizado o cadastro aparecerá uma tela para teste do serviço, porém com interface gráfica, ou seja, o Web Service está disponível e essa interface utiliza o Web Service de CEP para realizar as requisições.

O Web Service de CEP possui duas operações principais ObterLogradouroAuth, na qual recebe 3 parâmetros, CEP, usuário e senha, e retorna o endereço, e a operação ObterCEPAuth, que recebe 5 parâmetros, logradouro, localidade, UF, usuário e senha, e retorna o CEP.

Acessando o Web Service no Talend

Agora vamos ao Talend. Primeiramente vamos criar um job, no canto esquerdo selecione com o botão direito a opção “Job Designs -> Create job” e vamos dar um nome ao nosso job, o chamaremos de “WS_CEP”. Na paleta de componentes vamos expandir a pasta Internet, selecionar e arrastar para o nosso job o componente tWebServiceInput, esse é o componente padrão para chamadas a Web Services, disponível na versão Talend Open Studio, os demais componentes referentes a Web Services são disponibilizados na versão Talend Integration Suite.

Prosseguindo, também na paleta de componentes, vamos expandir a pasta Logs & Errors e realizar o mesmo processo com o componente tLogRow. Clicaremos com o botão direito em cima do componente tWebServiceInput selecionar a opção Row -> Main e arrastar a seta para o tLogRow. Vamos aproveitar para mostrar o nome do nosso job, clique em cima da área do job, e nas opções do componente marque a opção Show subjob title, você também pode colocar o nome que irá aparecer.

Clicando duas vezes no tWebServiceInput apareceram as propriedades do componente, no campo WSDL retire o que vem por padrão e insira a url do serviço de CEP, disponível aqui.

No campo Method Name colocaremos o nome da operação a ser requisitada no Web Service, obterLogradouroAuth, e na última parte serão inseridos os parâmetros necessários para fazer a requisição, como disse anteriormente o Web Service precisa de 3 parâmetros, então clique 3 vezes na opção + que tem logo abaixo. A ordem inserida aqui será a mesma ordem enviada ao Web Service, então se o Web Service recebe os parâmetros CEP, login e senha, vamos colocar nessa ordem também no Talend. Feito Isso vamos criar o esquema que irá armazenar os dados provenientes do Web Service. Clique na opção Edit schema e adicione 1 coluna, vamos nomeá-la  de endereço, ao finalizar aparecerá uma janela perguntando se você deseja propagar as mudanças, clique em Yes.

Feito isso basta ir até a aba Run(Job) ou simplesmente pressionar F6 para executar o nosso job e ver o resultado.

Bom por enquanto é isso, o intuito desse artigo foi só dar uma breve introdução à chamada de Web Services no Talend, e isso abre um leque de opções bastante vasto, sendo que essa tarefa acaba sendo bastante simples de ser realizada utilizando o Talend, dependendo somente da necessidade e criatividade.

Um grande abraço a todos.

Segundo job: PostgreSQL para Planilha Excel

Objetivos

Neste artigo você aprenderá a:

  1. Definir Metadados e Conexões com bancos de dados PostgreSQL;
  2. Carregar os dados do banco de dados mapeado em uma planilha Excel (XLS).

Introdução

Observações: Caso se tenha dúvidas em relação à criação de um repositório local, de um projeto e/ou de um job, por favor, veja os três primeiros passos do artigo Primeiro job: Arquivo delimitado para MySQL.

Requisito: Antes de começar, você irá precisar restaurar a base de dados  empresa, que será a origem de nossos dados.

IMPORTANTE: O arquivo em anexo encontra-se em formato .doc. Peço que você renomeie a extensão dele para .backup e para restaurá-lo siga os passos abaixo.

Nota: A versão do PostgreSQL utilizada no exemplo é a 8.4 (http://www.postgresql.org/download/)

Via pgAdmin III

  1. Clicar com o botão direito em Banco de Dados;
  2. Selecionar a opção ‘Novo Banco de Dados’;
  3. Definir os dados desse novo banco (nome, dono, codificação, etc.);
  4. Clicar com o botão direito no banco criado;
  5. Selecionar a opção Restaurar;
  6. Clicar no botão  ” … “;
  7. Informar o caminho onde se encontra o arquivo .backup, clicar em  Abrir e logo após em OK.

Via Comando

  1. Digitar o comando: pg_restore -d [NomeBase] /[Caminho do arquivo.bkp]

Nota: Os colchetes são apenas para ilustração.

Definindo Metadados

Nessa seção iremos descrever o mapeamento da origem do nosso Job (PostgreSQL, Base de Dados Empresa) e o mapeamento do destino (Planilha Excel).

PostgreSQL

Na seção Metadata (repositório da ferramenta), clique com o botão direito em Db Connections e selecione a opção Create Connection. No assistente que aparecer defina o nome da conexão e aperte na opção “Next“.

Nesta etapa você definirá o tipo do banco de dados e os detalhes da conexão. Em Db Type selecione PostgreSQL para que as outras opções sejam disponibilizadas e então defina os metadados de sua conexão conforme a imagem apresentada. Qualquer dúvida siga os passo do detalhamento abaixo.

Detalhamento dos parâmetros:

  1. Login: usuário do banco de dados;
  2. Password: senha do banco de dados;
  3. Server: IP do banco (se a conexão for local, pode usar localhost em caso de conexão local);
  4. Port: porta do banco de dados (já vem preenchido por padrão 5432, caso sua conexão seja em outra porta basta alterar);
  5. DataBase: nome da base de dados. Seguindo nosso exemplo o nome será Empresa;
  6. Schema: nome do schema do banco de dados. Esse parâmetro é opcional. Caso você não tenha criado um schema novo para a base de dados deve-se usar o schema public.

Após informar esses parâmetros clique em Check para verificar se a conexão com o banco de dados foi estabelecida. Caso a mensagem “Nome da Conexão connection successful” apareça, clique em OK e logo após Finish.


Nota: Caso uma mensagem de erro apareça ao testar a conexão, verifique se os parâmetros informados estão corretos e tente novamente.

Diante disso, você recuperará as tabelas da base de dados Empresa. Em Db Connections clique com o botão direito na conexão que você criou e selecione a opção Retrieve Schema. Com a  janela Schema aberta, clique em Next. Aparecerá um lista de todas as tabelas que fazem parte da base de dados Empresa. Selecione o botão Select All, logo após  Next e Finish.

Nota: Para verificar se as tabelas foram recuperadas, expanda a seção Table schemas (diretório abaixo da conexão criada no exemplo). Devem aparecer duas tabelas  ( tb_pessoa e td_cargo ).

Planilha Excel

Caso o Job criado para o exemplo não esteja aberto, por favor, abra. Logo após, vá até a Paleta da ferramenta, selecione as opções File -> Output , o componente tFileOutputExcel e o arraste até a área do Design Workspace. Para configurar a sua planilha de destino siga os passos abaixo.

  1. Clique uma vez em cima do icone do seu tFileOutputExcel;
  2. Logo abaixo da área do Design Workspace clique na aba Component e certifique-se que você se encontra na opção Basic settings do componente.
  3. No parâmetro File Name, clique na opção “…” para definir o diretório que você deseja salvar o arquivo e informar o nome dele.
  4. Marque a opção include header, para que na primeira linha de nossa planiha apareçam os nomes dos campos que estamos carregando.
  5. Clique no ícone salvar ou aperte Ctrl S para salvarmos as alterações.


Pronto!!!  Seu arquivo de destino já está configurado.

Nota: O Talend já coloca por default o caminho do workpace como diretório de saída dos arquivos (C:/Talend/TOS-Win32-r53616-V4.1.2/workspace). Nada impede que você altere conforme desejar.

Implementando o Job

Nessa etapa iremos implementar o processo de carga. Para isso o Job criado como exemplo deve estar aberto. Por favor, siga os passos listados abaixo.

  1. Clique, segure e arraste as duas tabelas criadas em Db Connections para a área do Design Workspace. Você pode selecionar vários itens utilizando a tecla Ctrl e arrastar de uma só vez. 
  2. Para cada item arrastado, uma janela irá surgir lhe perguntando que tipo de componente você deseja criar a partir desse item. Selecione para todos a opção tPostgresqlInput.
  3. Para cada tabela do Design Workspace, clique com o botão direito, selecione as opções Row -> Main e arraste a seta até o componente tMap. A ordem das tabelas deve ser seguida, primeiro tb_pessoa e depois td_cargo.
  4. Clique duas vezes no componente tMap e a janela de mapeamento irá aparecer. No lado esquerdo dessa janela ficam as tabelas da origem, o meio representa a transformação que os dados poderão sofrer e no lado direito o destino onde os dados serão armazenados (ETL).  Todas as configurações realizadas no componente tMap serão detalhadas abaixo.
  • Para recuperar as informações obtidas através do relacionamento entre as duas tabelas clique na opção “…” da tabela row2 da coluna idt_cargo e digite “row1.cod_cargo”.


  • Para criar  saída dos dados clique no ícone ” + ” e informar o nome da expressão.


  • Clique nas colunas das tabelas de origem e arraste para a saída criada. Arrate apenas os seguintes campos: mat_pessoa, nme_pessoa, nme_cargo, dsc_cargo e tel_ramal.
  • Após realizado o mapeamento clique na opção Apply e OK.


Após seguir os passos orientados anteriormente clique com o botão direito, selecione as opções Row -> [Nome da expressão de destino utilizada] e arraste a seta até o componente tFileOutputExcel e salve o projeto mais uma vez.

Certifique-se que seu Job esteja similar a ilustração abaixo.

Executando o job

  1. Clique na aba Run e depois no botão Run. Você também pode utilizar a tecla F6.
  2. Vá atéo diretório de destino que você escolheu e abra o arquivo Excel para visualizar os dados.

Conclusão

Neste artigo foi demonstrado como você realiza um processo de ETL. Extraindo os dados de uma base de dados no SGBD PostgreSQL, mostrando o cruzamento dos dados de duas tabelas e gerando um arquivo excel como saida. Dessa forma, esperamos ter mostrado as facilidades da ferramenta Talend. Até a próxima!!!

Primeiro job: Arquivo delimitado para MySQL

Neste artigo você aprenderá a:

  1. Criar um repositório local;
  2. Criar um projeto;
  3. Criar um job;
  4. Definir Metadados e Conexões com bancos de dados;
  5. Carregar os dados de um arquivo de texto em um banco de dados;

Introdução

Requisito: Antes de começar, você irá precisar deste arquivo, que será a origem de nossos dados.

Como já foi demonstrado neste artigo, é possível importar um projeto de demonstração a partir da janela de projetos, porém hoje iremos criar nosso projeto do zero e então o nosso primeiro Job.

Após efetuar o download da ferramenta, não será necessária a instalação, apenas descompacte na raiz do disco (o caminho curto fará diferença). Dentro do diretório do Talend, há diversas opções de binários para diversos sistemas e arquiteturas, e para cada um destes binários há um arquivo .ini, onde são configuradas as opções de memória da JVM.

Para o Windows há três executáveis: x86, x86_64 e WPF. O WPF é um subsistema para renderização de interface gráfica que utiliza DirectX que está para o Windows assim como o GTK está para Linux, porém não recomendo sua utilização pois ele ainda está em fase de portabilização no Eclipse sendo apenas uma herança para o Talend.

Para Linux há também três alternativas: x86, x86_64 e PPC (power pc) e todas utilizam o GTK.

Escolha o binário de acordo com a arquitetura de seu processador para que possamos partir para a criação de nosso projeto.

Nota: Você deve ter notado a forte ligação entre o Talend e o Eclipse, acontece que o Talend é desenvolvido como um plugin para o Eclipse, porém não é possível obtê-lo à parte.

Criando um repositório local

Então iremos criar um primeiro projeto em branco, mas antes disso é necessário criar um repositório onde serão armazenados nossos projetos.

As versões gratuitas permitem apenas a criação de repositórios locais, portanto no campo Workspace defina o diretório onde seus projetos serão armazenados, dê um nome a seu repositório e defina um e-mail válido.

Criando um projeto

Após criado o repositório, na tela de projetos poderemos criar um projeto selecionando a opção “Create a new local project” e “Go!“. Dê um nome a seu projeto, adicione uma descrição ao mesmo caso queira e escolha a linguagem utilizada (java ou perl), em nossos tutoriais utilizaremos a linguagem java. Feito isso clique em “Finish” e depois abra o projeto.

Nota: Ao abrir seu primeiro projeto o Talend provavelmente irá pedir seu e-mail, isto é opcional caso deseje obter newsletters sobre a ferramenta.

Criando um Job

A primeira tela a ser exibida na suite é a de boas vindas, feche-a e na próxima janela você terá à sua esquerda o repositório de seu projeto.

Nota: Uma caixa de diálogo com a informação Generation Engine irá aparecer, é recomendável que você aguarde a conclusão, se quiser clique em Run in background mas não cancele este processo.

Dentro de repositório, clique com o botão direito em Job Designs e selecione a opção Create Job. Um assistente irá surgir onde você poderá atribuir nome, propósito, descrição, versão e status ao novo job.

Ao concluir a criação do job, no centro de sua tela, na seção conhecida como Design Workspace um novo job em branco irá surgir.

Definindo Metadados

Arquivo

Para realizarmos a carga de nosso arquivo de texto em um banco de dados, precisamos primeiramente definir os metadados de nosso arquivo e nosso banco de dados.

Dentro do repositório, expanda a seção Metadata, lá você verá os metadados do projeto separados por tipo.

Primeiro vamos definir os metadados de nosso arquivo, por se tratar de um arquivo de texto delimitado por ponto e vírgula, clique com o botão direito em File Delimited e selecione a opção Create file delimited. No assistente que se abrir, dê um nome para o arquivo e clique em Next. Na próxima janela defina o caminho para o arquivo e sua codificação.

Na próxima etapa poderemos definir detalhes sobre a estrutura de nosso arquivo, como caracteres separadores de campos e linhas, linhas a saltar no início ou fim do arquivo ou mesmo limitar o número de linhas a serem lidas. Para o nosso arquivo, iremos definir um salto de 5 linhas iniciais, pois são comentários no cabeçalho do arquivo. Além disso, iremos marcar a opção Set heading row as column names para que a primeira linha após as 5 primeiras ignoradas seja considerada como nome das colunas.

A próxima etapa é onde definiremos os nomes das colunas, chaves primárias, tamanho, precisão e tipo de dado dos campos de nosso arquivo. Como estamos definindo metadados para um arquivo de texto, o tamanho, precisão ou chave primária não farão diferença, mas é interessante definir, pois poderemos herdar estas informações para componentes de saída.

Nota 1: O assistente varre as primeiras 10 linhas do arquivo para tentar detectar o tamanho dos campos, mas é importante você se certificar destes tamanhos, pois como são apenas as 10 primeiras linhas, você pode obter erros como o seguinte:

Data truncation: Data too long for column ‘RegTime’ at row 54

Observe que o erro ocorreu na linha 54, impossível que o assistente detectasse previamente o tamanho do campo. Este é um erro que você irá obter neste arquivo de exemplo caso deixe os tamanhos conforme o assistente detectar. Portanto configure o tamanho dos campos conforme na imagem anterior.

Nota 2: Para campos do tipo Date, você deve definir um padrão para a data conforme ela está disposta no arquivo, como você pode verificar na imagem anterior. Para mais informações use esta página.

Agora que já definimos os metadados de nosso arquivo, vamos definir os metadados de nossa conexão com o banco de dados.

Banco de Dados

Neste exemplo iremos utilizar o MySQL. Ainda na seção Metadata, clique com o botão direito em Db Connections e selecione a opção Create Connection. No assistente que se abrir defina o nome da conexão e salte para a próxima etapa.

Nesta etapa você definirá o tipo do banco de dados e os detalhes da conexão. Em Db Type selecione MySQL para que as outras opções sejam disponibilizadas e então defina os metadados de sua conexão conforme na imagem.

Clique em Check para verificar se os detalhes estão corretos e caso sim clique em Finish.

Como iremos utilizar esta conexão apenas como saída, não será necessária a definição de metadados de tabelas.

Carregando os dados

Esta etapa é extremamente difícil e é importante que você preste muita atenção.

Passo1: Clique, segure e arraste os dois itens criados em Metadata para a área do Design Workspace. Você pode selecionar vários itens utilizando a tecla Ctrl e arrastar de uma só vez.

Para cada item arrastado, uma janela irá surgir lhe perguntando que tipo de componente você deseja criar a partir desse item.

Para o arquivo delimitado, selecione tFileInputDelimited e para o mysql selecione tMysqlOutput. Observe que cada componente criado nesta área possui um visual diferente.

Passo 2: Agora clique e segure com o botão direito no componente tFileInputDelimited e arraste até o componente tMysqlOutput.

Selecione o componente tMysqlOutput. Veja que na parte inferior da suite você possui algumas visões. Clique na aba Component.

Nesta aba você pode definir várias opções para o componente, mas como estamos herdando as opções do repositório, não será necessária muita configuração.

Vá até o campo Table e dê um nome à tabela destino, por exemplo, “cliente”. Logo abaixo você verá as caixas Action on Table e Action on Data.

Em Action on Table você pode definir se o job irá criar a tabela, se ele irá truncar quaisquer dados existentes ou se ele deverá realizar um drop a cada execução. Selecione a opção Drop if exists and create para que ele exclua a tabela e crie novamente a cada execução.

Nota: A ação “Default” é não fazer nada, ou seja, a tabela deverá existir antes da execução do job.

Em Action on Data você define a ação com os dados, ou seja, se o job deverá realizar exclusões, atualizações ou inserções de dados.

Nota: Há duas opções que parecem redundantes: Insert or Update e Update or Insert, a diferença entre estas opções é performática: caso você saiba que seu job irá executar mais inserts do que updates, você deve selecionar a opção Insert or Update, para que ele primeiro realize os inserts e depois os updates. Caso saiba que ele vai realizar mais updates, então Update or Insert.

Executando o job

Clique na aba Run e depois no botão Run. Você também pode utilizar a tecla F6.

Conclusão

Neste artigo foi demonstrado como o Talend facilita nas tarefas básicas como criação de metadados, possibilitando que você se dedique mais ao que realmente importa.