Beruflich Dokumente
Kultur Dokumente
integração Cookbook
Segunda edição
Mais de 100 receitas para a construção de soluções fonte ETL abertos com
Integração Pentaho Dados
Alex Meadows
Carina Roldán
BIRMINGHAM - MUMBAI
Integração Cookbook dados Pentaho
Segunda edição
Todos os direitos reservados. Nenhuma parte deste livro pode ser reproduzida, armazenada em um sistema de recuperação
ou transmitida de qualquer forma ou por qualquer meio, sem a prévia autorização por escrito do editor, exceto no caso de
breves citações incorporadas em artigos ou críticas. Todos os esforços foram feitos na preparação deste livro para garantir a
precisão das informações apresentadas. No entanto, a informação contida neste livro é vendido sem garantia, expressa ou
implícita. Nem o autor, nem Packt Publishing, e os seus revendedores e distribuidores serão responsáveis por quaisquer
danos causados ou supostamente causados direta ou indiretamente por este livro.
Packt Publishing tem se esforçado para fornecer informações marca sobre todas as empresas e produtos mencionados
neste livro através da utilização adequada de capitais. No entanto, Packt Publishing não pode garantir a precisão das
informações.
www.packtpub.com
revisor
Kevin McGowan
revisores
indexador
Wesley Seidel Carvalho
Monica Ajmera Mehta
Daniel Lemire Coty Sutherland
Gráficos
Ronak Dhruv
editor de aquisição
Os editores técnicos
Raposo Gaurav
Thingalaya
Sobre o autor
Alex Meadows tem trabalhado com soluções de Business Intelligence de código aberto por quase 10 anos e trabalhou em
diversas indústrias, tais como fabricação de plásticos, marketing social e e-mail, e mais recentemente com software da Red Hat,
Inc. Ele tem sido muito ativo em Pentaho e outros comunidades de código aberto para aprender, compartilhar e ajudar os
recém-chegados com as melhores práticas em BI, análise e gerenciamento de dados. Ele recebeu seu diploma de Bacharel em
Administração de Empresas pela Universidade Chowan em Murfreesboro, Carolina do Norte, e seu mestrado em Business
Intelligence da Universidade de St. Joseph, na Filadélfia, Pensilvânia.
Em primeiro lugar, obrigado Christina por estar lá para mim antes, durante e depois de assumir o
desafio de escrever e revisar um livro. Eu sei que não tem sido fácil, mas obrigado por permitir-me a
oportunidade. Para minha avó, obrigado por me ensinar em uma idade jovem para sempre ir para os
objetivos que pode ser apenas fora do alcance. Finalmente, este livro não seria onde sem a
comunidade Pentaho e os amigos que fiz ao longo dos anos, sendo uma parte dela.
Adrián Sergio Pulvirenti nasceu em Buenos Aires, Argentina, em 1972. Ele obteve seu diploma de Bacharel em
Ciências da Computação na UBA, uma das universidades de maior prestígio na América do Sul.
Ele tem dedicado mais de 15 anos para o desenvolvimento de soluções de software web-based desktop e. Nos últimos
anos, ele tem liderado projetos de integração e desenvolvimento de soluções de BI.
Eu gostaria de agradecer aos meus filhos adoráveis, Camila e Nicolas, que compreenderam que eu não podia
compartilhar com eles as habituais sessões de jogos de vídeo durante o processo de escrita. Eu também gostaria
Ela já trabalhou como consultor de BI por mais de 10 anos. Nos últimos quatro anos, ela tem se dedicado em tempo integral
para o desenvolvimento de soluções de BI utilizando Pentaho Suite. Atualmente, ela trabalha para Webdetails, um dos
principais contribuintes Pentaho. Ela é a autora de 3,2 Pentaho Data Integration: Guia do Iniciante publicado por Packt Publishing em
Eu gostaria de agradecer aqueles que me encorajaram a escrever este livro: Por um lado, a
comunidade Pentaho; que me deram um feedback gratificante após livro do novato. Por outro
lado, meu marido, que sem hesitação, concordou em escrever o livro comigo. Sem eles eu não
tenho certeza se teria embarcado em um novo projeto de livro.
Eu também gostaria de agradecer aos revisores técnicos para o tempo e dedicação que eles colocaram
na revisão do livro. Em particular, graças aos meus colegas da Webdetails; é um prazer e um privilégio
trabalhar com eles todos os dias.
Sobre os revisores
Wesley Seidel Carvalho tem o seu mestrado em Ciência da Computação do Instituto de Matemática e Estatística da
Universidade de São Paulo (IME-USP), Brasil, onde pesquisou sobre (sua dissertação) Processamento de Língua Natural
(PLN) para o idioma Português. Ele é um especialista em banco de dados da Universidade Federal do Pará (UFPA). Ele tem
uma licenciatura em Matemática pela Universidade do Estado do Pará (Uepa).
Desde 2010, ele tem trabalhado com Pentaho e pesquisando Abrir governo de Dados. Ele é um membro ativo
das comunidades e listas de Software Livre, Open Data, e Pentaho no Brasil, contribuindo software "verificador
gramatical para o OpenOffice - CoGrOO" e Comunidade CoGrOO.
Ele tem trabalhado com a tecnologia, banco de dados e desenvolvimento de sistemas desde 1997, Business Intelligence desde
2003, e tem sido envolvida com Pentaho e PNL desde 2009. Ele atualmente está servindo seus clientes por meio de suas
startups:
f http://intelidados.com.br
f http://ltasks.com.br
Daniel Lemire tem um B.Sc. e um M.Sc. em Matemática pela Universidade de Toronto, e um Ph.D. em Engenharia
Matemática da Ecole Polytechnique e da Université de Montréal. Ele é um professor de Ciência da Computação na
TELUQ (Université du Québec), onde ele ensina principalmente online. Ele também foi um oficial de pesquisa do
Conselho Nacional de Pesquisa do Canadá e um empresário. Ele já escreveu mais de 45 publicações peer-reviewed,
incluindo mais de 25 artigos de jornal. Ocupou bolsas de pesquisa competitivos nos últimos 15 anos. Ele serviu como
um membro do comitê de programa em conferências líderes de ciência da computação (por exemplo, ACM CIKM,
ACM WSDM e ACM RecSys). Seu software de código aberto tem sido utilizado por grandes corporações como Google
e Facebook. Seus interesses de pesquisa incluem bancos de dados, recuperação de informação e programação de
alto desempenho. http://lemire.me/blog/.
Coty Sutherland foi introduzido pela primeira vez para a computação em torno da idade de 10. Naquela época, ele estava imerso
em vários aspectos de computadores e tornou-se evidente que ele tinha uma propensão para a manipulação de software. Desde
então e até agora, ele permaneceu envolvido em aprender coisas novas no espaço de software e adaptação ao ambiente em
mudança que é Desenvolvimento de Software. Ele se formou em Appalachian State University em 2009 com um Bacharel em Ciência
da Computação. Após a formatura, ele se concentrou principalmente no desenvolvimento de aplicações de software e suporte, mas
recentemente transferida para o campo de Business Intelligence para buscar coisas novas e emocionantes com dados. Ele está
atualmente empregado pela empresa open source, a Red Hat, como Engenheiro de Business Intelligence.
www.PacktPub.com
Você sabia que Packt oferece versões do eBook de cada livro publicado, com arquivos PDF e ePub disponíveis? Você pode
atualizar para a versão eBook em www.PacktPub.com e como um cliente livro impresso, você tem direito a um desconto na
cópia eBook. Entrar em contato com a gente no
service@packtpub.com para mais detalhes. em www.PacktPub.com, você também pode ler uma coleção de artigos técnicos
gratuitos, inscrever-se para uma série de boletins de notícias livres e receber descontos e ofertas exclusivas em livros e
eBooks Packt.
TM
http://PacktLib.PacktPub.com
Você precisa de soluções imediatas às suas perguntas de TI? PacktLib é uma biblioteca digital de livros on-line de Packt. Aqui,
você pode acessar, ler e pesquisar em toda a biblioteca de livros de Packt.
ii
Índice
iii
Índice
iv
Prefácio
Pentaho integração de dados (também conhecidos como Kettle) é uma das principais soluções de integração de dados de código
aberto. Com Chaleira, você pode tirar dados de uma multiplicidade de fontes, transformar e conformar os dados para requisitos
dados e carregar os dados em apenas como muitos sistemas de destino. Não só é PDI capaz de transformar e limpeza de dados, ele
também oferece um número cada vez crescente de plugins para aumentar o que já é uma lista muito robusto de recursos.
Pentaho Integration Cookbook de dados, Segunda Edição pega onde a primeira edição saiu fora, atualizando as receitas para a
última edição do PDI e mergulho em novos temas, tais como trabalhar com fontes de Big Data e nuvem, análise de dados e
muito mais.
Pentaho Integration Cookbook de dados, Segunda Edição mostra como tirar proveito de todos os aspectos da Chaleira através de um
conjunto de receitas práticas organizadas para encontrar soluções rápidas para suas necessidades. O livro começa com mostrando-lhe
como trabalhar com fontes de dados, como arquivos, bancos de dados relacionais, Big Data e fontes de nuvem. Então nós entramos em
como trabalhar com fluxos de dados, tais como combinar dados de diferentes fontes, como tirar proveito das diferentes ferramentas para
limpar e transformar os dados, e como construir trabalhos aninhados e transformações. tópicos mais avançados também são abordados,
tais como análise de dados, visualização de dados, plugins e integração das Chaleira com outras ferramentas da suíte Pentaho.
Pentaho Integration Cookbook de dados, Segunda Edição fornece receitas com fáceis instruções passo-a-passo para realizar tarefas
específicas. O código para as receitas podem ser adaptados e construído em cima para atender às necessidades individuais.
Capítulo 2, Leitura e Escrita de Arquivos, não só mostra como ler e gravar arquivos, mas também como trabalhar com
arquivos semi-estruturadas, e ler dados da Amazon Web Services.
Prefácio
Capítulo 3, Trabalhando com Big Data e Fontes nuvem, cobre como carregar e ler dados de algumas das muitas fontes de
dados NoSQL diferentes, bem como da Salesforce.com.
Capítulo 4, Manipulação de estruturas XML, mostra como ler, escrever e validar XML. estruturas XML simples e
complexos são mostrados, assim como formatos mais especializados, como feeds RSS.
Capítulo 5, Gerenciamento de arquivos, demonstra como copiar, mover, transferir e criptografar arquivos e diretórios.
Capítulo 6, À procura de Dados, mostra como a busca de informações através de vários métodos através de bases de dados,
serviços web, arquivos e muito mais. Este capítulo também mostra como validar os dados com etapas de validação embutidas de
chaleira.
Capítulo 7, Entendimento e Dados Otimizando fluxos, detalha como Kettle move dados através de postos de trabalho e
transformações e como otimizar fluxos de dados.
Capítulo 8, Execução e Re-usando Jobs e Transformações, mostra-lhe como lançar empregos e transformações de várias
maneiras através de argumentos estáticos ou dinâmicos e parametrização. transformações orientadas a objetos através
subtransformations também são explicados.
Capítulo 9, Integrando Chaleira eo Pentaho Suíte, trabalha com algumas das outras ferramentas da suíte Pentaho para mostrar como
combinar ferramentas proporciona ainda mais recursos e funcionalidades para relatórios, dashboards, e muito mais.
Capítulo 10, Obtendo o máximo de Kettle, trabalha com alguns dos recursos mais necessários (e-mail e madeireiras), bem como
conjuntos de dados de amostra edifício, e usando Chaleira para ler informações meta no emprego e transformações através de
arquivos ou repositório de dados de Kettle.
Capítulo 11, Utilizando ferramentas de visualização em Kettle, explica como trabalhar com plugins e se concentra em
DataCleaner, AgileBI e Instaview, uma característica da empresa que permite a análise rápida de fontes de dados.
Capítulo 12, Análise de dados, mostra como trabalhar com as diversas ferramentas analíticas incorporadas Chaleira, concentrando-se em
estatísticas que recolhem passos e conjuntos de dados de construção para Weka.
Apêndice A, Estruturas de dados, mostra as diferentes estruturas de dados usadas ao longo do livro.
Apêndice B, Referências, fornece uma lista de livros e outros recursos que ajudarão você a se conectar com o resto da
comunidade Pentaho e aprender mais sobre Kettle e as outras ferramentas que fazem parte do conjunto de Pentaho.
2
Prefácio
f Servidor Web com suporte ASP: Isso é necessário para duas receitas para mostrar como trabalhar
com serviços web.
f DataCleaner: Esta é uma das principais ferramentas de código aberto perfis de dados e integra
com chaleira.
f MySQL: Todas as receitas de banco de dados relacionais têm scripts para MySQL fornecido. Fique à vontade
Além disso, recomenda-se ter acesso ao Excel ou Calc e um editor de texto decente (como o Notepad ++ ou gedit).
Ter acesso a uma conexão de Internet será útil para algumas das receitas que usam serviços de nuvem, bem como
tornando possível acessar os links adicionais que fornecem mais informações sobre determinadas matérias ao longo do
livro.
Convenções
Neste livro, você vai encontrar uma série de estilos de texto que distinguem entre diferentes tipos de informação. Aqui estão alguns exemplos
desses estilos, e uma explicação do seu significado. palavras de código em texto, nomes de tabelas de banco de dados, nomes de pastas,
nomes de arquivos, extensões de arquivos, caminhos, URLs manequim, entrada do usuário, e manipula Twitter são apresentados da seguinte
forma: "Copie o
. jarra arquivo contendo o motorista para o lib . Diretório dentro do diretório de instalação Kettle" Um bloco de código é definido da
seguinte forma:
3
Prefácio
Quando queremos chamar a atenção para uma determinada parte de um bloco de código, as linhas ou itens relevantes são definidos em negrito:
<Pedido>
<Type> Cidade </ type>
<Query> Buenos Aires, Argentina </ query>
</ Request>
novos termos e palavras importantes são mostradas em negrito. Palavras que você vê na tela, em menus ou caixas de
diálogo, por exemplo, aparecem no texto assim: "clicando no Próximo botão move-lo para a próxima tela".
feedback do leitor
O feedback dos nossos leitores é sempre bem-vindo. Deixe-nos saber o que você pensa sobre este livro, o que você gostou ou
pode não ter gostado. feedback do leitor é importante para nós desenvolver títulos que você realmente tirar o máximo proveito
de. Para enviar-nos um feedback geral, basta enviar um e-mail para feedback@packtpub.com, e mencionar o título do livro através
do assunto da mensagem.
Se há um tema que você tem experiência em e você está interessado em qualquer escrito ou contribuindo para um
livro, consulte o nosso guia autor sobre www.packtpub.com/authors.
Suporte ao cliente
Agora que você é o proprietário orgulhoso de um livro de Packt, temos uma série de coisas para ajudá-lo a obter o máximo de
sua compra.
4
Prefácio
errata
Embora tenhamos tomado todos os cuidados para garantir a precisão de nosso conteúdo, erros acontecem. Se você
encontrar um erro em um dos nossos livros, talvez um erro no texto ou o código-ficaríamos muito gratos se você iria relatar
isso para nós. Ao fazer isso, você pode salvar outros leitores de frustração e nos ajudar a melhorar versões posteriores deste
livro. Se você encontrar qualquer errata, por favor informe-los visitando http://www.packtpub.com/submit-errata, seleção de seu
livro, clicando no errata Formulário de submissão link, e inserindo os detalhes da sua errata. Uma vez que seu errata são
verificados, a sua apresentação será aceito ea errata será carregado no nosso site, ou adicionado a qualquer lista de errata
existente, sob a seção Errata desse título. Qualquer errata existente pode ser visualizada através do seu título de http://www.packtpub.com/support.
Pirataria
A pirataria de material com direitos autorais na internet é um problema constante em todas as mídias. No Packt, tomamos a proteção
de nossos direitos autorais e licenças muito a sério. Se você se deparar com quaisquer cópias ilegais de nossos trabalhos, sob
qualquer forma, na Internet, por favor nos fornecer o endereço de localização ou nome do site imediatamente para que possamos
buscar um remédio. Entre em contato conosco copyright@packtpub.com com um link para o material pirateado suspeita.
Agradecemos a sua ajuda na proteção de nossos autores, e nossa capacidade de trazer-lhe um conteúdo valioso.
Questões
Pode contactar-nos em questions@packtpub.com se você está tendo um problema com qualquer aspecto do livro, e
faremos o nosso melhor para resolvê-lo.
5
1
Trabalhando com bancos de dados
f Obtendo dados de um banco de dados executando uma consulta construída em tempo de execução
f Inserir novas linhas quando uma chave primária simples tem de ser gerado
f Inserir novas linhas quando a chave primária tem de ser gerado com base nos valores armazenados
Introdução
Bases de dados são amplamente utilizados pelas organizações para armazenar e administrar dados transacionais, tais como histórico de
atendimento ao cliente, transações bancárias, compras, vendas, e assim por diante. Eles também são usados para armazenar dados de
Neste capítulo, você vai aprender a lidar com bancos de dados em Kettle. A primeira receita diz-lhe como se conectar a um banco de
dados, que é um pré-requisito para todas as outras receitas. O resto do capítulo ensina como realizar operações diferentes e podem
ser lidos em qualquer ordem, de acordo com suas necessidades.
O foco deste capítulo é sobre bancos de dados relacionais (RDBMS). Assim, o termo base
de dados é utilizado como sinónimo de banco de dados relacional ao longo das receitas.
bancos de amostras
Através do capítulo, você vai usar um par de bancos de dados de amostra. Esses bancos de dados podem ser criados e
carregado executando os scripts disponível no site do livro. Os scripts estão prontos para ser executado em MySQL.
Se você trabalha com um DBMS diferente, você pode ter que modificar os scripts
ligeiramente.
Para mais informações sobre a estrutura dos bancos de dados de amostra e do significado das tabelas e campos, consulte Apêndice A,
Estruturas de Dados. Sinta-se livre para adaptar as receitas para bancos de dados diferentes. Você poderia tentar alguns bancos de
dados bem conhecidas; por exemplo, Comida mart
(Disponível como parte do Mondrian distribuição no http://sourceforge.net/projects/ mondrian /) ou as bases de
dados de amostra MySQL (disponível em http://dev.mysql.com/doc/ índice de other.html).
Como parte dos bancos de dados de amostra usados neste capítulo você vai usar o Pentaho BI demo plataforma bancos de dados.
O Pentaho BI Platform Demo é uma instalação pré-configurado que permite explorar as capacidades da plataforma Pentaho. Ele se
baseia nas seguintes bases de dados:
Dados de amostra Os dados para Steel Wheels, uma empresa fictícia que vende todos os tipos de
réplicas escala de veículos.
8
Capítulo 1
Por padrão, todos os bancos de dados são armazenados em Hypersonic (HSQLDB). O script para criar os bancos de dados
HSQLDB pode ser encontrada em http://sourceforge.net/projects/pentaho/ arquivos. Debaixo Intelligence Business Server | 1.7.1-estável
olhe para pentaho_sample_data-
1.7.1.zip. Embora existam versões mais recentes do servidor Business Intelligence real, todos eles usam o mesmo conjunto de dados de
amostra.
Esses bancos de dados podem ser armazenados em outros SGBDs também. Scripts para criar e carregar esses bancos de
dados de outros SGBDs popular, por exemplo, MySQL ou Oracle pode ser encontrado em Prashant Raju de blog, em http://www.prashantraju.com/projects/pentaho.
Ao lado dos scripts que você vai encontrar instruções para criar e carregar os bancos de dados.
Se você pretende trabalhar com um banco de dados, seja leitura, escrita, olhando para cima de dados, e assim por diante, a primeira coisa que
você tem a fazer é criar uma conexão com esse banco de dados. Esta receita vai te ensinar como fazer isso.
Preparando-se
A fim de criar a conexão, você precisa saber as configurações de conexão. Pelo menos você vai precisar do seguinte:
f número da porta: A porta que o banco de dados conecta. Cada banco de dados tem seu próprio padrão
porta.
É recomendado que você também tem acesso ao banco de dados no momento da criação de uma conexão.
9
Trabalhando com bancos de dados
1. Selecione o Visão opção que aparece no canto superior esquerdo da tela, clique com o botão direito
no conexões de banco de dados opção, e selecione Novo. o Conexão de banco de dados
janela de diálogo aparece.
2. Em Tipo de conexão, selecionar o mecanismo de banco de dados que corresponda às suas DBMS.
4. Pressione o Teste botão. Deverá aparecer uma mensagem informando que a conexão com
seu banco de dados é OK.
Se você receber uma mensagem de erro em vez disso, você deve verificar novamente os dados
inseridos, bem como a disponibilidade do servidor de banco de dados. O servidor pode ser para
10
Capítulo 1
Como funciona...
A conexão com o banco é a definição que lhe permite aceder a uma base de dados de Kettle. Com os dados que você fornecer,
Chaleira pode instanciar conexões de banco de dados real e executar as diferentes operações relacionadas a bancos de dados. Uma
vez que você definir uma conexão de banco de dados, você será capaz de acessar esse banco de dados e executar instruções SQL
arbitrárias: criar objetos de esquema como tabelas, execute SELECIONAR declarações, modificar linhas, e assim por diante. Nesta receita
você criou a conexão do conexões de banco de dados árvore. Você também pode criar uma ligação pressionando o Novo... botão no Configuração
janela de qualquer etapa relacionada com o banco de dados em uma entrada de transformação ou trabalho em um trabalho. Em
alternativa, há também um assistente acessível a partir da Ferramentas menu ou pressionando o F3 chave. Independentemente do
método escolhido, a Definições janela, como o que você viu na receita, mostra-se, permitindo-lhe definir a conexão. Esta tarefa inclui o
seguinte:
Native (JDBC) é o método de acesso recomendado, mas você também pode usar uma
fonte pré-definida de dados ODBC, uma fonte de dados JNDI ou uma conexão com o
Oracle OCI.
f Entrando no nome de usuário e senha para acessar a conexão do banco de dados do banco de dados Um só pode ser criado com
uma transformação ou um trabalho aberto. Portanto, a receita que você foram convidados para criar uma transformação. O mesmo
Tem mais...
A receita mostrou a maneira mais simples de criar uma conexão de banco de dados. No entanto, há mais para saber sobre criação de
conexões de banco de dados.
11
Trabalhando com bancos de dados
Se você pretende usar o mesmo banco de dados em mais de uma transformação e / ou trabalho, é recomendável que você compartilhe
a conexão. Você pode fazer isso clicando com o botão direito sobre a conexão com o banco sob o conexões de banco de dados árvore e
clicando em Compartilhar. Desta forma, a conexão de banco de dados estará disponível para ser usado em todas as transformações e
empregos. conexões de banco de dados compartilhado são reconhecidos porque eles aparecem em negrito. Como um exemplo, dê uma
olhada na imagem seguinte exemplo:
as bases de dados livros e dados de amostra são compartilhadas; os outros não são. As informações sobre conexões
12
Capítulo 1
Não importa o que Chaleira armazenamento método é usado (repositório ou arquivos), você pode compartilhar conexões. Se você está
trabalhando com o método de arquivo, ou seja, ktr e kjb arquivos, as informações sobre conexões compartilhadas não são apenas salvos no shared.xml
arquivo, mas também salva como parte da transformação ou trabalho arquivos, mesmo se eles não usam as conexões.
Você pode evitar salvar todos os dados de conexão como parte dos seus
transformações e postos de trabalho selecionando a opção salvar apenas conexões
usadas para XML? no opções de chaleira janela sob ferramentas | Opções.
Evitando modificação das tarefas e transformações cada vez que uma conexão
mudanças
Em vez de digitar valores fixos na definição de conexão de banco de dados, vale a pena usar variáveis. Variáveis viver em
qualquer um dos dois lugares: na kettle.properties arquivo, que vive no diretório home Chaleira, ou dentro da transformação ou
trabalho como um parâmetro nomeado. Por exemplo, em vez de digitar localhost como o nome do host, você pode definir uma
variável chamada NOME DE ANFITRIÃO,
e, como o nome do host, digite a sua notação variável como $ { NOME DE ANFITRIÃO} ou %% NOME DE ANFITRIÃO%%.
Se você decidir mover o banco de dados da máquina local para um servidor, você só tem que mudar o valor da
variável e não precisa modificar as transformações ou trabalhos que usam a conexão.
Isto é especialmente útil quando é hora de mover seus empregos e transformações entre diferentes ambientes:
desenvolvimento, teste e assim por diante.
13
Trabalhando com bancos de dados
tipo. No Definições quadro, especifique a seqüência de conexão (que deve ser explicado juntamente com JDBC), o nome da
classe do driver, e o nome de usuário e senha. A fim de encontrar os valores para essas configurações, você terá que
consultar a documentação do driver.
Se você não tem certeza de que a conexão de banco de dados será acessível quando um trabalho ou transformação vai de Colher de fora,
você pode preceder todas as operações de banco de dados relacionados com uma entrada de trabalho Verifique a ligação do DB. A entrada
irá retornar verdade ou falso dependendo do resultado da verificação de uma ou mais conexões.
Se você está acostumado a trabalhar com bancos de dados, um de seus principais objetivos enquanto estiver trabalhando com PDI deve ser
obtenção de dados de seus bancos de dados para transformar, carregar em outros bancos de dados, geração de relatórios, e assim por diante.
Qualquer que seja a operação que pretende alcançar, a primeira coisa que você tem que fazer depois de se conectar ao banco de dados é
conseguir que os dados e criar um conjunto de dados PDI. Nesta receita, você vai aprender a maneira mais simples de fazer isso.
Preparando-se
Para seguir estas instruções, você precisa ter acesso a qualquer DBMS. Muitas das receitas neste capítulo irá se
conectar a uma instância MySQL. Recomenda-se que para tirar o máximo partido do código do livro, (que pode ser
encontrada no site do livro), você tem acesso a uma instância MySQL.
1. Crie uma transformação e soltar um Entrada Tabela passo para a tela. Você vai encontrá-lo em
a Entrada categoria de passos.
2. A partir do Conexão drop-down list, selecione a conexão com o banco de dados onde
seus dados reside, ou criá-lo se ele não existe.
14
Capítulo 1
3. No SQL textarea, digite a instrução SQL que retorna os dados que você precisa. Até agora, você deve ter algo
parecido com o seguinte:
4. Clique em Preview. Isto trará uma lista de amostras de linhas para que você possa confirmar que os dados
é como esperado.
5. Clique em Está bem para fechar a Entrada Tabela janela de configuração, e você estará pronto para usar
os dados para posterior manipulação.
Como funciona...
o Entrada Tabela passo que você usado na receita é o principal passo Chaleira para obter dados de um banco de dados. Quando
você executa ou pré-visualizar a transformação, Chaleira executa o SQL e empurra as linhas de dados provenientes da base de
dados para a corrente da etapa de saída. Cada coluna da instrução SQL leva a um campo de PDI e cada linha gerada pela
execução da instrução torna-se uma linha no conjunto de dados PDI.
Depois de obter os dados do banco de dados, ele estará disponível para qualquer tipo de manipulação no interior da
transformação.
15
Trabalhando com bancos de dados
Tem mais...
A fim de economizar tempo, ou no caso de você não tem certeza do nome das tabelas ou colunas no banco de dados, em vez de
digitar a instrução SQL, clique no Obter SQL select ... botão. Isso fará com que o Database Explorer janela. Esta janela permite-lhe
explorar o banco de dados selecionado. Ao expandir a árvore do banco de dados e selecionando a tabela que lhe interessa, você
será capaz de explorar essa tabela através das diferentes opções disponíveis no âmbito do Ações cardápio. Duplo clique sobre o
nome da tabela irá gerar uma SELECIONAR declaração para consultar essa tabela. Você terá a chance de incluir todos os nomes
de campo na declaração, ou simplesmente gerar uma SELECT * declaração. Depois de trazer o SQL ao Entrada Tabela janela de
configuração, você será capaz de modificá-lo de acordo com suas necessidades.
Veja também
f Obtendo dados de um banco de dados executando uma consulta construída em tempo de execução
Suponha que você precisa listar todos os produtos Steel Wheels para uma determinada linha de produtos e escala.
Preparando-se
16
Capítulo 1
2. Antes de obter os dados do banco de dados, você tem que criar o fluxo que irá fornecer os parâmetros
para a declaração.
3. Criar um fluxo que constrói um conjunto de dados com uma única linha e duas colunas: o parâmetro da linha de produtos e o
parâmetro de escala. Para este exercício, vamos estar usando um Grade de dados passo, mas outras medidas como a gerar
linhas etapa também irá funcionar. abrindo a
Grade de dados etapa, adicione o productline_par e productscale_par linhas para o
meta aba. Ambos devem ser do tipo Corda:
4. Mude para o Dados aba. Observe como os campos criados no meta guia construir o
para linha de dados a ser adicionado. Criar um registro com Carros clássicos como o valor para
productline_par e 01:10 como o valor para productscale_par:
5. Agora arraste um Entrada Tabela passo para a tela e criar um hop do Grade de dados degrau,
que foi criado anteriormente, em relação a este passo.
17
Trabalhando com bancos de dados
6. Agora você pode configurar o Entrada Tabela degrau. Dê um duplo clique sobre ele, selecione a conexão
ao banco de dados e digite a seguinte declaração:
productline SELECIONAR
, PRODUCTSCALE
, CÓDIGO DO PRODUTO
, PRODUCTNAME DE
PRODUTOS p ONDE productline =? E
PRODUCTSCALE =?
7. No Inserir dados a partir da etapa lista, selecione o nome da etapa que está ligada à
Entrada Tabela degrau. Feche a janela.
8. Selecione o Entrada Tabela passo e fazer uma pré-visualização da transformação. Você verá uma lista de
todos os produtos que correspondem a linha de produtos e escala fornecido no fluxo de entrada:
Como funciona...
Quando você precisa para executar um SELECIONAR declaração com parâmetros, a primeira coisa que você tem a fazer é construir um
fluxo que fornece os valores dos parâmetros necessários para a declaração. O fluxo pode ser feita de apenas um passo; por exemplo,
uma grade de dados com valores fixos, ou um fluxo constituído por vários passos. O importante é que o último passo fornece os valores
apropriados para o
Entrada Tabela degrau.
Então, você tem que ligar o último passo no fluxo para o Entrada Tabela passo onde você irá digitar o comunicado. O que
diferencia esta declaração de uma instrução regular é que você tem que fornecer pontos de interrogação. Quando você
visualizar ou executar a transformação, a afirmação é preparado e os valores chegando ao Entrada Tabela passo est ligados
aos marcadores de posição; isto é, o lugar onde você digitou os pontos de interrogação.
18
Capítulo 1
Note-se que na receita a saída do fluxo foi uma única linha com dois campos, que é exatamente o mesmo número de
pontos de interrogação como no comunicado.
O número de campos de chegar a uma Entrada Tabela passo deve ser exatamente o
mesmo que o número de pontos de interrogação encontrados na consulta.
De referir ainda que no fluxo, a linha de produtos foi, em primeiro lugar e a escala do produto no segundo lugar. Se você
olhar para as linhas destacadas na receita, você vai ver que a declaração esperava que os valores dos parâmetros para
ser exatamente nessa ordem.
Todos os valores que são utilizados desta maneira são consumidos pela Entrada
ser usado para parametrizar expressões de valor, tal como fez na receita.
Se você precisa para parametrizar algo diferente a partir de uma expressão de valor, você deve tomar uma outra abordagem,
como explicado na próxima receita.
Tem mais...
19
Trabalhando com bancos de dados
A declaração teria puxado os valores para os dois parâmetros do fluxo de entrada na mesma ordem que os dados
apareceu. Ele teria obrigado o primeiro ponto de interrogação com o valor na primeira linha, eo segundo ponto de
interrogação com o valor chegando na segunda fila. Note-se que esta abordagem é menos flexível que o anterior. Por
exemplo, se você tem que fornecer valores para parâmetros com diferentes tipos de dados, você não será capaz de
colocá-los na mesma coluna e linhas diferentes.
Em seguida, no Entrada Tabela janela de configuração que você tem que verificar o Executar para cada linha? opção. Desta forma, a
declaração será preparado e os valores chegando ao Entrada Tabela passo será ligado aos espaços reservados, uma vez para cada
linha no conjunto de dados vindo para a etapa. Para este exemplo, o resultado seria parecido com o seguinte:
Veja também
f Obtendo dados de um banco de dados executando uma consulta construída em tempo de execução
20
Capítulo 1
tempo de execução
Quando você trabalha com bancos de dados, na maioria das vezes você começar escrevendo uma instrução SQL que obtém os
dados que você precisa. No entanto, existem situações em que você não conhece essa afirmação exatamente. Talvez o nome das
colunas para consulta estão em um arquivo, ou o nome das colunas pelo qual você irá classificar virá como um parâmetro de fora da
transformação, ou o nome da tabela principal para consultar muda de acordo com os dados armazenados na lo (por exemplo sales2010).
PDI permite que você tenha qualquer parte da instrução SQL como uma variável, para que você não precisa saber o texto da instrução SQL
literal em tempo de design.
Suponha a seguinte situação: você tem um banco de dados com dados sobre livros e seus autores, e você quer gerar um arquivo
com uma lista de títulos. Se para recuperar os dados ordenados por título ou por gênero é uma escolha que você quer adiar até o
momento em que você executar a transformação.
Preparando-se
Você vai precisar de um banco de dados livro com a estrutura, como explicado no Apêndice A, Estruturas de Dados.
3. Agora arraste um Entrada Tabela passo para a tela. Em seguida, crie e selecione a conexão
ao banco de dados do livro.
a transformação, e executá-lo.
7. Abra o arquivo gerado e você vai ver os livros ordenados por título.
8. Agora tente novamente. aperte o F9 chave para executar a transformação mais uma vez.
21
Trabalhando com bancos de dados
11. Abra o arquivo gerado. Desta vez você vai ver os títulos ordenados por gênero.
Como funciona...
Você pode usar variáveis Chaleira em qualquer parte do SELECIONAR declaração dentro de um Entrada Tabela degrau. Quando a
transformação é inicializado, PDI substitui as variáveis por seus valores, desde que a Substitua as variáveis em script? opção estiver
marcada.
Na receita, a primeira vez que você executou a transformação, Chaleira substituído a variável
ORDER_COLUMN com a palavra título ea instrução executada foi a seguinte:
Na segunda vez, a variável foi substituída pela gênero ea instrução executada foi a seguinte:
Como mencionado na receita, qualquer variável Chaleira predefinido pode ser usado em vez
de um parâmetro nomeado.
Tem mais...
Você pode usar variáveis não só para o ORDENAR POR cláusula, mas em qualquer parte da declaração: nomes de tabelas, colunas e assim
por diante. Você poderia até mesmo realizar a declaração completa em uma variável. Note, porém, que você precisa ser cauteloso na
aplicação da presente.
Você também pode usar a mesma variável mais de uma vez na mesma instrução. Esta é uma vantagem do uso de variáveis como
uma alternativa para pontos de interrogação quando você precisa executar parametrizado SELECIONAR afirmações.
Parâmetros nomeados são outra opção para armazenar peças de declarações. Eles são parte do trabalho ou de transformação e permitir a
valores padrão e definições claras para que o parâmetro é. Para adicionar ou editar parâmetros nomeados, clique com o botão direito
sobre a transformação ou trabalho, entrar em suas configurações, e mudar para o parâmetros aba.
Veja também
22
Capítulo 1
PDI tem várias etapas que permitem realizar estas operações. Nesta receita você vai aprender a usar o Insert / Update degrau.
Antes de inserir ou atualizar linhas em uma tabela usando este passo, é fundamental que você sabe qual campo ou
campos na tabela identificar uma linha na tabela.
Se você não tem uma maneira para identificar exclusivamente os registros, você
deve considerar outros passos, como explicado no
Tem mais... seção.
Assumir esta situação: você tem um arquivo com os novos funcionários de Steel Wheels. Você tem que inserir os funcionários no
banco de dados. O arquivo também contém os funcionários antigos que foram alterados ou o escritório onde trabalham, o número do
ramal, ou outras informações básicas. Você vai aproveitar a oportunidade para atualizar essa informação também.
Preparando-se
Faça o download do material para a receita da página do livro. Dê uma olhada no arquivo que você irá usar:
Explorar o banco de dados Steel Wheels, em particular a funcionários mesa, para que você saiba o que você tem antes de
executar a transformação. Execute a seguinte instrução MySQL:
SELECIONAR
EmployeeNumber ENUM
, EXT EXTENSÃO
, OFFICECODE OFF
, Supervisor Repto
, JobTitle DE
FUNCIONÁRIOS
23
Trabalhando com bancos de dados
+- - - - - - +- - - - - - - - - - - - - - - - +- - - - - - - +- - - - - +- - - - - - - +- - - - - - - - - - - +
+- - - - - - +- - - - - - - - - - - - - - - - +- - - - - - - +- - - - - +- - - - - - - +- - - - - - - - - - - +
| 1188 | Julie Firrelli | x2173 | 2 | 1143 | Representante de Vendas | | 1619 | Tom king
+- - - - - - +- - - - - - - - - - - - - - - - +- - - - - - - +- - - - - +- - - - - - - +- - - - - - - - - - - +
1. Crie uma transformação e usar um entrada de arquivo de texto passo para ler o arquivo funcionários.
TXT. Fornecer o nome ea localização do arquivo, especifique vírgula como separador, e preencher o Campos grade.
2. Agora, você vai fazer as inserções e atualizações com um Insert / Update degrau. Então, expanda o
Saída categoria de passos, procure o Insert / Update passo, arraste-o para a tela, e criar uma hop do Arquivo
de texto passo de entrada para este.
3. Dê um duplo clique sobre o Insert / Update passo e selecione a conexão com o aço
banco de dados de rodas, ou criá-lo se ele não existe. Como tabela de destino, tipo Funcionários.
24
Capítulo 1
+- - - - - - +- - - - - - - - - - - - - - - +- - - - - - - +- - - - - +- - - - - - - +- - - - - - - - - - - - - - +
+- - - - - - +- - - - - - - - - - - - - - - +- - - - - - - +- - - - - +- - - - - - - +- - - - - - - - - - - - - - +
| 1188 | Julie Firrelli | x2174 | 2 | 1143 | Gerente de Vendas | | 1619 | Tom king
+- - - - - - +- - - - - - - - - - - - - - - +- - - - - - - +- - - - - +- - - - - - - +- - - - - - - - - - - - - - +
Como funciona...
o Insert / Update passo, como o próprio nome indica, serve para ambas as linhas inserir ou atualizar. Para cada linha em sua corrente,
Chaleira procura uma linha na tabela que coincide com a condição de que você colocar na grade superior da grade rotulada A chave (s) para
procurar o valor (s) :. Tomemos por exemplo a última linha no seu arquivo de entrada:
Quando esta linha vem ao Insert / Update etapa, Chaleira procura por uma linha onde
NÚMERO DE EMPREGADO é igual a 1811. Quando ele não encontrar um, ele insere uma linha seguindo as instruções que você
colocar na grade inferior. Para esta linha de amostra, o equivalente INSERIR declaração seria a seguinte:
25
Trabalhando com bancos de dados
Quando Chaleira procura por uma linha com NÚMERO DE EMPREGADO igual a 1188, ele encontra-lo. Em seguida, ele atualiza essa linha de
acordo com o que você colocar na grade inferior. Ele só atualiza as colunas onde você coloca Y debaixo de Atualizar coluna. Para esta linha
de amostra, o equivalente ATUALIZAR declaração seria a seguinte:
Note que o nome deste empregado no arquivo ( Julianne) é diferente do nome na tabela ( Julie), mas, como você
colocá N sob a coluna Atualizar para o campo PRIMEIRO NOME, esta coluna não foi atualizado.
Se você executar a transformação com o nível de log Detalhado, no log você será
capaz de ver as declarações preparadas reais que Chaleira realiza ao inserir ou
atualizar linhas em uma tabela.
Tem mais...
etapa tem o mesmo nome que as colunas na tabela, você está feito. Se não, você deve verificar o Especificar campos de banco de dados opção
e preencher o campos de banco de dados guia exatamente como você preencheu a grade inferior no Insert / Update etapa, exceto que
aqui não existe Atualizar coluna.
26
Capítulo 1
Você pode substituir o Insert / Update passo por um saída de mesa passo e, como o fluxo de tratamento de erros que sai do saída
de mesa etapa, colocar um Atualizar degrau.
Como alternativa, clique com o botão direito sobre o saída de mesa etapa, selecione Definir o tratamento de erros ..., e configurar o configurações
de tratamento de erros passo janela que aparece. Sua transformação seria parecido com o seguinte:
No saída de mesa passo, selecione a tabela FUNCIONÁRIOS, Verifica a Especificar campos de banco de dados
opção e preencher o campos de banco de dados guia apenas como você preencheu a grade inferior no Insert / Update
etapa, exceto que aqui não existe Atualizar coluna. No Atualizar passo, selecione a mesma mesa e encher a parte superior da
grade-vamos chamá-lo os campos-chave grade assim como você encheu o campos-chave grade no Insert / Update degrau.
Finalmente, preencher a grade inferior com os campos que você deseja atualizar, ou seja, as linhas que tiveram Y debaixo de
Atualizar coluna.
Neste caso, Chaleira tenta inserir todos os registros de vir para o saída de mesa degrau. As linhas para as quais a inserção falha
ir para a Atualizar passo, e ficar atualizado. Se as colunas na campos-chave grade do Insert / Update etapa não são uma chave
única na base de dados, esta abordagem alternativa não funciona. o saída de mesa iria inserir todas as linhas. Aqueles que já
existia seria duplicado em vez de ficar atualizado. Esta estratégia para a realização de inserções e atualizações tem sido
provado ser muito mais rápido do que o uso do Insert / Update passo sempre que a relação das alterações de inserções é baixo.
Em geral, para melhores razões prática, isso não é uma solução aconselhável.
27
Trabalhando com bancos de dados
Veja também
f Inserir novas linhas onde uma chave primária simples tem de ser gerado
f Inserir novas linhas onde a chave primária tem de ser gerado com base nos valores armazenados
sequência de base de dados (naqueles SGBD que têm essa característica, por exemplo, Oracle) ou simplesmente por adição de um
para o valor máximo em a mesa. Carregando dados nessas tabelas é muito simples. Esta receita ensina como fazer isso através do
seguinte exercício. Há novos escritórios em Steel Wheels. Você tem os dados dos escritórios em um arquivo que se parece com o
seguinte:
Preparando-se
Para esta receita, você vai usar a base de dados exemplo Pentaho. Se você não tem esse banco de dados, você terá que
seguir as instruções na introdução deste capítulo.
Como você vai inserir registros na tabela do escritório, que seria bom se você explorar essa tabela antes de fazer quaisquer operações de
inserção. A seguir está uma consulta de exemplo:
SELECIONAR
OFFICECODE
, ENDEREÇO LINHA 1
, CIDADE
, PAÍS DE ESCRITÓRIOS
ORDER BY OFFICECODE;
28
Capítulo 1
+- - - - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - - - - - - - - - +- - - - - - - - - - - +
+- - - - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - - - - - - - - - +- - - - - - - - - - - +
+- - - - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - - - - - - - - - +- - - - - - - - - - - +
1. Crie uma transformação e criar uma conexão com o dados de amostra base de dados.
2. Use um entrada de arquivo de texto para ler a offices.txt arquivo com dados sobre os novos escritórios.
4. Dê um clique duplo na etapa, selecione a conexão com o dados de amostra banco de dados e
tipo escritórios Enquanto o tabela de destino.
6. No chave técnico tipo de campo OFFICECODE. Para o Criação de chave técnico campos, deixe os valores
padrão. Feche a janela.
8. Dê um clique duplo na etapa, selecione a conexão com o dados de amostra banco de dados e
tipo ESCRITÓRIOS Enquanto o tabela de destino.
9. Na primeira grade, adicionar linhas com o texto OFFICECODE ambos sob campo da tabela e abaixo
Transmitir campo1. Como Comparador escolher =. Dessa forma, você irá atualizar as linhas onde
OFFICECODE é igual ao código de escritório em seu fluxo.
10. Na grade inferior, adicionar uma linha e tipo TELEFONE ambos sob campo da tabela e campo de fluxo.
Adicionar uma segunda linha e digite CÓDIGO POSTAL em ambas as colunas.
29
Trabalhando com bancos de dados
13. Como você pode imaginar, três novos escritórios foram adicionados, com chaves primárias 8, 9,
e 10. Os resultados são os seguintes:
SELECIONAR
OFFICECODE
, ENDEREÇO LINHA 1
, CIDADE
, PAÍS DE
ESCRITÓRIOS
+- - - - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - - - - - - - - - +- - - - - - - - - - - +
+- - - - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - - - - - - - - - +- - - - - - - - - - - +
+- - - - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - - - - - - - - - +- - - - - - - - - - - +
Como funciona...
Em muitas situações, antes de inserir dados em uma tabela que você tem para gerar a chave primária. Se a chave primária é
uma sequência simples ou a chave primária máximo mais um, você pode gerá-lo usando um lookup Combinação / atualização degrau.
Na receita, para cada linha em seu arquivo, com o lookup Combinação / atualização etapa, você olha para um registro na escritórios
30
Capítulo 1
Porque os escritórios são novos, (não há escritórios na tabela com a mesma combinação de
endereço, cidade, e país valores) a pesquisa falhar. Como consequência, o passo gera um valor de chave como o máximo OFFICECODE na
tabela, além de 1. Em seguida, ele insere uma linha com a chave primária gerada e os campos que você digitou na grade.
Finalmente, a etapa adiciona o valor da chave primária gerado para o fluxo. Como última tarefa, usamos essa chave para atualizar
e TELEFONE.
Tem mais...
o lookup Combinação / atualização passo está dentro do Armazém de dados categoria, porque é utilizado principalmente para o
carregamento tabelas de dimensões lixo. Mas, como você pode ver, ele também pode ser usado na situação particular em que você tem
que gerar uma chave primária. Nesta receita gerada a chave primária como o plus máxima 1, mas, como você pode ver na janela de
configurações, uma seqüência de banco de dados também pode ser usado em seu lugar.
Quando você usa o lookup Combinação / atualização passo para inserir, certifique-se de que
as colunas que não fazem parte da lista de campos de chave são anulável ou ter valores
padrão.
Note-se que este é um passo potencialmente lento, uma vez que utiliza todos os valores
para a comparação.
Veja também
f Inserir novas linhas onde a chave primária tem de ser gerado com base nos valores armazenados
31
Trabalhando com bancos de dados
Suponha que você tem que carregar os dados do autor para o o livro de base de dados. Você tem os principais dados para os
autores, e você tem que gerar a chave primária como no exemplo anterior.
Preparando-se
Execute o script que cria e carrega dados para o livros base de dados. Você vai encontrá-lo em
http://packtpub.com/support. Se exemplo anterior do livro a partir deste capítulo foi executado, os dados do banco de
dados e autor já deveria ter sido criado. Antes de prosseguir, verifique os valores atuais para as chaves primárias
na tabela onde você irá inserir os dados:
autores;
+- - - - - - - - - - - - - - - - +
| MAX (id_author) |
+- - - - - - - - - - - - - - - - +
| A00009 |
+- - - - - - - - - - - - - - - - +
Execute as seguintes etapas para gerar chaves para registros de dados inseridos:
32
Capítulo 1
3. Para gerar o próximo chave primária, você precisa saber o máximo atual. Então, use um Entrada Tabela passo
para obtê-lo. Neste caso, a seguinte instrução irá dar-lhe esse número:
SELECIONAR
4. Usando um Junte-se a linhas (produto cartesiano) passo, juntar ambos os fluxos. Seu
transformação deve parecer com o seguinte:
5. Adicione uma Adicionar seqüência degrau. Substitua o valor padrão ValueName com
delta_value. Para o resto dos campos na janela de configuração, deixe os valores padrão.
6. Adicione uma Calculadora passo para construir as chaves. Você fazê-lo preenchendo a janela de configuração
como mostrado:
7. A fim de inserir as linhas, adicione um saída da tabela passo, clique duas vezes sobre ele e selecione a conexão com o livros base
de dados.
33
Trabalhando com bancos de dados
10. Selecione o campos de banco de dados aba e preencher a grade da seguinte forma:
+- - - - - - - - - - +- - - - - - - - - - - +- - - - - - - - - - - - - +- - - - - - - - - - - +- - - - - - - - - - +
+- - - - - - - - - - +- - - - - - - - - - - +- - - - - - - - - - - - - +- - - - - - - - - - - +- - - - - - - - - - +
+- - - - - - - - - - +- - - - - - - - - - - +- - - - - - - - - - - - - +- - - - - - - - - - - +- - - - - - - - - - +
Como funciona...
Quando você tem que gerar uma chave primária com base nas chaves primárias existentes, não há nenhuma maneira direta para
fazê-lo em Kettle, a menos que a nova chave primária é simples para gerar adicionando um para o máximo. Uma possível solução é
a mostrada na-receita recebendo a última chave primária na tabela, combinando-a com o seu rio principal, e usando essas duas
fontes para gerar as novas chaves primárias. Esta é a forma como ele trabalhou neste exemplo.
34
Capítulo 1
Primeiro, usando um Entrada Tabela etapa, você descobriu a última chave primária na tabela. Na verdade, você tem apenas a parte
numérica necessário para construir a nova chave. Neste exercício, o valor foi 9.
Com o Junte-se a linhas (produto cartesiano) etapa, você adicionou esse valor como uma nova coluna em sua corrente principal.
Tomando esse número como um ponto de partida, você necessário para construir as novas chaves primárias como A00010, A00011, e
assim por diante. Fizer por gerar uma sequência ( 1, 2, 3, e assim por diante), adicionar esta sequência à max_id ( que levou a valores 10,
11, 12, e assim por diante), e, finalmente, a formatação da chave com o uso da calculadora. Note que, no Calculadora passo, o
max_id com o delta_value seqüência. Em seguida, ele converte o resultado para uma Corda dando-lhe o formato com a
máscara 0000. Isto levou aos valores 00010, 00011, e assim por diante. O segundo A + B é uma concatenação. Ele
Note-se que esta abordagem funciona, desde que você tem um cenário de usuário único. Se você executar várias instâncias da
transformação, eles podem escolher o mesmo valor máximo e tentar inserir linhas com o mesmo PK levando a uma violação de
restrição de chave primária.
Tem mais...
A chave para este exercício é fazer com que o último ou máxima de chave primária na tabela, juntá-lo ao seu fluxo principal, e usar
esses dados para construir a nova chave. Após a junção, o mecanismo para a construção da chave final vai depender de seu caso
particular.
Veja também
f Inserir novas linhas onde uma chave primária simples tem de ser gerado
Ou
Você poderia simplesmente executá-lo usando um SQL entrada de trabalho ou um Executar o script SQL degrau. Se você enfrentar a segunda
das situações acima, você ainda pode usar uma truncar a tabela entrada de trabalho.
35
Trabalhando com bancos de dados
Para situações mais complexas, você deve usar o Excluir degrau. Vamos supor a seguinte situação: você tem um banco de dados
com produtos ao ar livre. Cada produto pertence a uma categoria: ferramentas, barracas, sacos de dormir, e assim por diante. Agora
você deseja excluir todos os produtos de uma determinada lista de categorias, onde o preço é menor ou igual a $ 50.
Preparando-se
A fim de seguir a receita, você deve baixar o material para este capítulo: um script para criar e carregar o banco de dados e
um arquivo do Excel com a lista de categorias envolvidas. Depois de criar o banco de dados ao ar livre e carregamento de
dados, executando o script fornecido, explorar a base de dados antes de seguir a receita. Em particular, executar a seguinte
declaração:
Selecione a Categoria
PARTIR produtos de p
GROUP BY p.id_category;
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
| categoria | quantidade |
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
| cozinha | 19 |
| luzes | 14 |
| sacos de dormir | 5|
| tendas | 4|
| Ferramentas | 8|
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
Selecione a Categoria
PARTIR produtos de p
preço> 50
GROUP BY p.id_category;
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
| categoria | quantidade |
36
Capítulo 1
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
| cozinha | 5|
| luzes | 1|
| sacos de dormir | 1|
| tendas | 8|
| Ferramentas | 2|
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
2. O valor para o qual você vai comparar o preço antes de apagar será armazenado como um
nomeado parâmetro. Então, clique com o botão direito dentro da transformação e selecione configurações de transformação. Mudar
para o parâmetros guia e criar um parâmetro chamado MAX_PRICE.
Defina o valor padrão para 50.
3. Arraste a uma tela Entrada Excel passo para ler o arquivo Excel com a lista de categorias.
4. Arraste para a tela uma obter Variáveis passo para obter a variável nomeado como um campo chamado
MAX_PRICE com o tipo Número.
5. Depois disso, adicionar um pesquisa de banco de dados degrau. Configurá-lo para obter o id_category Campos
com base nas descrições de categoria no arquivo Excel. Até agora, a transformação parece com o seguinte:
Para volumes maiores, é melhor para obter a variável apenas uma vez em um fluxo
separado e se juntar as duas correntes com um Junte-se a linhas (produto cartesiano) degrau.
37
Trabalhando com bancos de dados
6. Selecione o pesquisa de banco de dados passo e fazer uma pré-visualização. Você deve ver o seguinte:
7. Finalmente, adicione uma Excluir degrau. Você vai encontrá-lo sob o Saída categoria de passos.
10. Explorar o banco de dados. Se você executar as mesmas instruções que você executou antes de iniciar a receita, você vai
notar que todos os produtos pertencentes às categorias no arquivo Excel com preço igual ou inferior a US $ 50 foram
excluídos. O seguinte é o que você vai ver:
Selecione a Categoria
PARTIR produtos de p
GROUP BY p.id_category;
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
| categoria | quantidade |
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
| cozinha | 19 |
| luzes | 14 |
| sacos de dormir | 5|
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
38
Capítulo 1
Selecione a Categoria
PARTIR produtos de p
preço> 50
GROUP BY p.id_category;
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
| categoria | quantidade |
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
| cozinha | 5|
| luzes | 1|
| sacos de dormir | 1|
| tendas | 8|
| Ferramentas | 2|
+- - - - - - - - - - - - - - - +- - - - - - - - - - +
Como funciona...
o Excluir etapa permite excluir linhas em uma tabela em um banco de dados com base em certas condições. Neste caso, você
pretende excluir linhas da tabela produtos onde o preço foi inferior ou igual a 50, e a categoria estava em uma lista de
categorias, de modo que o Excluir passo é a escolha certa. É assim que funciona: PDI constrói uma declaração preparada para
o EXCLUIR Operação. Então, para cada linha em sua corrente, PDI liga os valores da linha para as variáveis na declaração
preparada. Vamos vê-lo pelo exemplo. Na transformação que você construiu um fluxo onde cada linha teve uma única
categoria eo valor para o preço. Se você executar a transformação com o nível de log Detalhado e olhar para o log, você vai ver
o ONDE cláusula é construída com base nas condições inseridos no excluir configuração
janela. Para cada linha, os valores dos campos que você digitou na grid- MAX_PRICE e
id_category -são ligados aos pontos de interrogação na declaração preparada.
39
Trabalhando com bancos de dados
Note-se que as condições no Excluir etapa são baseados em campos na mesma tabela. Neste caso, como você foram fornecidos
com descrições de categoria eo produtos tabela que não tem as descrições, mas o ID para as categorias, você tinha que usar um
passo extra para obter esse ID-uma pesquisa de banco de dados.
Suponha que a primeira linha no arquivo de Excel teve o valor tendas. Como o ID da categoria
tendas é 4, a execução da declaração preparada com os valores nesta linha tem o mesmo efeito que a execução
da instrução SQL a seguir:
Veja também
fo Procurando por valores em uma tabela de banco de dados receita em Capítulo 6, à procura de dados
f Você recebe um arquivo simples e tem que carregar todo o conteúdo em uma tabela temporária
f Você tem que criar e carregar uma tabela de dimensão com dados provenientes de outro banco de dados que você poderia
escrever um CRIAR A TABELA declaração a partir do zero e, em seguida, criar a transformação que carrega a mesa, ou você pode
fazer tudo isso de uma forma mais fácil de colher. Neste caso, suponha que você recebeu um arquivo com dados sobre países e as
línguas faladas nesses países. Você precisa carregar o conteúdo completo em uma tabela temporária. A tabela não existe e você
Preparando-se
Para seguir as instruções, você vai precisar do countries.xml arquivo disponível para download a partir do
site do livro.
Execute os seguintes passos para criar ou alterar uma tabela de banco de dados:
1. Crie uma transformação e criar uma conexão com o banco de dados onde você vai guardar os dados.
40
Capítulo 1
2. Para ler o countries.xml arquivo, use um Obter dados de XML degrau. Como circuito XPath tipo / mundo
/ país / idioma.
4. A partir do Saída categoria, arrastar e soltar uma saída de mesa passo para a transformação.
5. Criar um hop do Obter dados de XML passo para esta nova etapa.
6. Dê um duplo clique sobre o saída de mesa passo e selecione a conexão que você acabou de criar.
8. Clique no SQL botão. Uma janela será exibida com o seguinte script:
país TINYTEXT
, TINYTEXT de capital
, TINYTEXT idioma
, TINYTEXT isofficial
);
9. Porque você sabe que isofficial é apenas uma bandeira simples com valores Y / N, substituir
TINYTEXT isofficial com isofficial CHAR (1).
10. Depois de clicar no Executar, uma janela vai aparecer dizendo que a declaração foi
executado, ou seja, a tabela foi criada.
11. Salvar e executar a transformação. Toda a informação que vem do arquivo XML é salvo na tabela
recém-criada.
41
Trabalhando com bancos de dados
Como funciona...
PDI permite criar ou alterar tabelas em seus bancos de dados, dependendo das tarefas implementadas em suas
transformações ou empregos. Para entender do que se trata, vamos explicar o exemplo anterior. UMA saída de mesa passo
provoca Kettle para executar um INSERIR declaração contra o banco de dados. A inserção é feita com base nos dados
provenientes da saída de mesa e os dados que você colocar no saída de mesa janela de configuração, por exemplo, o nome
da tabela ou o mapeamento dos campos.
Quando você clica no SQL botão no definição de saída Tabela janela, isso é o que acontece: Chaleira constrói as
instruções necessárias para executar esse inserção com sucesso. Como neste exemplo, a tabela não existe e,
portanto, a declaração gerado clicando no botão é um
CRIAR A TABELA declaração.
Quando a janela com a declaração gerada apareceu, você executou. Isto causou a tabela a ser criada, para que você
possa executar com segurança a transformação e inserir na nova tabela os dados provenientes do arquivo para a etapa.
Tem mais...
o SQL botão está presente em várias etapas relacionadas com o banco de dados. Em todos os casos, o seu objectivo é o
mesmo: para determinar as instruções a serem executadas, a fim de executar a transformação com sucesso. Na receita, a
declaração foi uma CRIAR A TABELA, mas há outras situações. Seguem-se alguns exemplos:
f Se você usar um Insert / Update passo e preencha o Atualizar campos: grade com um campo que
não existe, gera uma chaleira ALTERAR A TABELA declaração, a fim de adicionar esse campo como uma nova coluna
na tabela.
f Se você usar um Atualizar passo e usar os nomes de colunas que não são indexados
no A chave (s) para procurar o valor (s): tipo grade, uma chaleira gera
CREATE INDEX declaração.
f Se você usar um Dimension Lookup / Atualizar passo, a fim de carregar um mudando lentamente
dimensão, Chaleira gera um CRIAR A TABELA declaração incluindo todos os campos que são necessários para
manter esse tipo de dimensão atualizado. Mudando lentamente dimensões são uma construção de armazenamento
de dados que armazena dados históricos e mantém versões dos dados na mesma tabela.
42
Capítulo 1
Você pode executar o SQL como ele é gerado, você pode modificá-lo antes de executá-lo (como fez na receita), ou
você pode simplesmente ignorá-la. Às vezes, o SQL gerado inclui soltando uma coluna apenas porque a coluna existe
na tabela, mas não é usado na transformação. Nesse caso, você não deve executá-lo.
Finalmente, você deve saber que se você executar a instrução de colher fora, a fim de ver as mudanças dentro da ferramenta que
você quer ter de limpar o cache clicando com o botão direito sobre a conexão de banco de dados e selecionando o Limpar Cache
DB opção, ou reiniciar Spoon.
Veja também
f Você precisa carregar alguns dados em uma tabela temporária. A tabela existe, mas você precisa
adicionar algumas novas colunas a ele antes de prosseguir.
f Você tem que carregar uma tabela de dimensão. Esta tarefa é parte de uma nova exigência, pelo que esta
Enquanto você está criando as transformações e postos de trabalho, você tem a chance de criar ou modificar essas tabelas. Mas, se
essas transformações e empregos estão a ser executado no modo batch em um ambiente diferente, ninguém vai estar lá para fazer
essas verificações ou criar ou modificar as tabelas. Você precisa adaptar o seu trabalho para que estas coisas são feitas
automaticamente.
Suponha que você precisa fazer alguns cálculos e armazenar os resultados em uma tabela temporária que serão usados mais
tarde em outro processo. Como este é um novo requisito, é provável que a tabela não existe no banco de dados alvo. Você pode
criar um trabalho que cuida disso.
43
Trabalhando com bancos de dados
2. A partir do condições categoria, arrastar e soltar uma tabela existe entrada, uma SQL entrada de
Scripting, e uma MANEQUIM entrada de Geral.
4. Dê um duplo clique sobre o tabela existe entrada, escolha o livros conexão de banco de dados e
Como Nome da mesa tipo my_tmp_table.
5. Dê um duplo clique sobre o SQL entrada, escolha a mesma conexão de banco de dados, e na SQL
Roteiro: digite o seguinte:
CRIAR my_tmp_table TABELA (CALC_1
numérico (10,2), CALC_2 numérico (10,2),
CALC_3 numérico (10,2)
);
A instrução anterior é escrito com uma sintaxe MySQL. Por favor, reveja e
corrigi-lo, se necessário, porque você está usando um SGBD diferente.
44
Capítulo 1
Como funciona...
o tabela existe entrada, como sugere seu nome, verifica se existe uma tabela em seu banco de dados. Como acontece com qualquer entrada de
trabalho, esta entrada sucesso ou falha. Se ele falhar, o trabalho cria a tabela com um SQL entrada. Se for bem sucedido, o trabalho não faz
nada.
Tem mais...
o entrada SQL é muito útil, não só para a criação de tabelas como você fez na receita, mas também para executar instruções muito
simples, como, por exemplo, definir uma bandeira antes ou depois de executar uma transformação. Seu principal uso, no entanto, está
executando instruções DDL.
Por outro lado, a fim de decidir se era necessário para criar a tabela ou não, você usou um tabela existe entrada. Além de
esta entrada e antes de verificar a existência da tabela, você poderia ter usado o Verifique as conexões dB. Esta entrada
permite que você veja se o banco de dados está disponível.
Agora, vamos supor que a tabela existe, mas é uma versão antiga que não tem todas as colunas que você precisa. Neste caso, você pode usar
uma entrada útil adicional: existem colunas de uma tabela. Se você pode detectar que uma coluna não estiver presente, você pode alterar a
tabela, adicionando essa coluna, também com uma SQL entrada de trabalho.
Criar ou alterar tabelas não é uma tarefa que deve ser feito como parte de um processo de
ETL regular. Chaleira permite que você faça isso, mas você deve ter cuidado ao utilizar estas
funcionalidades.
Veja também
Suponha que você tenha um banco de dados com livros. Você recebeu um arquivo com uma lista de livros. Nessa lista
existem livros que você já tem e há livros que você não tem. Para os livros que você já tem, você pretende atualizar os
preços.
45
Trabalhando com bancos de dados
Entre os outros livros, você irá inserir em apenas aqueles que têm sido publicados recentemente seu banco de dados. Você
vai reconhecê-los porque eles têm o texto NOVO no Comente campo.
Preparando-se
Para esta receita, você vai precisar do banco de dados que pode ser criado e preenchido por executar o script books_2.sql.
Você também precisará do arquivo books_news.txt que acompanha o material para este capítulo.
À medida que a receita vai modificar os dados no banco de dados, antes de prosseguir, explorar a base de dados para ver o que está
dentro. Em particular, execute as seguintes instruções e prestar atenção aos resultados:
FROM livros;
+- - - - - - - - - - +
| COUNT (*) |
+- - - - - - - - - - +
| 34 |
+- - - - - - - - - - +
+- - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - +
+- - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - +
+- - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - +
* SELECT FROM
livros
46
Capítulo 1
1. Criar uma nova transformação e criar uma conexão com o livros base de dados.
2. Gota um entrada de arquivo de texto passo para a tela e usar a etapa para ler a books_news.
TXT Arquivo. Como separador, tipo |. Leia todos os campos como Corda exceto o preço que tem de ser lido como um Número com
3. Fazer uma pré-visualização para verificar que você tenha lido o arquivo corretamente. Você deve ver o seguinte:
4. Use um dividir Campos passo para dividir o campo nome em dois: primeiro nome e último nome.
5. Use um pesquisa de banco de dados passo a olhar para cima na autores mesa para um autor que
corresponde ao primeiro nome e último nome Campos. Como o valor para Valores para retornar de tabela de
pesquisa: adicionar id_author.
7. A partir da Saída categoria de passos arrastar e soltar um Sincronizar após fusão passo para
a tela e criar um hop desde o último passo em direção a este. Sua transformação é semelhante ao
seguinte:
8. Dê um clique duplo na etapa. Para o Conexão campo, selecione o livros conexão. Como
tabela de destino, tipo livros.
47
Trabalhando com bancos de dados
11. Como fieldname operação, selecionar Comente. Como Insira quando o valor igual, tipo NOVO. Como
Update quando valor igual, tipo Em estoque. Deixar os outros campos em branco.
14. Explorar o banco de dados novamente. Em particular, executado pela segunda vez as mesmas declarações que
decorreu antes de fazer a receita. Agora você terá o seguinte:
FROM livros;
+- - - - - - - - - - +
| COUNT (*) |
+- - - - - - - - - - +
| 38 |
+- - - - - - - - - - +
48
Capítulo 1
+- - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - +
+- - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - +
+- - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +- - - - - - - +
* SELECT FROM
livros
+- - - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - - - - +- - - - - - - +- - - - - - - +
+- - - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - - - - +- - - - - - - +- - - - - - - +
+- - - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - - - - +- - - - - - - +- - - - - - - +
Como funciona...
o Sincronizar após fusão etapa permite inserir, atualizar ou excluir linhas em uma tabela com base no valor de um
campo no fluxo. Na receita, você usou o Sincronizar após fusão passo tanto para inserir os novos livros (por
exemplo, Tordo) e para a actualização dos preços para os livros que você já tinha (por exemplo, A menina com o
tatuagem do dragão).
Para contar PDI se para executar uma inserção ou uma atualização, você usou o campo Comente.
Debaixo de avançado guia, você disse PDI que deve inserir os registros em que o comentário foi igual a NOVO, e
atualizar aqueles em que o comentário foi Em estoque.
Note-se que, porque você não tinha a intenção de excluir linhas, você deixou o Excluir quando o valor igual
opção em branco. No entanto, você também pode ter configurado esta opção da mesma forma que você configurou os
outros. Um exemplo disso, poderia ser a exclusão do livros que deixará de ser publicado. Se há livros que
correspondam a de critérios de mercado, você pode digitar
fora do mercado no Excluir quando o valor igual opção e esses livros seriam excluídos. As inserções e atualizações
foram feitas com base nas áreas que você inseriu nas redes sob a
Geral guia, que funcionam exatamente como as grades em um Insert / Update ou um Atualizar degrau.
49
Trabalhando com bancos de dados
Tem mais...
Vamos ver um pouco mais sobre o passo que você usou nesta receita.
tabela tudo em uma única etapa, com base em um campo presente no conjunto de dados. Para cada linha, Chaleira usa o valor
dessa coluna para decidir qual das três operações básicas para executar. Isso acontece da seguinte forma. Suponha que o fieldname
Inserir A inserção é feita para todas as linhas onde o campo op é igual a NOVO. A inserção é feita com base nos
campos de chave Assim como em um Insert / Update degrau.
Atualizar A atualização é feita para todas as linhas onde o campo op é igual ao valor Em estoque. A atualização é feita
com base nos campos de chave Assim como em um Insert / Update ou um Atualizar degrau.
Excluir A exclusão é feita para todas as linhas onde o campo op é igual ao valor
Interrompido. A exclusão é feita com base nos campos de chave Assim como em um
Excluir degrau. Para operações de exclusão, o conteúdo da grade inferior é ignorado.
Veja também
50
Capítulo 1
Às vezes, você tem várias bases de dados com exatamente a mesma estrutura com diferentes finalidades. Estas são
algumas situações:
f Um banco de dados para a informação que está sendo atualizado diariamente e um ou mais
bases de dados para dados históricos.
f Um banco de dados para o seu caixa de areia, um segundo banco de dados para a área de teste, e um terceiro
Em qualquer dessas situações, é provável que você precisa ter acesso a um ou outro dependendo de certas condições, ou você
pode mesmo ter que acessar todos eles um após o outro. Não só isso, o número de bancos de dados não pode ser fixado; ele
pode mudar ao longo do tempo (por exemplo, quando um novo ramo é aberto).
Suponha que você enfrentar o segundo cenário: sua empresa tem vários ramos, e as vendas para cada ramo são armazenados
em um banco de dados diferente. A estrutura do banco de dados é o mesmo para todos os ramos; a única diferença é que cada
um deles contém dados diferentes. Agora você deseja gerar um arquivo com o total de vendas para o ano em curso em todos os
ramos.
Preparando-se
Faça o download do material para esta receita. Você vai encontrar um arquivo de amostra com conexões de banco de dados para três ramos. Ele
parece com o seguinte:
Se você pretende executar a transformação, modificar o arquivo para que ele aponta para bancos de dados reais.
1. Crie uma transformação que utiliza um entrada de arquivo de texto passo que lê o arquivo com o
dados de ligação.
2. Adicione uma linhas de cópia para resultados passo para a transformação. Criar um hop indo de Texto
entrada de arquivo para Copiar linhas de resultados.
51
Trabalhando com bancos de dados
direito sobre a transformação e selecionando configurações de transformação. Mudar para o parâmetros aba e digite os
parâmetros nomeados.
$ {DATABASE_NAME}.
5. Use um Entrada Tabela passo para obter as vendas totais do banco de dados. Use o
conexão apenas definido.
6. Use um saída de arquivo de texto passo para o envio do resumo de vendas para um arquivo de texto. não
7. Criar um trabalho com dois Transformação entradas de trabalho, ligados um após o outro.
8. Use a primeira entrada para chamar a primeira transformação que você criou e a segunda entrada para chamar a segunda
transformação. O trabalho se parece com o seguinte:
9. Dê um duplo clique sobre a segunda entrada transformação, selecione a avançado guia e verificação
a Copiar os resultados anteriores aos parâmetros? e a Executar para cada linha de entrada?
caixas de seleção.
12. Abra o arquivo de texto gerado. Ela deve ter uma linha com informações de vendas para cada banco de dados no arquivo com
a lista de bancos de dados.
52
Capítulo 1
Como funciona...
Se você tem que conectar a vários bancos de dados, e você não sabe com antecedência quais ou quantos bancos de dados você terá
que conectar, você não pode confiar em uma conexão com valores fixos ou variáveis definidas em um único lugar, por exemplo , no kettle.properties
arquivo (que está localizado no diretório home Kettle). Nessas situações, o melhor que você pode fazer é definir uma conexão com
variáveis e definir os valores para as variáveis em tempo de execução. Na receita, você criou um arquivo de texto com uma linha de
vendas de resumo para cada banco de dados em uma lista. A transformação que escreveu a linha de vendas utilizada uma conexão
nomeado parâmetros. Isso significa que todo aquele que invocar a transformação tem de fornecer os valores adequados.
O trabalho principal laçadas na lista de conexões de banco de dados. Para cada linha nessa lista, ele chama a transformação de
copiar os valores do arquivo com os parâmetros na transformação. Em outras palavras, cada vez que a transformação é
executado, o parâmetros nomeados são instanciado com os valores provenientes do arquivo.
Tem mais...
Na receita, você mudou o anfitrião e o nome do banco de dados. Você poderia ter parametrizado qualquer um dos
valores que compunham uma conexão de banco de dados, por exemplo, o nome de usuário e senha.
Veja também
fo Executar parte de um trabalho uma vez para cada linha em um conjunto de dados receita em Capítulo 8,
Execução e Re-usando Jobs e Transformações
53
Trabalhando com bancos de dados
Nesta receita você vai carregar a tabela de pai-filho dos empregados da Steel Wheels. A hierarquia de
papéis no Steel Wheels é a seguinte:
Você irá carregar todos os empregados a partir de um arquivo. A seguir estão as linhas de amostra em que file:
1002|Murphy|Diane|x5800|dmurphy@classicmodelcars.com | 1 | Presidente |
1056|Patterson|Mary|x4611|mpatterso@classicmodelcars.com | 1 | VP
Sales|dmurphy@classicmodelcars.com
1076|Firrelli|Jeff|x9273|jfirrelli@classicmodelcars.com | 1 | VP
Marketing|dmurphy@classicmodelcars.com
. . .
Como você pode ver, entre os campos que têm o e-mail do funcionário que está acima na hierarquia. Por
exemplo, Gerar Bondur é um Gerente de vendas, e relatórios para o empregado com e-mail mpatterso@classicmodelcars.com,
isso é, Mary Patterson.
Preparando-se
Para executar esta receita, ou truncar o funcionários mesa Steel Wheels, ou criar a tabela funcionários em um banco de
dados diferente.
1. Crie uma transformação que insere o registro para o presidente que é o primeiro na hierarquia e não
relata a ninguém. A transformação deve ler o arquivo, filtrar o registro com JobTitle = Presidente, e inserir
os dados para o funcionários mesa.
2. Crie outra transformação para carregar o resto dos trabalhadores. Definir um parâmetro nomeado com o nome NÍVEL
que irá representar o papel dos funcionários sendo carregado.
54
Capítulo 1
4. Use um obter Variáveis passo para adicionar a variável NÍVEL como um novo campo chamado nível.
5. Use um Junte-se a linhas passo para mesclar os dados dos funcionários com o nível do
transformação será filtrando. Deixe o condição campo vazio de modo que o nível do obter Variáveis passo
serão adicionados a cada ficha.
6. Adicione uma Filtrar linhas passo para filtrar os funcionários a carga com base em suas funções. Em
7. Adicione uma pesquisa de banco de dados passo para descobrir o número do funcionário do empregado
que é um acima na hierarquia. Na grelha superior, adicionar uma linha com a condição
EMAIL = REP_TO. Use a grade inferior para obter o campo NÚMERO DE EMPREGADO e renomeá-lo para RELATÓRIOS
PARA.
8. Adicionar uma Manequim passo para enviar registros de funcionários que não têm um empregado
registro pai para. Este passo irá agir como um tratamento de erros degrau.
9. Adicionar saída de mesa passo e usá-lo para introduzir os registos na tabela funcionários.
Sua transformação final se parece com o seguinte:
10. Por fim, criar um trabalho para colocar tudo junto. arraste um COMEÇAR entrada e quatro
Transformação entradas de trabalho para a área de trabalho. Ligar todos eles em uma fileira.
11. Uso do primeiro Transformação entrada para executar a transformação que carrega
o presidente.
13. Repetir o passo 12 para o terceiro Transformação entrada, mas desta vez, tipo. * Gerente.*
como o valor para o NÍVEL parâmetro.
55
Trabalhando com bancos de dados
14. Repetir o passo 12 para o quarto Transformação entrada, mas desta vez, o tipo Vendas
Rep. * como o valor para o NÍVEL parâmetro.
15. Salve e execute o trabalho. A tabela deve ter todos os funcionários carregado, como você pode ver na
seguinte consulta:
SELECIONAR
N EmployeeNumber
, ÚLTIMO NOME
, RELATÓRIOS PARA
, JobTitle DE
colaboradores;
+- - - - - - +- - - - - - - - - - - +- - - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - - - +
+- - - - - - +- - - - - - - - - - - +- - - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - - - +
+- - - - - - +- - - - - - - - - - - +- - - - - - - - - - - +- - - - - - - - - - - - - - - - - - - - - - - - - - - - +
Como funciona...
Se você tiver que carregar uma tabela com relações pai-filho, carregar tudo de uma vez nem sempre é viável. Olhe para a dados
de amostra base de dados. Não há nenhuma chave estrangeira física do
RELATÓRIOS PARA coluna para o NÚMERO DE EMPREGADO coluna, mas se a chave estrangeira tivesse existido, ele seria um fracasso por causa
da restrição de chave estrangeira. Não apenas isso; neste caso, o carregamento de uma só vez seria impossível porque no arquivo que você
perdeu o ID do carregamento empregado pai todos os registros necessários para o RELATÓRIOS PARA coluna.
56
Capítulo 1
Assim, nesta receita havia uma solução possível para carregar a mesa. Nós carregamos todos os funcionários, uma função de
cada vez, começando com o presidente e seguido pelos papéis abaixo na hierarquia. A transformação que carregou os outros
papéis simplesmente ler o arquivo, manteve apenas os funcionários com o papel que está sendo carregado, olhou para o ID do
empregado pai na hierarquia, e inseridos os registros. Para os papéis que você poderia ter valores fixos usados, mas você usou
expressões regulares em seu lugar. Ao fazer isso, você evitou chamar a transformação uma vez para cada papel diferente. Por
exemplo, para carregar os vice-presidentes que você chamou a transformação uma vez com a expressão regular VP. * que
combinava tanto VP de Vendas e VP de Marketing.
Veja também
Ao trabalhar com sistemas de banco de dados fonte, os desenvolvedores têm que permanecer constantemente vigilantes para novas mudanças
no sistema como eles acontecem. Utilizando os metadados fonte que pode ser encontrada dentro do sistema de banco de dados pode ajudar a
gerar instruções SQL que permanecem constantemente actualizada. Isto irá permitir que os dados de origem para ser capturado mesmo se o
Nesta receita você irá criar uma base de dados dinâmicos extração transformação que irá extrair os dados do livros banco de
dados criado no início do capítulo.
Preparando-se
Para esta receita você vai precisar do banco de dados que pode ser criado e preenchido por executar o script books.sql. Isto pode ser
encontrado no código para este capítulo. À medida que a receita vai ler metadados do livros banco de dados, antes de prosseguir,
explorar repositório de metadados do banco de dados para ver o que está dentro. Em particular, executar estas instruções e prestar
SELECIONAR
NOME DA MESA
, TABLE_TYPE
, MOTOR
, VERSÃO
, ROW_FORMAT
, TABLE_ROWS
, AVG_ROW_LENGTH
, data_length
57
Trabalhando com bancos de dados
De information_schema.tables ONDE
TABLE_SCHEMA = 'livros';
+- - - - - - - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - +- - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - - - - -
+- - - - - - - - - - - - - - - - +- - - - - - - - - - - - - +
+- - - - - - - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - +- - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - - - - -
+- - - - - - - - - - - - - - - - +- - - - - - - - - - - - - +
+- - - - - - - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - +- - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - - - - -
+- - - - - - - - - - - - - - - - +- - - - - - - - - - - - - +
SELECIONAR
NOME DA MESA
, NOME DA COLUNA
, ORDINAL_POSITION
, COLUMN_DEFAULT
, IS_NULLABLE
, TIPO DE DADOS
DE ONDE INFORMATION_SCHEMA.COLUMNS
TABLE_SCHEMA = 'livros';
+- - - - - - - - - - - - - - +- - - - - - - - - - - - - +- - - - - - - - - - - - - - - - - - +- - - - - - - - - - - - - - - - +- - - - - - -
- - - - - - +- - - - - - - - - - - +
+- - - - - - - - - - - - - - +- - - - - - - - - - - - - +- - - - - - - - - - - - - - - - - - +- - - - - - - - - - - - - - - - +- - - - - - -
- - - - - - +- - - - - - - - - - - +
58
Capítulo 1
+- - - - - - - - - - - - - - +- - - - - - - - - - - - - +- - - - - - - - - - - - - - - - - - +- - - - - - - - - - - - - - - - +- - - - - - -
- - - - - - +- - - - - - - - - - - +
Comparar a forma como os dados no information_schema banco de dados coincide com a CRIAR DDL
declarações encontradas no books.sql Arquivo. Observe como os mesmos parâmetros nas demonstrações utilizado para
criar as tabelas traduzir na TABELAS e COLUNAS mesas.
1. Criar uma nova transformação e adicionar um Entrada Tabela passo que pode conectar-se à
information_schema base de dados.
2. Criar uma consulta que seleciona o NOME DA MESA e NOME DA COLUNA colunas a partir da
COLUNAS mesa, certificando-se de filtrar apenas na livros TABLE_SCHEMA.
3. Adicione um valor constante usando o Adicionar constantes step encontrado sob a Transformar
categoria. O valor deve ser nomeado garoupa com o tipo número inteiro eo valor de 1.
Criar um hop do Entrada Tabela passo para o Adicionar constantes degrau:
59
Trabalhando com bancos de dados
5. Visualize o Denormaliser degrau. Para cada tabela na livros banco de dados, você deve
ver um registro com uma lista separada por vírgulas de nomes de coluna.
6. Agora terminar esta transformação, adicionando uma linhas de cópia para resultar passo e criar um hop
de denormaliser Row passo para o linhas de cópia para resultar degrau.
7. Uma vez que estaremos construindo uma consulta SQL a partir destas colunas, a maneira mais simples será a usá-los como variáveis.
As variáveis não podem ser usados na mesma transformação como eles são definidos, mais vamos ter vários conjuntos de
variáveis, por isso precisamos criar um trabalho sub e um trabalho pai. empregos sub são postos de trabalho dentro de outros
empregos. Vamos continuar a construir as transformações necessárias e, em seguida, vamos construir os dois postos de trabalho
8. Criar uma segunda transformação. Adicionar um Entrada Tabela passo que irá usar as variáveis
estaremos criando a partir dos dados da primeira transformação. Certifique-se de selecionar o
Substitua as variáveis em script? checkbox. A consulta deverá ser parecido com o seguinte:
SELECIONAR $ {column_list_par} em $
{table_name_par}
9. Adicionar saída de arquivo de texto degrau. Para o Nome do arquivo campo, aponte para um local onde o
extratos de tabela de banco de dados pode ser despejado para. o Nome do arquivo Também é possível utilizar parâmetros. Use o table_name_par
como o nome do arquivo. o saída de arquivo de texto etapa irá armazenar todos os dados é na corrente sem declarar qualquer Campos,
por isso deixe o Campos
separador vazio.
60
Capítulo 1
10. Criar uma última transformação que irá utilizar o Obter linhas de resultado passo e carga
as variáveis column_list_par e table_name_par com o definir variáveis
degrau. o definir variáveis passo deve ser preenchido com o seguinte:
11. Criar um emprego. Este será o sub trabalho que levará cada registro e executar uma consulta. Trazer ao longo de um COMEÇAR
passo dois Transformação passos, e uma Sucesso degrau. O primeiro Transformação etapa deve apontar para a
transformação que define os parâmetros usados na consulta. O segundo Transformação etapa deve apontar para a
transformação que utiliza os parâmetros e extrai a saída da consulta em um arquivo de texto. Este trabalho deve ser
semelhante ao seguinte:
12. Crie outro emprego. Este será o trabalho pai para todo o processo. Trazer ao longo de um COMEÇAR passo, uma Transformação
passo, uma Trabalho passo, e um Sucesso degrau. o
Transformação passo deve apontar para a transformação que é extrair dados a partir da information_schema base
de dados. o Trabalho passo será apontando para o trabalho que criou anteriormente. Certifique-se de que o Executar
para cada linha de entrada? opção for activada sob a avançado guia para o trabalho. Seu trabalho final deve ser
semelhante ao seguinte:
13. Agora executar o trabalho pai. Deve haver um número de arquivos de texto com uma produção igual ao número
de tabelas no livros base de dados.
61
Trabalhando com bancos de dados
Como funciona...
A maioria dos bancos de dados têm um repositório de metadados que detalha tabelas e colunas. Isso pode ser usado para construir
consultas dinâmicas para extrair dados para processamento posterior. Neste caso, uma vez que o livros banco de dados foi criado, o
aplicativo de banco de dados armazenados os metadados dentro do information_schema base de dados. Nós, então, consultado o banco de
dados e usou um denormaliser Row passo para mesclar os detalhes das colunas em um único campo para que a nossa consulta seria
executado corretamente.
Veja também
f Obtendo dados de um banco de dados executando uma consulta construída em tempo de execução
fo Executar parte de um trabalho uma vez para cada linha em um conjunto de dados receita em Capítulo 8,
Execução e Re-usando Jobs e Transformações
Embora tenhamos advertiu que as tarefas de design de banco de dados não deve ser feito normalmente usando PDI, por
vezes, há certas tarefas que são muito repetitivo e pode economizar muito tempo criando uma transformação simples de
executar tais tarefas. Por exemplo, talvez haja algumas novas colunas de auditoria que precisam ser adicionados a todas as
tabelas de um banco de dados. Com PDI, e usando repositório de metadados de um banco de dados, é muito simples de
adicionar as colunas. Nesta receita estaremos criando uma transformação que vai ler uma lista de tabelas do livros
banco de dados no repositório de metadados do banco de dados e construir consultas dinâmicas para cada tabela.
Preparando-se
Para esta receita você vai precisar do banco de dados que pode ser criado e preenchido por executar o script books.sql. Isto pode
ser encontrado no código para este capítulo. À medida que a receita vai ler metadados do livros banco de dados, antes de
prosseguir, explorar repositório de metadados do banco de dados para ver o que está dentro. Em particular, execute a seguinte
instrução para ver o que as tabelas estão disponíveis no livros base de dados:
SELECIONAR
NOME DA MESA
, TABLE_TYPE
, MOTOR
62
Capítulo 1
, VERSÃO
, ROW_FORMAT
, TABLE_ROWS
, AVG_ROW_LENGTH
, data_length
De information_schema.tables ONDE
TABLE_SCHEMA = 'livros';
+- - - - - - - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - +- - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - - - - -
+- - - - - - - - - - - - - - - - +- - - - - - - - - - - - - +
+- - - - - - - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - +- - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - - - - -
+- - - - - - - - - - - - - - - - +- - - - - - - - - - - - - +
+- - - - - - - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - +- - - - - - - - - +- - - - - - - - - - - - +- - - - - - - - - - - -
+- - - - - - - - - - - - - - - - +- - - - - - - - - - - - - +
1. Crie uma transformação. Adicionar um Entrada Tabela passo que lê o NOME DA MESA de
a TABELAS tabela do MySQL do information_schema base de dados.
2. A partir do Scripting categoria, adicionar um Executar o script SQL degrau. Marque a opção
Executar para cada linha? e adicione NOME DA MESA ao parâmetros: seção. Para o
script SQL para executar, use o seguinte:
ALTERAR A TABELA ?
ADD COLUMN create_date DATETIME default '1900-01-01 00:00:00', ADD COLUMN UPDATE_DATE
TIMESTAMP PADRÃO CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
63
Trabalhando com bancos de dados
3. Criar um hop entre a Entrada Tabela e Executar o script SQL passos. Save e corra
a transformação. Quando concluído, verifique as tabelas no livros base de dados. Todos eles devem agora
ter um Criar Data e um data de atualização coluna adicionado.
Como funciona...
Usando repositório de metadados de um banco de dados é uma forma muito poderosa e eficaz para conhecer a estrutura de um
determinado banco de dados fonte. Com esta transformação, levou vantagem de que ao ler uma lista de todas as tabelas do livros banco
de dados e correu uma consulta com base em variáveis que acrescentou duas colunas para cada tabela com base no nome da tabela.
Tente adicionar filtros adicionais para especificar certas tabelas do livros base de dados. MySQL de
information_schema banco de dados também tem uma tabela que detalha as colunas de cada tabela (apropriadamente chamado COLUNAS). Para
bancos de dados maiores, você pode querer filtrar apenas um subconjunto de tabelas com base em colunas ou tipos de dados.
Embora tenha sido dito antes, que vale a pena mencionar novamente que esta técnica
deve ser usada com extrema cautela, uma vez que pode alterar drasticamente o seu
banco de dados, dependendo do tipo de consulta executada!
Veja também
f Obtendo dados de um banco de dados executando uma consulta construída em tempo de execução
fo Executar parte de um trabalho uma vez para cada linha em um conjunto de dados receita em Capítulo 8,
Execução e Re-usando Jobs e Transformações
f consultas Edifício SQL com base em metadados de banco de dados
64
2
Leitura e Escrita
de Arquivos
f leitura de arquivos com alguns campos que ocupam duas ou mais linhas
Introdução
Os arquivos são os mais primitivos, mas também o formato mais usado para armazenar dados e de intercâmbio. PDI tem a capacidade de ler dados
de todos os tipos de arquivos e formatos diferentes. Ele também permite que você escreva de volta para arquivos em formatos diferentes também.
Leitura e escrita de arquivos simples é uma tarefa muito simples. Há várias etapas nas categorias de entrada e saída de
passos que lhe permitem fazê-lo. Você escolhe o passo, configurá-lo rapidamente, e está feito. No entanto, quando os
arquivos que você tem que ler ou criar não são simples e que acontece na maioria das vezes, a tarefa de leitura ou escrita
pode se tornar um exercício tedioso, se você não sabe os truques. Neste capítulo, você vai aprender não apenas o básico
para leitura e escrita de arquivos, mas também todos os how-tos para lidar com eles.
Este capítulo abrange arquivos texto (. TXT, .csv, e largura fixa) e arquivos do Excel. Para
receitas de ler e escrever arquivos XML, consulte
Capítulo 4, manipulação de estruturas XML.
Nesta receita, você vai aprender o uso do entrada de arquivo de texto degrau. No exemplo, você tem que ler um arquivo simples com uma lista
de informações dos autores como o seguinte:
Preparando-se
A fim de continuar com o exercício, você deve ter um arquivo chamado authors.txt semelhante ao mostrado na
secção de introdução desta receita.
3. Agora, você tem que digitar o nome do arquivo ( authors.txt) com seu caminho completo.
Você fazê-lo na Arquivo ou diretório caixa de texto.
66
Capítulo 2
Dependendo de qual sistema operacional o arquivo foi criado, o seu tipo de formato terá
de ser alterado. DOS é o formato padrão, com Unix ser para qualquer um dos sistemas
operacionais baseados em * nix. O tipo de formato pode ser alterado no Conteúdo tab sob Formato.
6. Selecione o Campos guia e clique no obter Campos botão para obter as definições do
campos automaticamente. A grade será preenchida, como mostrado na imagem seguinte:
Chaleira nem sempre acho que os tipos de dados, tamanho, ou formato como esperado.
Então, depois de obter os campos, você pode alterar os dados para que você considera mais
apropriado.
Quando você lê um arquivo, não é obrigatório manter os nomes das colunas como
eles estão no arquivo. Você é livre para mudar os nomes dos campos também.
7. Clique no visualização botão e você verá algumas linhas de amostra construídos com os dados
no seu arquivo.
67
Leitura e Escrita de Arquivos
Como funciona...
Você usa entrada de arquivo de texto a fim de ler arquivos de texto, neste caso, a authors.txt Arquivo. Olhando para o conteúdo
do arquivo, você pode ver que a primeira linha contém o cabeçalho das colunas. Para reconhecer esse cabeçalho, você tem
Tem mais...
Para trabalhar com esses tipos de arquivos de texto delimitados, você poderia escolher o entrada de arquivo CSV degrau. Esta etapa tem
uma configuração menos potente, mas fornece um melhor desempenho. Se você explorar as guias da entrada de arquivo de texto janela de
configuração, você verá que existem mais opções para definir, mas os apenas explicados são, de longe, a mais utilizada. Mas, há um par
Onde os valores H1, H2, ... são os códigos hexadecimais para os separadores. Por exemplo, para especificar um til (~) como
separador em vez de digitá-la, você pode digitar $ [ 7E]. No entanto, esta notação faz mais sentido quando seus separadores
são caracteres não imprimíveis. Para a cadeia de gabinete, a notação hexadecimal também é permitido. Basta seguir as
68
Capítulo 2
Se você está lendo um número, e os números no seu arquivo tem separadores, sinais de dólar, e assim por diante,
você deve especificar um formato para contar Chaleira como interpretar esse número. O formato é uma combinação
de padrões e símbolos, como explicado na documentação da API do Oracle Java no seguinte URL: http://docs.oracle.com/javase/7/docs/api/java/text/
DecimalFormat.html.
Se você não especificar um formato para seus números, você ainda pode fornecer um comprimento e precisão. O comprimento é o número
total de números significativos, enquanto que a precisão é o número de dígitos de ponto flutuante.
No caso de datas, a mesma coisa acontece. Quando seu arquivo de texto tem uma data, você tem que selecionar ou digitar uma
máscara de formato, de modo Chaleira pode reconhecer os diferentes componentes do data no campo. Para uma referência
completa sobre os formatos de data, verifique a documentação da API do Oracle Java, localizado no seguinte URL: texto
http://docs.oracle.com/javase/7/docs/api/java/ / SimpleDateFormat.html.
Se você quiser reordenar ou excluir algumas das colunas que você lê, você tem que adicionar mais um passo para a
transformação. Suponha que você deseja mover o país nome para o fim da lista de colunas, mudá-lo para um nome de campo
mais adequado, tal como nacionalidade.
Neste caso, adicionar um Selecione os valores degrau. o Selecione os valores etapa permite selecionar, renomear, reordenar e excluir
campos, ou alterar os metadados de um campo.
69
Leitura e Escrita de Arquivos
Debaixo de Selecione & Alter guia, selecione todos os campos e manipular os de acordo com suas necessidades, como mostrado
no exemplo a seguir:
Se você quer apenas mudar o nome das colunas, você não precisa de um Selecione os
Preparando-se
Você deve ter um grupo de arquivos de texto em um diretório, todos com o mesmo formato. Nesta receita, os nomes
desses arquivos começam com museums_italy_, por exemplo, museums_italy_1, museums_italy_2, museums_italy_roma, museums_italy_genova,
e assim por diante. Cada arquivo tem uma lista de nomes de museus, um museu em cada linha.
70
Capítulo 2
3. De acordo com o Arquivo ou diretório guia, digite o diretório onde os arquivos são.
5. Em seguida, clique no Adicionar botão. A grade irá ser preenchido, tal como mostrado na
imagem seguinte:
$ {Internal.Transformation.Filename.Directory}
é uma variável que vai ser substituído no tempo de execução com o caminho
completo da transformação de corrente. Note que a variável será indefinido até que
você salve a transformação. Portanto, é necessário que você salva antes de executar
uma pré-visualização da etapa. Se você estiver executando um script em vários
ambientes, é recomendável para definir variáveis para o caminho em vez de usar $ { Internal.Transformation.Filename.
Diretório}. Você não tem que digitar o nome completo do
$ {Internal.Transformation.Filename.Directory}
variável. Ele pode ser selecionado a partir de uma lista criada automaticamente ao
pressionar Ctrl + Espaço.
Para definir uma variável, você pode criar um par de variável / valor no
kettle.properties ficheiro, que está localizado no diretório home Chaleira.
6. Sob o Campos guia, adicione uma linha; tipo museu para o Nome e coluna Corda
debaixo de Tipo coluna.
71
Leitura e Escrita de Arquivos
Como funciona...
Com Chaleira, é possível ler mais de um arquivo ao mesmo tempo usando um único
Entrada de arquivo de texto degrau.
A fim de obter o conteúdo de vários arquivos, você pode adicionar nomes à linha de grade por linha. Se os nomes dos arquivos
compartilhar o caminho e alguma parte de seus nomes, você também pode especificar os nomes dos arquivos usando expressões
regulares, como mostrado na receita. Se você digitar uma expressão regular, Chaleira terá todos os arquivos cujos nomes coincidem
com ele. Na receita, os arquivos que combinava museums_italy _. * \. txt foram considerados como arquivos de entrada.
museums_italy _. * \. txt significa todos os arquivos começando com museum_italy_ e ter a extensão TXT. Você pode testar se a
expressão regular é correta, clicando no Mostrar nome do arquivo (s) ... botão. Que irá mostrar uma lista de todos os
arquivos nessa pasta que correspondem a expressão. Se você preencher a grade com os nomes de vários arquivos (com
ou sem o uso de expressões regulares), Chaleira irá criar um conjunto de dados com o conteúdo de todos esses arquivos
um após o outro. Para saber mais sobre expressões regulares, você pode visitar os seguintes URLs: http: // www.
regular-expressions.info/quickstart.html e http://docs.oracle.com/ JavaSE / tutorial / essencial / regex /.
Tem mais...
Na receita de ler vários arquivos. Pode acontecer que você tem que ler apenas um arquivo, mas você não sabe
o nome exato do arquivo. Um exemplo disso é um arquivo cujo nome é um texto fixo seguido do ano atual e mês
como em samplefile_201012.txt. A receita é útil em casos como esse também. Neste exemplo, se você não sabe o
nome do arquivo, você ainda será capaz de lê-lo, digitando o seguinte expressão regular: samplefile_20 [0-9] [0-9] (0
[1-9] | 1 [0-2]). \ txt.
Os arquivos mais simples para leitura são aquelas em que todas as linhas seguem o mesmo padrão: Cada linha tem um número fixo de
colunas, e todas as colunas têm o mesmo tipo de dados em cada linha. No entanto, é comum ter arquivos onde a informação não tem
esse formato. Em muitas ocasiões, os arquivos têm pouca ou nenhuma estrutura. Isto também é chamado de formatação
"semi-estruturado". Suponha que você tenha um arquivo com descrições de montanha-russa, e o arquivo é semelhante ao seguinte:
Journey to Atlantis é um passeio de emoção sem igual, pois é ... Roller Coaster Estatísticas Drop:
60 pés
72
Capítulo 2
KRAKEN
SeaWorld Orlando
Nomeado após um monstro marinho lendário, Kraken é um ... Kraken começa com uma queda de
uma altura de 15-histórias ... Roller Coaster Estatísticas Altura: 151 pés Drop: 144 pés Velocidade
Máxima: 65 mph Comprimento: 4.177 pés Inversões: 7
Kumba
Busch Gardens Tampa
. . .
Como você pode ver, o arquivo anterior está longe de ser o típico arquivo estruturado que você pode ler simplesmente configurando uma entrada
de arquivo de texto degrau. Seguindo essa receita, você vai aprender a lidar com este tipo de arquivo.
Preparando-se
Quando você tem que ler um arquivo não-estruturados, como o arquivo de exemplo anterior, a primeira coisa a fazer é dar uma olhada
detalhada no que faz. Tentar entender como os dados são organizados; apesar de ser não-estruturado, tem um formato oculto que você
tem que descobrir, a fim de ser capaz de lê-lo. Então, vamos analisar o arquivo de amostra, que está disponível para download no site
da Packt. O arquivo tem dados sobre várias montanhas-russas. Vamos tomar nota das características do arquivo:
Como um exercício útil, você poderia fazer isso sozinho antes de ler a lista a
seguir.
Cada montanha russa abrange várias linhas. Existem linhas em branco, as quais devem ser eliminados. O que nos permite
distinguir a primeira linha para cada montanha-russa do resto, é que ele é escrito em letras maiúsculas.
A primeira linha abaixo do nome da montanha-russa é o nome do parque de diversões onde ele está localizado.
73
Leitura e Escrita de Arquivos
A maioria das linhas tem uma propriedade da montanha-russa no formato de Código: descrição,
Como por exemplo Drop: 60 pés.
Acima das propriedades, há uma linha com o texto Estatísticas da montanha russa, que não adiciona qualquer informação. Ele deve
ser descartado.
Existem linhas com informação adicional sobre o montanha russa. Não há nada que distingue estas linhas. Eles
simplesmente não se enquadram em nenhum dos outros tipos de linhas (linhas com o nome do parque, linhas com
propriedades de montanha-russa, e assim por diante). Depois de entender o conteúdo de seu arquivo, você está pronto
para lê-lo e analisá-lo.
2. Use esse passo para ler o arquivo chamado rollercoasters_II.txt. Debaixo de Conteúdo
guia, desmarque a Cabeçalho opção e sob o Separador guia, tipo |. Debaixo de Campos
guia, digite um único campo chamado texto do tipo Corda. Como o personagem | não está presente em qualquer parte do arquivo,
você tem certeza de que toda a linha vai ser lido como um único campo.
Escolher o separador de direito quando a construção de arquivos pode ser complicado. Tente
encontrar o personagem ou personagens certo que nunca são usadas dentro do conjunto de dados
3. A partir do Scripting categoria de passos, adicione um Modificada Java Script Valor degrau,
clique duas vezes nele, e sob a janela da guia Principal, digite o seguinte trecho de código:
var atracção;
trans_Status = CONTINUE_TRANSFORMATION;
4. Clique no obter variáveis botão para preencher a grade com a variável atração.
degrau. Criar um hop de Modificada Java Script Valor ao passo Adicionar campos de valor em mudança seqüência.
74
Capítulo 2
6. Clique duas vezes no passo. Como campo de resultado tipo line_nr. Na primeira linha da grelha,
tipo atração.
Até agora, você já leu o arquivo, e identificou todas as linhas pertencentes a cada montanha-russa. É hora de analisar as diferentes
linhas. Em primeiro lugar, vamos analisar as linhas que contêm propriedades:
1. Adicione uma Filtrar linhas passo e entrar no estado REGEXP texto (+.): (+.).
3. Configurar o passo da seguinte forma: Como O campo para avaliar selecionar texto. Verifica a Crio
campos para grupos de captura opção. Como Expressão regular: Tipo de (+.): (+.).
4. Preencha a grade inferior com duas linhas: como Novo campo tipo código na primeira linha e desc em
o segundo. Em ambas as linhas, sob Tipo, selecionar Corda, e abaixo aparar selecionar ambos.
5. Finalmente, adicione uma Selecione os valores passo para selecionar os campos: atração, código, desc,
e line_nr.
A fim de fazer uma pré-visualização para ver como os passos estão transformando seus dados,
você pode adicionar um Manequim passo e enviar os falsos linhas da Filtrar linhas passo em
relação a ele. A única finalidade desta é para evitar a transformação bater antes da visualização
pode ser concluído.
Agora, você irá analisar as outras linhas: as linhas que contêm o nome do parque, e os comentários
adicionais:
1. Adicionar outro Filtrar linhas passo, e enviar os falsos fileiras de outro Filtrar linhas degrau
em direção a este.
75
Leitura e Escrita de Arquivos
2. Adicionar dois Adicionar constantes passos, e uma Selecione os valores passo, e ligar todas as etapas, como
3. No Filtrar linhas inserir o estado line_nr = 1. Abra a primeira Adicionar constantes passo e adicionar um campo String
chamado código com o valor parque. Certifique-se as verdadeiras linhas da Filtrar linhas passo ir para esta etapa.
4. No outro Adicionar constantes etapa, adicionar um campo String chamado código com o valor
informação adicional. Certifique-se os falsos linhas da Filtrar linhas passo ir para esta etapa. Use o Selecione
os valores passo que une os dois Adicionar constantes etapas para selecionar os campos atração, código,
texto, e line_nr. No mesmo passo, renomeia texto Como desc.
Certifique-se de que os campos estão nesta ordem exata. Os metadados de ambos Selecione os
valores passos devem coincidir.
Agora que você tem analisado todos os tipos de linhas é hora de juntar as linhas juntas:
1. Junte-se a ambos Selecione os valores com um Classificar linhas degrau. Ordenar as linhas por atração
e line_nr.
76
Capítulo 2
2. Selecione o Classificar linhas passo e fazer uma pré-visualização. Você deve ver o seguinte:
Como funciona...
Quando você tem um arquivo semi-estruturadas (um arquivo com pouca ou nenhuma formatação real), a primeira coisa a fazer é
entender o seu conteúdo, a fim de ser capaz de analisar o arquivo corretamente. Se as entidades descritas no arquivo (montanhas
russas neste exemplo) são medidos ao longo de várias linhas, a primeira tarefa é identificar as linhas que compõem uma única
entidade. O método usual é fazê-lo com um JavaScript degrau. Neste exemplo, com o código JavaScript, você usou o fato de que a
primeira linha de cada montanha-russa foi escrito com letras maiúsculas, para criar e adicionar um campo chamado atração. No mesmo
código, você removido linhas indesejadas. Neste exemplo, como você precisava saber qual linha foi o primeiro em cada grupo, você
adicionou uma
Depois de fazer isso, que, como observado é necessário apenas para um determinado tipo de arquivo, você tem que analisar as
linhas. Se as linhas não seguem o mesmo padrão, você tem que dividir seu fluxo em tantas correntes como tipo de linhas que você
tem. Neste exemplo, você dividir o fluxo principal em três, como segue:
Em cada poço, você procedeu de forma diferente de acordo com o formato da linha. O passo mais úteis para a análise
77
Leitura e Escrita de Arquivos
Depois de analisada a linha com Avaliação regexp ou o passo de sua escolha, você pode continuar transformar ou modificar os
campos de acordo com as suas necessidades e as características de seu arquivo particular. Da mesma forma, dependendo do
propósito da sua transformação, você pode deixar os fluxos separados ou juntá-los novamente juntos como você fez na
receita.
Tem mais...
Existem alguns tipos comuns de arquivos que podem ser analisados na forma como você analisado arquivo montanhas russas:
As linhas que começam com o INV. são os cabeçalhos factura; as linhas a seguir os cabeçalhos são os detalhes dessas facturas.
Arquivos como estes não são incomuns. Se você tem um arquivo como este com os registros que representam cabeçalhos seguidos por
registros que representam detalhes sobre esses cabeçalhos, e os registros de cabeçalho e detalhe têm estruturas diferentes, você poderia
analisá-lo conforme explicado na receita. Leia o arquivo, faça o que for necessário para descobrir se uma linha é um cabeçalho ou um detalhe,
e dividir o fluxo em dois. Depois disso, analisar linhas de cabeçalho e linhas de detalhe em conformidade.
logfiles
Logfiles estão entre os tipos mais comuns de arquivos não estruturados. Eles são normalmente utilizados para monitorar os processos, clique
com o fluxo de análise, os downloads do usuário, e assim por diante. Ser capaz de processar através da montanha de detalhes produzidos
podem ajudar a identificar o que os clientes estão olhando ou o que os usuários são frequentemente fazendo em dado websites. Por exemplo,
vamos olhar para as seguintes linhas de amostra pertencentes a um log Pentaho servidor:
. . .
2010-09-30 13: 01: 30,437 DEBUG [org.pentaho.platform.engine.
services.solution.SolutionEngine] fd386728-CCAB-11df-9 ... 2010-09-30 13: 01: 30,484 INFO
[org.pentaho.platform.reposit
ory.solution.SolutionRepositoryBase] Solução Reposito ...
78
Capítulo 2
Neste caso, todas as linhas de começar com um marcador de tempo, seguido do nível de registo ( DEBUG, INFO, e assim por diante), e, em
Apesar de ser desestruturado, as linhas em um arquivo de log-a mostrada acima tem algum texto que permite que você saiba que
tipo de dados é nessas linhas. Usando esse conhecimento, você pode analisar diferentes linhas, como explicado na receita.
Neste exemplo particular, você pode ler o arquivo como contendo dois campos: um para a hora, o outro com o resto da linha.
Em seguida, você pode analisar a segunda divisão campo-lo em dois: o tipo de log ( DEBUG, INFO, e assim por diante) e o
detalhe. Opcionalmente, se você queria tratar cada nível de log diferente, você poderia dividir o fluxo com um caso interruptor passo
ou aninhados
Filtrar linhas etapas e prossiga.
Veja também
f Executar parte de um trabalho várias vezes até que uma condição é verdadeira receita em Capítulo 8,
Execução e Re-usando Jobs e Transformações
Firebug 1,5: edição, depuração e monitoramento de páginas da Web Publicado em: abril 2010
Nosso preço: $ 21.99
79
Leitura e Escrita de Arquivos
Este arquivo contém informações sobre o livro. No arquivo, cada livro é descrito em três linhas: uma para o título, uma para a data de
publicação publicado ou esperado, e uma linha para o preço. Não há nenhuma maneira direta de dizer Chaleira como interpretar
Preparando-se
Criar um arquivo que contém o texto anterior ou fazer o download do arquivo de amostra a partir do site da Packt.
1. Crie uma transformação e usar um entrada de arquivo de texto passo para ler o arquivo
packt_books.txt. Debaixo de Conteúdo guia, desmarque a Cabeçalho opção e como
Separador, digite |. Debaixo de Campos guia, digite um único campo String chamado texto.
3. Clique duas vezes na etapa. Como O campo para achatar digite ou selecione texto. Preencher a grade com três
Você já tem os campos como colunas! Agora, você pode ir um pouco mais e fazer alguma limpeza, como segue:
2. Configurar o passo da seguinte forma: Como O campo para avaliar digite ou selecione publishing_date.
Marque a opção Criar campos para grupos de captura. Como Expressão regular: tipo
(Publicado | esperado): (+.).
80
Capítulo 2
3. No Capturar Campos Grupo grade, adicionar duas linhas. Na primeira linha, crie um novo Corda
campo chamado status. No segundo, criar um Encontro campo chamado pub_date com
Formato yyy MMM. Em ambas as linhas, sob a aparar coluna, seleccionar ambos.
4. A partir do Transformar categoria, adicione um Substituir na corda degrau. Na grade, adicionar uma linha
com o valor preço sob a coluna No campo de fluxo, e Nosso preço: sob a coluna Procurar.
5. Finalmente, use um Selecione os valores passo para mudar os metadados do Preço campo: Alterá-lo
para Número. Como Formato, digite $ #. 00. Faça uma pré-visualização e você verá o seguinte:
Como funciona...
o flattener Row passo é um passo simples destinado para achatar linhas consecutivas e é perfeito para leitura de arquivos,
como o que na receita. Neste caso, você tinha um arquivo com informações do livro, cada livro ocupando três linhas
consecutivas. o flattener Row passo achatada campo texto
em três novos campos diferentes: título, publishing_date, e preço.
Note-se que se um livro tem um número diferente de linhas (por exemplo, se ela não tem a linha de preço), então você obtém resultados
inesperados.
81
Leitura e Escrita de Arquivos
Tem mais...
Se você não tem certeza sobre o conteúdo do arquivo, é melhor evitar esta solução simples e ir para um mais sofisticado, por
exemplo, uma solução que utiliza um denormalizer Row degrau. denormalizer Row leva um fluxo de dados normalizado (como um
valor / emparelhamento de chave) e desnormaliza-lo para que os dados para uma determinada entidade fará parte de uma linha.
Um grande exemplo e uma visão geral desta etapa pode ser encontrada no wiki Pentaho em http://wiki.pentaho.com/display/ EAI /
Fileira + De-normalizador.
Veja também
Quando você usa um dos passos Chaleira dedicados para leitura de arquivos, Chaleira espera uma entidade por linha. Por exemplo,
se você está lendo um arquivo com uma lista de clientes, em seguida, Chaleira espera que um cliente por linha. Suponha que você
tenha um arquivo organizado por linhas, onde os campos estão em diferentes colunas, mas alguns dos campos abrangem várias
linhas, como no exemplo a seguir contém dados sobre montanhas-russas:
A primeira linha para cada montanha russa tem o nome de atracção, a velocidade, e o local em três colunas diferentes. A localização, no
entanto, se estende por mais de duas ou três linhas. Finalmente, o ano não está na primeira linha como seria de esperar, mas na
segunda. Como ler este arquivo? Não com apenas uma entrada de arquivo de texto simples, mas, combinando-o com um par de medidas
adicionais, como você vai aprender nesta receita.
82
Capítulo 2
Preparando-se
Criar um arquivo que contém o texto anterior ou baixar o arquivo de exemplo do site da Packt.
1. Crie uma transformação e usar um entrada de arquivo de texto passo para ler o arquivo
rollercoasters.txt. Debaixo de Conteúdo guia, selecione Fixo Como Tipo de arquivo.
2. Preencher o Campos aba. Você também pode clicar em obter Campos usar o assistente que lhe permite
configurar as colunas de largura fixa, ou pode digitar as propriedades dos campos diretamente na grade. Debaixo Tipo de
Trim, selecionar ambos para todas as linhas. Debaixo Repetir, selecionar Y para os primeiros dois campos: Montanha russa e Rapidez.
configure o Ano campo com Formato #.
3. A partir do Estatisticas categoria, adicione um grupo de degrau. Na grade Os campos que fazem
-se ao grupo: introduzir duas linhas com valores Montanha russa e Rapidez. Encha o
agregados: grelha, como mostrado na imagem seguinte:
4. A partir do Transformar categoria, adicione um dividir Campos degrau. Dê um duplo clique sobre ele e configurar
-lo como segue: O campo para dividir Tipo, selecione Localização. Para delimitador, digite |. Encha o
Campos grade com três linhas. Debaixo Novo campo tipo parque, localização, e país.
83
Leitura e Escrita de Arquivos
Como funciona...
Se você tem que ler um arquivo e alguns dos campos em sua extensão de arquivo ao longo de várias linhas, você tem que encontrar
uma maneira de agrupar todos esses campos juntos. O grupo palavra faz você pensar sobre o grupo de degrau. Primeiro de tudo, a fim
de agrupar linhas, as linhas devem ter um campo ou campos em comum. No arquivo de exemplo, você sabe que as linhas seguintes a
que contém o nome da montanha-russa pertencem à mesma montanha-russa, mas Kettle não. Então, você selecionou Y debaixo de
Repetir campo; isso faz com que Chaleira repetir o valor do Montanha russa e Rapidez campos nas linhas, onde o campo está
vazio. Se você fizer visualizar os dados no entrada de arquivo de texto etapa, você vê o seguinte:
Desta forma, você é capaz de agrupar todas as linhas que compartilham os mesmos valores para o Montanha russa
e Rapidez Campos. Com o grupo de etapa, você fazer isso e concatenar os valores diferentes para o Localização e ano
Campos. Você sabe que as diferentes linhas para o Localização campo pertencem ao nome do parque, onde a
atração está localizado, a cidade ou estado e do país. Por isso, a última coisa que você faz é dividir o local em
três campos: parque, localização, e país.
Veja também
Nesta receita, você vai aprender o uso do saída de arquivo de texto passo para escrever arquivos de texto. Vamos supor que você tem
um banco de dados com produtos ao ar livre e que deseja exportar um catálogo de produtos para um arquivo de texto.
84
Capítulo 2
Preparando-se
Para esta receita, você vai precisar de um banco de dados com produtos ao ar livre com a estrutura explicada em
Apêndice A, Estruturas de dados.
2. Gota um A introdução da tabela passo para a tela. Digite a seguinte instrução SQL:
innerj.desc_product SELECT, categories.category, innerj.price FROM produtos innerj INNER JOIN categorias
EM innerj.id_category = categories.id_category
4. No Nome do arquivo caixa de texto sob o Arquivo guia, digite ou procure o nome do arquivo de destino.
6. Verifique o Não criar arquivo no início checkbox. Esta opção impede a criação
do arquivo quando não há dados para escrever a ele.
Se você quiser criar o arquivo de qualquer maneira, desmarque a Não criar arquivo no início caixa de
seleção e um arquivo com, pelo menos, 0 bytes será criado.
caixa de verificação.
9. Execute a transformação, um novo arquivo de texto será criado contendo a lista de produtos.
85
Leitura e Escrita de Arquivos
Como funciona...
o saída de arquivo de texto etapa permite gerar arquivos. Nesta receita, você usou para gerar um arquivo CSV com dados vindos
de um banco de dados. Debaixo de Arquivo guia, você inseriu o caminho eo nome do arquivo. Aqui, você também tem várias
opções para incluir a data ou a hora em diferentes formatos, como parte do nome do arquivo. Para este exemplo, você não tem
No arquivo gerado você pode ver que a primeira coluna contém uma linha com os cabeçalhos. Esses cabeçalhos são gerados
quando o Cabeçalho opção no Conteúdo guia está marcada. Debaixo de Campos guia desta etapa, você deve incluir os campos
de destino, incluindo os seus tipos e formatos. Se você precisar, você pode incluir um campo mais de uma vez.
Se você não especificar qualquer campo, a etapa vai escrever todos os campos da
etapa anterior. Isso pode ser útil quando você não sabe os nomes exatos dos
campos ou quando estes campos mudam dinamicamente.
Sob essa mesma guia, o Nulo coluna especifica a string que será escrito no caso de um valor nulo.
Finalmente, se você especificar o comprimento campo de cada coluna, um arquivo de largura fixa será criada.
Tem mais...
Aqui estão algumas considerações que tornam o processo de arquivos de escrita mais flexível.
Alterar cabeçalhos
Se você quiser alterar o nome de um cabeçalho, você pode inserir um Selecione os valores passo do
Transformar categoria pouco antes da saída de arquivo de texto degrau. Debaixo de Selecione & Alter guia, selecione os campos que
deseja renomear e dar-lhes uma melhor descrição. Por exemplo, você pode selecionar o desc_product fieldname e mudar o nome do
campo como Produtos.
Para enviar todos os outros campos em direção ao saída de arquivo de texto etapa, você também tem que verificar o
Incluir campos não especificados, ordenados por nome opção.
Em ambos os casos, você pode especificar um formato usando uma máscara de padrões e símbolos.
86
Capítulo 2
No caso de campos numéricos, você pode encontrar mais informações sobre os formatos no seguinte URL:
http://docs.oracle.com/javase/7/docs/api/java/text/DecimalFormat.html.
No caso de campos de data, você vai encontrar uma referência completa no seguinte URL: http: //
docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html.
Um arquivo padrão gerada com Kettle é um arquivo com várias colunas, que podem variar de acordo com a forma como
configurou a Campos guia do Saída passo e uma linha para cada linha em seu conjunto de dados, todos com a mesma estrutura.
Se você deseja que o arquivo tem um cabeçalho, o cabeçalho é criado automaticamente com os nomes dos campos. E se você
quiser gerar um arquivo de alguma forma diferente do que? Suponha que você tem um arquivo com uma lista de tópicos para um
exame escrito. Quando um aluno tem de fazer o exame, você tomar essa lista de tópicos e gerar uma folha como o seguinte:
Preparando-se
Crie um arquivo com uma lista de tópicos ou baixar o arquivo de amostra a partir do site da Packt.
Rownum na saída? opção e como Rownum nome do campo, tipo topic_num. Debaixo de
Campos guia, digite um único campo chamado texto.
2. A partir do Scripting categoria, arraste um Definido pelo usuário Expressão Java (UDJE). Use-o para
substitua o texto campo com o seguinte: topic_num + "" + Texto. Criar um hop do
entrada de arquivo de texto passo para o User Defined Expressão Java degrau.
87
Leitura e Escrita de Arquivos
3. Com um Selecionar linhas etapa, selecione o texto campo e você tem a lista de tópicos. Agora você
precisa adicionar o cabeçalho personalizado. Criar um hop do User Defined Expressão Java
passo para o Selecionar linhas degrau.
4. Com uma Obter Informações do Sistema passo, obter o nome do estudante a partir da linha de comando. Debaixo
5. Adicione uma UDJE para substituir o texto campo com o seguinte: " Nome do aluno: " + Texto.
6. A partir do Entrada categoria, adicione um Grade de dados degrau. Debaixo de meta guia, adicionar um campo String
nomeado texto. Preencha o Dados guia, como mostrado na imagem seguinte (incluindo a quarta linha vazia):
8. Dê um duplo clique no primeiro anexar fluxos passo, conforme hop cabeça, selecione o nome do
UDJE passo, conforme hop cauda, selecione o nome do Grade de dados degrau.
9. Dê um clique duplo no segundo anexar fluxos passo, conforme hop cabeça, selecione o nome do
anterior anexar fluxos passo, conforme hop cauda selecione o nome do Selecione os valores degrau.
88
Capítulo 2
10. Após esta última anexar fluxos etapa, adicionar um saída de arquivo de texto passo, introduzir um caminho e
nome para o arquivo de saída, e como campos, digite o nome do único campo que existe: o campo com o nome texto.
11. Executar a transformação. Não se esqueça de fornecer um nome de aluno como o primeiro argumento de
linha de comando. Por exemplo, executar o trabalho a partir do terminal no Kettle diretório de instalação
seria semelhante sh pan.sh / arquivo: <file_path_and_ name_here> .ktr <Student Name>. Veja o arquivo gerado;
ele deve olhar exatamente como o mostrado na introdução.
Como funciona...
Quando você gerar um arquivo com qualquer uma das etapas de saída Chaleira, as linhas têm que ser homogênea, ou seja, todos eles
têm que ter o mesmo formato, o mesmo número de colunas, o mesmo tipo de dados, e assim por diante. Esta receita lhe mostrou uma
das maneiras para criar um arquivo com linhas que diferem na estrutura. Neste caso, você tinha um fluxo principal com duas colunas: um
número e um tema escrito. No entanto, você também teve várias linhas que formavam um cabeçalho para esses tópicos. O que você fez
foi construir fluxos separados; em cada fluxo você concatenado os diferentes campos que você queria enviar para o arquivo, criando um
único campo chamado texto. Em seguida, juntou-se os fluxos usando anexar fluxos passos, e enviou o conjunto de dados final para um
arquivo com uma única coluna.
Tem mais...
A abordagem utilizada na receita é útil para criar arquivos com cabeçalhos personalizados ou rodapés. Agora, suponha que você
enfrentar qualquer um dos seguintes cenários:
f Você tem que gerar um arquivo com um cabeçalho personalizado, mas o conjunto de dados principal tem múltipla
f Você tem mais do que um conjunto de dados, todos com uma estrutura diferente (número diferente
ou o tipo de colunas) e você quer enviar todos eles para o mesmo arquivo, um após o outro.
Nestas situações, o problema pode ser resolvido de uma maneira diferente: criar uma transformação diferente para cada fluxo (uma para o
cabeçalho, uma para cada conjunto de dados diferente), e chamá-los um após o outro a partir de um trabalho principal. Toda
transformação deve acrescentar as linhas para o mesmo arquivo (não se esqueça de verificar o Acrescentar opção no saída de arquivo de
texto degrau). Criando isso leva um pouco mais de tempo, mas lhe dá muito mais flexibilidade.
89
Leitura e Escrita de Arquivos
Às vezes, você não tem o nome completo do arquivo que você pretende ler ou escrever na sua transformação. Isso pode ser
porque o nome do arquivo depende de um campo ou em informação externa. Suponha que você recebe um arquivo de texto com
informações sobre novos livros a serem processados. Este arquivo é enviado para você em uma base diária e a data é parte de seu
nome (por exemplo,
newBooks_20100927.txt).
Preparando-se
A fim de seguir esta receita, você deve ter um arquivo de texto chamado newBooks_20100927.txt
com informações do livro de amostra, como a seguir:
2. Gota um Obter Informações do Sistema passo do Entrada categoria na tela. Adicionar um novo campo
nomeado hoje, E no Tipo caixa de listagem, selecione Data System (variável).
3. A partir do Transformar categoria, adicione um valores selecionados passo, a fim de dar a data
o formato desejado. Clique no Meta-dados guia e preencha a primeira linha da seguinte forma:
4. Na receita, o arquivo é salvo no mesmo diretório como a transformação. A fim de obter este diretório, você tem que
obtê-lo como um campo em seu conjunto de dados. Esse é o propósito da próxima etapa. Adicione o obter Variáveis passo
do Trabalho categoria. Na grade, adicionar um novo campo chamado caminho. No Variável coluna, prima Ctrl + espaço a
fim de mostrar a lista de possíveis variáveis e selecione Internal.Transformation.Filename.Directory.
5. A partir do Scripting categoria, adicione um User Defined Expressão Java passo a partir de agora.
90
Capítulo 2
6. Na janela de configuração passo, adicione um campo denominado nome do arquivo ( digite-o no Novo campo
7. Agora que você tem o nome do arquivo, vamos ler o arquivo. Adicionar um entrada de arquivo de texto degrau.
Sua transformação deve olhar como a mostrada na imagem seguinte (exceto, possivelmente, para os
nomes da etapa):
8. Dê um clique duplo na etapa. Debaixo de Arquivo guia, vá para a seção inferior e verificar
a Aceita nomes de arquivos a partir da etapa anterior checkbox.
9. No Passo de ler a partir de nomes de ficheiros caixa de texto, digite ou selecione o nome do UDJE passo criado anteriormente. No Campo na
entrada para usar como nome de arquivo caixa de texto, tipo nome do arquivo.
11. Sob a Campos guia, adicione o seguinte nomes e tipos: Título (String), Autor
( String), preço (Number), e Género (corda).
Você não pode usar o obter Campos botão neste caso, porque o nome do arquivo será definido de
forma dinâmica. De forma a obter os cabeçalhos automaticamente, você pode preencher o Arquivo guia
com o nome de um arquivo de amostra. Em seguida, clique no obter Campos botão, a grade será
preenchida. Finalmente, você deve remover o arquivo de amostra do Arquivo
e definir o separador Aceita nomes de arquivos a partir da etapa anterior seção novamente.
Executar a transformação, você vai obter uma fonte de dados com as informações do arquivo de texto cujo nome foi
resolvido de forma dinâmica.
Como funciona...
Quando você tem que ler um arquivo eo nome do arquivo é conhecido apenas no momento de executar a transformação, não é
possível definir o nome do arquivo explicitamente na grade localizada sob o Arquivo guia do Entrada degrau. No entanto, há uma
maneira de fornecer o nome do arquivo.
91
Leitura e Escrita de Arquivos
Primeiro, você tem que criar um campo com o nome do arquivo, incluindo seu caminho completo. Depois de ter esse campo, a
única coisa a fazer é configurar o Aceita nomes de arquivos a partir da etapa anterior seção do Entrada passo, especificando o
Na receita, você não sabe o nome completo, porque parte do nome foi a data do sistema, como por exemplo, C:
/myDocuments/newBooks_20100927.txt. A fim de construir um campo com esse nome, você fez o seguinte:
Estas etapas estão entre os mais utilizados para estas situações. No entanto, os passos ea maneira de construir o campo vai depender
do seu caso particular. Na receita, você usou um entrada de arquivo de texto passo, mas o mesmo se aplica para outra Entrada passos:
Entrada Excel, Entrada de propriedade, e assim por diante. Pode acontecer que você quer ler um arquivo com um entrada de arquivo CSV passo,
mas percebe que ele não tem a opção de aceitar o nome do arquivo a partir de uma etapa anterior. Não se preocupe! Se você criar um hop de
qualquer passo em direção a este passo, a caixa de texto com o nome O campo de nome de ficheiro (dados de etapas anteriores) vai mostrar
magicamente, permitindo que o nome a ser fornecido dinamicamente. Este método para fornecer o nome do arquivo também se aplica quando
Tem mais...
O que se segue é um pouco de fundo sobre o Obter Informações do Sistema passo usado na receita. Depois disso, você vai
ver como a Aceitar nome do arquivo de campo? recurso pode ser usado na geração de arquivos.
Você pode usar o Obter Informações do Sistema passo para recuperar informações do ambiente PDI. Na receita, ele foi usado para
obter a data do sistema, mas você pode usá-lo para trazer e adicionando à outra informação ambiental conjunto de dados, por
exemplo, os argumentos da linha de comando, o nome do transformação, e assim por diante.
Você pode obter mais informações sobre esta etapa no seguinte URL:
http://wiki.pentaho.com/display/EAI/Get+System+Info.
92
Capítulo 2
Gerando vários arquivos simultaneamente com a mesma estrutura, mas nomes diferentes
Vamos supor que você quer escrever arquivos com informações sobre o livro, mas um arquivo diferente para cada gênero. Por exemplo, um
arquivo chamado fiction.txt com todos os livros de ficção, um outro arquivo chamado
children.txt com livros infantis, e assim por diante. Para fazer isso, você deve criar o nome do arquivo de forma dinâmica, como
mostrado na receita. Neste caso, supondo-se que o conjunto de dados tem um campo com o gênero do livro, você pode criar
uma expressão Java que concatena o caminho, o campo que tem o gênero, ea cadeia. TXT. Outra solução poderia ser a
concatenação do campo de caminho, gênero e. TXT através da Calculadora degrau. Em seguida, no saída de arquivo de texto etapa,
você deve marcar a caixa de seleção chamada Aceitar nome do arquivo de campo? E no
Correndo essa transformação vai gerar diferentes arquivos de texto com informações do livro; um arquivo para cada gênero.
Existem algumas ocasiões em que você precisa para incluir o nome de um arquivo como uma coluna em seu conjunto de dados para
processamento posterior. Com Chaleira, você pode fazê-lo de uma forma muito simples. Neste exemplo, você tem vários arquivos de texto
sobre os produtos de campismo. Cada arquivo pertence a uma categoria diferente e você sabe a categoria a partir do nome do arquivo. Por
exemplo, tents.txt
contém produtos da barraca. Você deseja obter um único conjunto de dados com todos os produtos a partir desses arquivos, incluindo um
campo indicando a categoria de cada produto.
Preparando-se
Para executar este exercício, você precisa de um diretório ( campingProducts) com arquivos de texto chamado
kitchen.txt, lights.txt, sleeping_bags.txt, tents.txt, e tools.txt. Cada arquivo contém descrições dos produtos e seu
preço separado com um |. Considere o seguinte exemplo:
93
Leitura e Escrita de Arquivos
2. Gota um entrada de arquivo de texto passo para a área de trabalho e usá-lo para ler os arquivos. Debaixo de
3. De acordo com o Conteúdo guia, tipo | Enquanto o Separador e completar a Campos guia como se segue:
4. Sob o campos de saída adicionais guia, tipo nome do arquivo no campo Baixo
campo de nome de arquivo.
5. Pré-visualizar esta etapa, você pode ver que há um novo campo chamado nome do arquivo com o
nome do arquivo (por exemplo: kitchen.txt).
6. Agora, você deve dividir o texto filename para obter a categoria. Adicionar um dividir Campos de
Transformar categoria, clique duas vezes sobre ele e preencher as janelas de configuração, como mostrado na imagem seguinte:
7. Pré-visualizar a última etapa da transformação, você verá um conjunto de dados com os produtos de campismo, o
seu preço, e também uma coluna chamada categoria com a categoria de produto adequado.
94
Capítulo 2
Como funciona...
Esta receita mostrou-lhe o caminho para converter os nomes dos arquivos em um novo campo chamado
categoria. O diretório de origem inserido no entrada de arquivo de texto etapa contém vários arquivos cujos nomes são
as categorias de produtos. Debaixo de campos de saída adicionais
guia, você incorporou o filename curta como um campo (por exemplo tents.txt); você também poderia ter incluído a extensão, tamanho ou
caminho completo entre outros campos. O passo seguinte na transformação, uma dividir Campos passo utiliza um ponto (.) como o delimitador
valor a ser usado no campo apenas a primeira parte, que é a categoria ( tendas no exemplo). Ele elimina a segunda parte, que é a
extensão do nome do arquivo (. TXT). Se você não deseja descartar a extensão, você deve adicionar outro campo na grade (por
exemplo, um campo chamado extensão de arquivo). Note-se que para este campo, você definir o tipo, mas você também pode especificar
um formato, comprimento, e assim por diante.
Chaleira fornece a input Excel passo, a fim de ler dados a partir de arquivos do Excel. Nesta receita, você vai usar esta etapa para
ler um arquivo de Excel sobre museus em Itália. O arquivo tem uma folha com uma coluna para o nome do museu e um outro para
a cidade onde ele está localizado. Os dados é iniciado na célula C3 (tal como mostrado na imagem na próxima secção).
Preparando-se
Para este exemplo, você precisa de um arquivo do Excel com o nome museumsItaly.xls com um museus folha, como mostrado na
imagem seguinte:
95
Leitura e Escrita de Arquivos
3. De acordo com o arquivos aba, navegue até o museumsItaly.xls arquivo e clique no Adicionar
botão. Isso fará com que o nome do arquivo a ser movido para a grade abaixo.
4. Sob o Folha guia, preencha a primeira linha da seguinte forma: Tipo museus no nome da folha
coluna, 2 no Inicia a linha, e 2 no Comece coluna.
As linhas e colunas são valores numéricos (você não pode definir a coluna com a letra de
identificação que você vê em Excel). Estes valores são baseados em zero (elas começam
com o número 0).
6. Sob o Campos guia, clique no Obter campos de linha de cabeçalho ... botão para obter o
nome e cidade Campos.
7. Visualizar a passo, você irá obter um conjunto de dados com os dados museus provenientes da folha de Excel.
Como funciona...
o input Excel etapa permite que você leia arquivos do Excel. Começando com Kettle 4.1.0, você também pode usar esta etapa para ler Escritório
aberto arquivos calc.
Esta receita mostrou-lhe o caminho para ler um simples arquivo Excel, com uma única folha. No entanto, o
input Excel etapa permite que você leia vários arquivos do Excel, ao mesmo tempo. Você fazê-lo apenas adicionando mais especificações
de nome de arquivo para a rede localizado sob o Arquivo aba. A etapa também permite a leitura de várias folhas. Você pode clicar no Obter
Sheetname (s) botão para selecionar a partir da lista de folhas para ler. Se você não especificar qualquer folha na grade, a etapa vai ler
todos eles.
Tome cuidado quando você deixar o nome da folha em branco ou quando você selecionar
mais de uma folha, porque se as folhas têm estruturas diferentes, você receberá um erro.
Excepto para a informação sobre a folha, a configuração de um input Excel passo para a leitura de um arquivo do Excel é exatamente o mesmo que
a configuração de um entrada de arquivo de texto degrau. Você não deve ter quaisquer problemas fazê-lo funcionar.
96
Capítulo 2
Veja também
Uma das coisas boas sobre arquivos do Excel é que eles dão-lhe a liberdade para escrever em qualquer lugar nas folhas, que às
vezes é bom se você quer priorizar o look and feel. No entanto, isso poderia causar problemas quando é hora para processar
automaticamente os dados nesses arquivos. Suponha que você tenha um arquivo do Excel com valores para um par de variáveis que
você gostaria de definir, como mostrado na imagem seguinte:
Neste exemplo, você deseja definir valores para três variáveis: Ano, productline, e Origem.
O problema é que você não sabe onde na folha de que a tabela é. Ele pode estar em qualquer lugar, perto do canto superior esquerdo da folha.
Como você não pode pedir Kettle para fazer a varredura em algum lugar perto do canto superior esquerdo, você vai aprender nesta receita como
Preparando-se
Criar um arquivo do Excel com a tabela anterior. Sinta-se livre para escrever os valores em qualquer lugar dentro das primeiras linhas e
colunas, enquanto os rótulos e os valores estão em colunas adjacentes.
2. Dê um clique duplo na etapa e digite ou procure o caminho eo nome do arquivo do Excel que você acabou de criar.
97
Leitura e Escrita de Arquivos
3. De acordo com o Conteúdo guia, desmarque a Cabeçalho opção, apenas no caso de uma das variáveis
está na primeira linha.
4. Selecione o Campo guia, e adicionar 10 linhas. Como Nome tipo uma, b, c, ..., j. Como Tipo, selecionar
Corda para as 10 linhas.
5. A partir do Transformar categoria de passos, arraste para a tela Row Normalizer e uma
Linha denormalizer degrau.
6. A partir do Estatisticas categoria, arraste Analytic Query, e ligar todas as etapas, como mostra a
a tela a seguir:
7. Dê um duplo clique Row Normalizer; Clique em obter Campos e a grade será preenchido
automaticamente com 10 linhas. Preencha a última coluna, novo campo, digitando em todas as linhas do valor célula.
8. Dê um duplo clique sobre o Analytic consulta degrau. Na grade inferior, adicionar uma linha com o
seguinte valores:
?? Debaixo Tipo, selecionar LEAD "N" linhas para a frente e obter Assunto.
9. Sob N tipo 1. Clique duas vezes em denormalizer Row. No Chave campo, digite ou selecione
célula. Preencher a grade inferior, como segue:
10. Fazer uma pré-visualização na última etapa. Você deve ver o seguinte:
98
Capítulo 2
Como funciona...
O truque para obter dados a partir de uma folha de Excel, se você não sabe exatamente onde na folha de dados está localizada, é
livrar-se das principais linhas e colunas. Livrar-se de linhas é fácil: basta deixar o Não há linhas vazias opção. O problema é se livrar
das colunas. Nesta receita, você tinha um arquivo do Excel com alguns valores: ano, a linha de produtos, e origem. Você não sabe
onde exatamente na folha os valores foram, mas você tinha duas pistas: Eles estavam em algum lugar nas primeiras células e os
valores foram ao lado dos rótulos que eles identificados. Assim, a fim de encontrar o que você está procurando, você lê os primeiros
10 colunas usando nomes genéricos uma, b, c, e assim por diante. Normalizando as células, você coloca a linha de células por linha.
Desta forma, cada valor permaneceu na linha logo abaixo seu rótulo. Por exemplo, se a célula com o valor ANO
permaneceu na décima linha, a célula com o valor 2010 foi na linha 11. Você pode confirmar isso fazendo uma pré-visualização
na Row Normalizer degrau. Para cada linha, a Analytic consulta passo foi para a frente para obter o valor da linha abaixo e
trouxe-nos como um novo campo na linha atual. Desta forma, as etiquetas e os valores foram de novo ao lado do outro, como
99
Leitura e Escrita de Arquivos
Agora, você pode simplesmente remover as linhas inúteis, mantendo apenas aqueles com etiquetas igual a Ano, productline, ou Origem,
ou fazer o que foi feito na receita: desnormalizar os dados para obter apenas uma linha. Esta linha está pronto para ser usado
para definir as variáveis Ano, productline, e
Origem apenas adicionando um definir variáveis passo no final da corrente.
Tem mais...
Como você não sabe quais colunas irá realizar que tipo de dados, o conselho é ler todos como string. Desta forma, você evita erros
inesperados. No entanto, depois de receber os dados, você pode alterar os metadados em conformidade usando um Selecione os
valores degrau.
Você só ler as primeiras 10 colunas. Se você não pode ter certeza de que os valores vão
estar neste intervalo de células, fique à vontade para aumentar esse valor.
Marcadores e valores são dispostos horizontalmente. E se, em vez de ter os rótulos e os valores como na receita, você
tê-los dispostos horizontalmente, como mostrado na imagem seguinte ?:
A receita ainda funciona se você fizer uma modificação simples. editar o Analytic consulta passo e mudar o 1 para 10. É assim que
funciona: quando você desnormalizar as linhas, as etiquetas e os seus valores permanecem 10 linhas afastados uns dos outros.
Assim, em vez de olhar para a próxima linha, a
Analytic consulta passo tem de olhar 10 linhas para a frente e obter os valores nessas linhas. Você pode vê-lo na imagem
seguinte, que é o resultado de uma prévia sobre este passo:
100
Capítulo 2
Se você apenas tem que olhar para uma célula específica, por exemplo D5, a solução é bastante diferente, mas, felizmente, bastante
simples. Em primeiro lugar, você tem que saber o número da coluna e linha onde seus dados estão. Como Excel começa a contar do
zero, você concluir que o D5 célula de amostra está na terceira coluna, quarta linha. Então, você pega um input Excel passo e digite o
nome do arquivo de Excel para ler. Na grade localizada sob o Folhas guia, adicionar uma linha. Debaixo de linha de partida
e Comece coluna tipo, o número da linha e da coluna de interesse são 4 e 3 nesse caso. Debaixo de Conteúdo guia, desmarque a Cabeçalho
e a Não há linhas vazias opções, marcada por padrão, e na Limite caixa de texto, tipo 1. Debaixo de Campos guia, adicionar um único
campo para manter o seu valor. Você terminou. Faça uma pré-visualização do arquivo Excel e você verá o seguinte:
Escrevendo um arquivo do Excel com Kettle tem muito em comum com a escrita de um arquivo de texto. Com exceção de um par de
configurações específicas para os arquivos do Excel, a configuração de um saída Excel passo é muito semelhante à configuração de um saída
de arquivo de texto degrau. Uma das diferenças é que quando você escrever um arquivo do Excel, você adicionar uma folha para o arquivo. E se
você quer escrever mais de uma folha no mesmo arquivo? Suponha que você tenha uma fonte de dados que contém livros e seus autores e
você deseja criar um arquivo do Excel com duas folhas. Na primeira folha, você quer que os autores e, no segundo, os títulos dos livros. Esta
101
Leitura e Escrita de Arquivos
Preparando-se
Para executar esta receita, você vai precisar de um banco de dados com livros e autores com a estrutura descrita na Apêndice A, Estruturas
de dados.
Realizar os seguintes passos, a fim de criar a folha com detalhes dos autores:
4. No Nome do arquivo caixa de texto sob o Arquivo guia, escreva o caminho de destino eo nome do arquivo ( Livros).
7. No nome da folha caixa de texto, tipo Autores. Selecione os Campos guia e clique no
obter campos botão para preencher a grade com os dados do autor. A grade deve ser semelhante ao mostrado na
imagem seguinte:
Se você achar que os tipos de defeito ou formatos dos campos não estão corretas,
você pode corrigi-los manualmente.
Realizar os seguintes passos, a fim de criar a folha com detalhes dos livros:
2. Gota um Entrada Tabela entrar na tela, a fim de ler as informações do título do livro:
* SELECT FROM fim Livros por título
102
Capítulo 2
3. Adicione uma saída Excel passo e definir o mesmo nome de ficheiro e extensão configurado no
transformação anterior ( livros e XLS).
Alternativamente, você pode usar um novo passo com o nome Escritor Excel.
Você vai encontrá-lo na Experimental categoria em Kettle 4.2 ou posterior. Esta etapa
permite escrever planilhas do Excel com mais flexibilidade. Uma de suas principais
características é o suporte para arquivos de modelo ou folhas.
6. Sob a mesma guia, certifique-se de verificar a Acrescentar checkbox. Selecione os Campos aba
e pressione o obter campos botão para preencher a grade com títulos de livros. A grade deve ser semelhante ao
mostrado na imagem seguinte:
103
Leitura e Escrita de Arquivos
9. Execute o trabalho. Ele irá gerar um arquivo do Excel com duas folhas: uma para autores e outro para
títulos. Deve olhar como a tela a seguir:
Como funciona...
A maneira intuitiva para gerar um arquivo Excel com duas folhas seria a criação de uma única transformação com os dois saída
Excel passos, um para cada uma das folhas. No entanto, essa abordagem não funciona porque Kettle não pode gerenciar o
acesso simultâneo ao mesmo ficheiro Excel em uma única transformação.
Uma maneira de evitar esse problema é criar diferentes transformações, um para cada folha, e em seguida, chamar essas
transformações de um emprego. Com esta abordagem, as transformações são executadas sequencialmente, o que significa
que as folhas são gerados um de cada vez, evitando o problema simultaneidade.
Tem mais...
Outra maneira de assegurar a geração sequencial das folhas seriam usando o Bloquear este passo até que passos terminar passo
do Fluxo categoria. Usando este passo, a escrita da segunda folha vai esperar para a primeira folha para completar o seu
processo de escrita. Para a nossa receita, a transformação deve ser semelhante a seguinte:
104
Capítulo 2
Veja também
Quando você gerar um arquivo Excel, você geralmente gerá-lo com uma única folha. Você pode, no entanto, gerar um
arquivo com mais folhas. Com PDI, você pode gerar um arquivo do Excel com várias folhas, mesmo se você não sabe
com antecedência quantas folhas você vai gerar, ou o nome dessas folhas.
Nesta receita, você irá criar tal um arquivo do Excel. Seu arquivo terá informações título do livro separado em
diferentes folhas, dependendo do gênero dos livros.
Preparando-se
Você vai precisar de um banco de dados contendo livros e autores com a estrutura descrita na
Apêndice A, Estruturas de dados.
2. A partir do Arquivo Gestão categoria, soltar um excluir arquivo entrada de trabalho para a área de trabalho.
3. No Nome do arquivo caixa de texto, digite o caminho eo nome do arquivo do Excel você irá criar, a fim de
remover o arquivo se ele existir.
4. Em seguida, você tem que adicionar os dois Transformação entradas: uma para selecionar o livro de
categorias ( Transf_Categories) e outro para escrever a folha específica para cada categoria ( Trans_BookByCategory).
O trabalho deverá ser parecido com o seguinte:
6. Nesta transformação, uma gota A introdução da tabela passo, a fim de obter categorias diferentes do livro. A
instrução SQL, deve ser semelhante ao seguinte:
105
Leitura e Escrita de Arquivos
7. Adicione uma linhas de cópia para resultar de Trabalho pasta e criar uma hop do A introdução da tabela
passo no sentido de esta.
9. gota uma A introdução da tabela passo para a tela. No SQL quadro, o seguinte tipo
declaração, a fim de selecionar os livros de acordo com o GÊNERO parâmetro:
12. No Nome do arquivo caixa de texto sob o Arquivo guia, digite o caminho de destino e
Arquivo. No Extensão caixa de texto, deixe o valor padrão xls.
16. Volte para o trabalho; editar os detalhes da entrada trabalho para a transformação
Trans_BookByCategory. Vou ao avançado guia e verifique o Copie resultado anterior para parâmetros? e Executar
para cada linha de entrada? caixas de seleção.
17. De acordo com o parâmetros guia, adicionar um novo valor: Tipo GÊNERO no Parâmetro
coluna, e gênero para o nome da coluna Stream.
18. Quando você executa o trabalho, o ficheiro Excel criado deve ter uma folha diferente para cada categoria, como
mostrado na imagem seguinte:
106
Capítulo 2
Como funciona...
Quando você tem que executar a mesma tarefa e outra vez, a solução é criar um loop que executa uma única
transformação ou trabalho, tantas vezes quanto necessário. Neste caso, o objetivo era criar uma nova folha de Excel para
cada categoria livro. Assim, a solução foi a seguinte:
f Chamar a segunda transformação uma vez para cada categoria na lista, copiando o
linhas a resultar na primeira transformação, e verificar o Executar para cada linha de entrada caixa de seleção na Trabalho
entrada pertencente à segunda transformação
Veja também
fo executando parte de um trabalho uma vez para cada linha no conjunto de dados receita em Capítulo 8, Execução e Re-usando
Jobs e Transformações
Amazon Web Services ajudou a remodelar a gestão do servidor, fornecendo flexibilidade infinita com máquinas virtuais que podem ser
girados ou desligar quase tão rápido quanto um simples comando. S3 é um espaço de armazenamento escalável que podem ser
compartilhados entre instâncias virtuais e é um local comum para arquivos a serem processados. Com esta receita, estaremos lendo
informações a partir de um arquivo em uma instância S3.
107
Leitura e Escrita de Arquivos
Esta receita vai exigir o acesso a AWS, que tem um nível gratuito para novos
usuários. Se você já usou AWS no passado e não tem acesso ao nível gratuito, a
receita não vai lidar com grandes transferências de dados de modo a despesa será
mínimo.
Preparando-se
Você precisa ter acesso aos arquivos para esta receita, que estão disponíveis no site da Packt. Você também vai precisar para criar
um balde de S3 para carregar os arquivos.
3. Clique em Criar Bucket e dar o balde um nome único. Para a receita, estaremos
utilizando a convenção de nomenclatura < seunome> .pdicb2.test.bucket.
5. Clique no Crio botão. Seu balde S3 será criado e nós podemos carregar nosso teste
arquivos para ele.
6. Clique no nome do seu balde. O conteúdo do balde vai agora ser apresentada. Clique no Envio botão e carregar o books.csv arquivo
dentro do balde. As chaves de segurança são necessárias para acessar o espaço de armazenamento S3. Use as seguintes
Estamos usando as teclas conta root para esta receita. Por favor, siga a documentação
AWS sobre as melhores práticas com contas de segurança quando essa configuração
fora de aprendizado e testes.
2. Clique nos pop-ups sobre as melhores práticas da AWS (mas note os links para essa configuração em um
ambiente vivo).
3. De acordo com a secção marcada Chaves de acesso, encontre o chave S3 Acesso e copiá-lo para
uso posterior.
4. O S3 CSV Input etapa requer uma chave secreta S3. Isto pode ser obtido utilizando o legado
página: https://portal.aws.amazon.com/gp/aws/securityCredentials.
copiá-lo também para uso posterior.
108
Capítulo 2
3. Abra o S3 Entrada degrau. copie o chave S3 Acesso e chave S3 Segredo para dentro
seus campos relacionados.
4. Clique no Escolha um balde botão. Se as teclas estão ativas, uma lista de disponíveis
baldes deve aparecer. Selecione < seunome> /pdicb2.test.bucket da lista.
6. Clique no obter Campos botão. Isso vai puxar os metadados campo do arquivo
e carregá-lo no Campos grade.
Como funciona...
o S3 CSV Input etapa funciona de forma muito semelhante ao CSV Input ou Entrada de arquivo de texto etapas, na medida em que analisa
os dados com base no formato do arquivo CSV. A maior diferença é que para acessar o arquivo, não só o arquivo tem que ser localizado,
mas o nome balde e as duas chaves para acessar o balde deve ser fornecido antes dos dados pode ser puxado para a transformação.
Outra característica poderosa da etapa é que ele permite que os arquivos a serem recuperados em paralelo-significado que arquivos muito
grandes podem ser divididos em muito pedaços mais manejáveis a serem processados. o S3 CSV Input passo não permite arquivos
compactados ou para o processamento de múltiplos arquivos. possíveis soluções para este poderia incluir armazenar o valor do campo
nome do arquivo da etapa em um parâmetro e looping sobre a lista ou a montagem do balde S3 diretamente em um sistema de arquivos
Veja também
109
3
Trabalhando com Big Data
e Fontes nuvem
Introdução
Enquanto arquivos simples e bancos de dados são o tipo mais comum de fonte que os desenvolvedores usando Chaleira interagir
com, existem muitos outros tipos de fontes de dados que são capazes de ser usado. Os armazéns de dados agora estão
começando a aproveitar os recursos de ferramentas como o Hadoop, bancos de dados NoSQL, e serviços em nuvem como
Amazon Web Services e SalesForce. Neste capítulo, você vai aprender a interagir com estas fontes de Big Data em Kettle. As
receitas neste capítulo são agrupados em várias fontes de dados, com cada agrupamento cobrindo como conectar, ler dados de, e
dados de carga na origem de dados.
Trabalhando com Big Data e Fontes nuvem
O foco deste capítulo é sobre as fontes de dados que são geralmente maiores do que pode ser configurado para trabalhar através de
exercícios. Para cada fonte de dados, a receita Conectando-se a um banco de dados em
Capítulo 1, Trabalhando com bancos de dados, cobrirá como se conectar à origem de dados, bem como recomendações
para a criação de um ambiente de teste no qual trabalhar.
mais comum para trabalhar. Este tipo de fonte de dados utiliza uma API web, que os desenvolvedores podem interagir com os dados
dentro do serviço de nuvem maciça. Às vezes, os dados que são gerados a partir do Salesforce.com é apenas parte da história em
torno de gestão de relacionamentos com clientes e maior benefício pode ser tido por colocar em dados de outras fontes para ajudar
na geração de vendas. Esta receita vai te ensinar como configurar e se conectar a um desenvolvimento dados de instância e de carga
Preparando-se
Antes de podermos cobrir a forma de interagir com Salesforce.com, você precisa se registrar para um ambiente de
desenvolvimento que parece e se sente como um ambiente de produção full-blown, embora em menor escala. Navegar para http://www.developerforce.com/events/re
registration.php e preencha o formulário para se cadastrar. Nós estaremos usando os aplicativos já construídos do ambiente de
desenvolvimento para a receita. Os dados que será o carregamento pode ser encontrada no código para este capítulo.
Toda vez que você deseja criar uma conexão com Salesforce.com, você vai precisar do seguinte:
f Nome de Usuário
f Senha
f Token de segurança
f Salesforce URL Webservice (a padrão é digitado, mas pode ser alterado se um diferente
versão da API está sendo usado)
Também é recomendado que você tem o ambiente de desenvolvimento, de modo que você possa solucionar, se
necessário.
Cada conta que se conecta através da API Salesforce.com deve usar tanto a
senha da conta e um token de segurança. Fichas pode ser gerado através conta
| Setup | Minhas informações pessoais | Redefinir meu token de segurança. Toda
vez que a senha da conta é reposto, um novo token é gerado.
112
Capítulo 3
2. Adicione uma Entrada de arquivo de texto opção no Entrada categoria. Navegue até o accounts.csv
arquivo encontrado no código para este capítulo.
4. No Campos guia, clique em Obter Fields. O passo será tentar e fazer uma melhor palpite sobre o
os nomes das colunas, ou trazer ao longo dos cabeçalhos das colunas se houver uma linha de cabeçalho.
6. Adicione uma Salesforce Insert passo do Saída categoria e conecte o Arquivo de texto
Entrada passo a ele através de um hop.
Recomenda-se que para as etapas que necessitam de informações (login, como o Salesforce
Entrada, Insert, Upsert, e Excluir
etapas), que esses detalhes sejam armazenados nos parâmetros, de modo que quando
eles mudam, você não tem que lembrar todos os lugares que eles estão em uso.
9. No Definições seção, selecione Conta no Módulo listbox. Uma vez que este conjunto de dados é pequeno, podemos
deixar o Tamanho do batch campo definido para 10. O número máximo de registos que pode ser carregado em
um lote é de 200, de acordo com a documentação Salesforce.com API ( http://www.salesforce.com/us/developer/docs/apexcode/Content/
apex_gov_limits.htm).
10. No Campos grade, clique em Editar mapeamento e mapear os campos de fluxo para o objeto
Campos. Clique em Está bem para salvar o mapeamento e Está bem novamente para sair do passo.
11. Salve e execute o passo. Os dados da conta deve agora carregar no objeto Conta Salesforce.com.
113
Trabalhando com Big Data e Fontes nuvem
Como funciona...
Os passos do Salesforce em Kettle tirar proveito da API web para fazer a interface com a estrutura de dados back-end.
Podemos levar os dados de fora do ambiente Salesforce.com e carregá-lo, para realizar análises mais avançadas nos
dados que vive tanto no aspecto de gestão de relacionamento com clientes, bem como os novos dados de fora. Os únicos
limites, como a quantidade de dados que podem ser armazenados e acessados são, o número de chamadas de API
disponíveis, e quanto espaço foi destinado à conta de Salesforce.com.
Veja também
Enquanto esta receita não lidar com uma grande quantidade de dados, tenha em mente que as
chamadas de API estão limitados às tampas sobre a conta que está sendo usado.
Preparando-se
Enquanto nós pode executar mais de filtragem, se o account.csv os dados são carregados de acordo com o Carregando dados em
Salesforce.com receita, não há dados fictícios suficientes no objeto de conta do ambiente de desenvolvimento, para nós para cavar. Será útil
também para ter o ambiente de desenvolvimento aberto no caso de qualquer solução de problemas é necessária.
2. A partir do Entrada categoria, selecione o Salesforce Input passo e trazê-lo para a tela.
3. Na Definições guia, preencha o Nome de Usuário e Senha campos com seu nome de usuário,
senha e token de segurança.
114
Capítulo 3
6. Para condição de consulta, entrar billingStreet! = null. Queremos ter certeza de que
temos clientes que têm um endereço de cobrança entrou.
7. Mude para o Campos guia e clique em Obter campos. Todos os campos para o objeto deve
ser preenchido na rede.
8. Clique em linhas de visualização para ver o conjunto de dados que é retornado a partir da consulta. Clique em ESTÁ BEM.
9. Adicionar Saída de arquivo de texto passo do Saída categoria. Adicionar um salto a partir do Força de vendas
Entrada ao Saída de arquivo de texto degrau.
10. Abra o Saída de arquivo de texto passo e para a Nome do arquivo campo, escolha um local para o
arquivo de texto a ser criado.
11. Mude para o Campos guia e clique em Obter campos. Todos os campos de fluxo deve preencher
a grade.
12. Executar a transformação eo arquivo de texto deve ser preenchida com o conjunto de dados.
Como funciona...
A API Salesforce inclui uma linguagem de consulta que tem uma lógica semelhante à SQL, chamado SOQL, que permite a consulta
complexa de objetos de dados para filtrar os dados para uso específico. o
Salesforce Input passo permite a utilização destes filtros para inserir dados numa corrente de dados Kettle normal. Os dados podem ser
ainda mais purificado e processado conforme a necessidade de integrar em um armazém de dados, relatório ou outra ferramenta de
usuário final.
Para saber mais sobre SOQL, confira o Salesforce. docs COM no http://www.salesforce.com/us/
desenvolvedor / docs / soql_sosl /.
Veja também
Pentaho foi uma das primeiras empresas a fornecer suporte para o Hadoop e tem seu código aberto esses recursos, juntamente
com passos para outras fontes de Big Data.
115
Trabalhando com Big Data e Fontes nuvem
Há uma série de tutoriais e vídeos no wiki Big Data da Pentaho disponível em http://wiki.pentaho.com/display/BAD/
Pentaho + Big + dados + Comunidade + Home.
Preparando-se
Antes de realmente tentar se conectar ao Hadoop, temos que criar um ambiente adequado. Empresas como Hortonworks e
Cloudera têm estado na vanguarda do fornecimento de novos recursos e funcionalidades para o ecossistema Hadoop,
incluindo ambientes de sandbox, para aprender sobre as várias ferramentas. Nós estaremos usando ambiente Sandbox
Hortonworks' para receitas Hadoop deste capítulo.
Depois de ter o sandbox configurado e pronto para ser executado, temos de fornecer Chaleira com uma configuração de
configuração. Essas configurações são chamados calços, que dão Chaleira todos os drivers necessários para se comunicar com um
determinado Hadoop ou outra pilha de Big Data. Uma visão geral de quais versões do Hadoop são suportados oficialmente, pode ser
encontrada em http://wiki.pentaho.com/display/ BAD / Configuração + Pentaho + para + seu + Hadoop + Distro + e + Versão.
Para construir um calço sob encomenda para Kettle, começamos com o básico hadoop-20 Shim fornecido pelo
Pentaho (que pode ser localizado na Chaleira de plugin diretório | pentaho-big-dataplugin | hadoop-configurações). O . jarra arquivos
sob o lib diretório tem que ser atualizado para coincidir com as versões das várias ferramentas dentro Sandbox os
Hortonworks'.
Agora precisamos apenas de um conjunto de dados em que para carregar o nosso ambiente Hadoop recém-cunhadas.
Felizmente, existem algumas grandes conjuntos de dados para nós para brincar. Para os exercícios deste capítulo, iremos utilizar
o banco de dados Baseball encontrada em http://seanlahman.com/ arquivos / database / lahman2012-csv.zip.
116
Capítulo 3
Banco de Dados de beisebol de Sean Lahman vai todo o caminho de volta para 1871 e é uma das
estatísticas do beisebol mais completos conjuntos disponíveis ao público. Como uma vantagem
adicional, estes dados também é utilizado para alguns dos cursos fornecidos como parte da caixa de
areia Hortonworks VM.
2. Traga um Começar passo e do Big Data seção. Trazer ao longo de um Hadoop Copiar arquivos
degrau. Conectar as duas etapas em conjunto com um hop que vai do Começar passo para o
Hadoop Copiar arquivos degrau.
3. Abra o Hadoop Copiar arquivos degrau. Marque a Criar pasta de destino checkbox.
4. Adicione o local onde você baixou os dados de beisebol na fonte de arquivo / pasta
campo de texto. Certifique-se de descompactar o conjunto de dados de modo que Chaleira vai pegar o arquivo real.
5. A Hortonworks Sandbox vai tentar usar um endereço IP local, que deveria ter exibido na inicialização da
caixa. o Arquivo de destino / Pasta campo de texto terá a conexão da caixa de areia e vai dizer Kettle
onde para carregar os dados. Use a seqüência de conexão: hdfs: // <your_sandbox_ip_address>: 8020 /
user / sandbox / baseball / raw. Seu passo deve ser semelhante à imagem a seguir:
117
Trabalhando com Big Data e Fontes nuvem
Enquanto o sandbox não vai exigir um nome de usuário ou senha, ambientes de produção
provavelmente vai precisar de um. É melhor para armazenar esses valores em parâmetros, uma
vez que eles são exibidos em texto simples.
6. Guardar e executar o trabalho. O banco de dados Baseball agora está a carregar em seu ambiente de sandbox. Você
pode monitorar o processo do trabalho através da linha de comando da caixa de areia:
Se você receber uma mensagem de erro do PDI, garantir que o sandbox está operacional e que não há problemas de
conectividade.
Como funciona...
Chaleira de Hadoop Copiar arquivos passo fornece uma interface fácil de usar para enviar dados para o
Hadoop File System (HDFS). A seqüência de conexão usada no passo 5, na verdade, faz várias coisas:
f Definir o local onde os dados serão armazenados (/ user / sandbox / baseball / raw)
Todos os dados são carregados para esse local para processamento adicional, ou usando-o por meio de outras ferramentas, como colmeia,
Tem mais...
Embora este passo é projetado para carregar o sistema de arquivos Hadoop com dados, ele também pode carregar dados diretamente em Hive
(a camada de tipo SQL para Hadoop). Há uma grande tutorial sobre a funcionalidade em http://wiki.pentaho.com/display/BAD/Loading+Data+into+Hive.
Hive é uma camada de tradução usado para fazer a interface com os dados armazenados no Hadoop, permitindo aos utilizadores escrever
consultas que são semelhantes para SQL em um idioma personalizado chamado HiveQL. Enquanto Hadoop Copiar arquivos torna o
carregamento de grandes quantidades de dados mais fácil, também podemos usar meios mais tradicionais, como Saída de mesa, Insert /
Update, e Atualizar com uma conexão de banco de dados.
Veja também
118
Capítulo 3
Na verdade, podemos tratá-lo como qualquer outra fonte de dados que é um arquivo simples.
Preparando-se
Para esta receita, iremos utilizar o conjunto de dados de basebol carregado na Hadoop na receita
Carregando dados em Hadoop ( Também neste capítulo). Recomenda-se que esta receita é realizada antes de
continuar. Estaremos focando a Salaries.csv e a Master.csv conjuntos de dados. Vamos descobrir quanto dinheiro
cada jogador ganhou ao longo de suas carreiras.
2. No desenhar guia, sob a Big Data seção, selecionar e trazer mais de dois Entrada Hadoop Arquivo passos. Usaremos
um para cada um dos. csv arquivos que deseja mesclar juntos.
3. Editar um do Entrada Hadoop Arquivo passos. Isso será usado para puxar na
Salaries.csv em formação.
4. Para a Arquivo ou diretório campo de texto, digite as informações de conexão para chegar ao
Salaries.csv dados. Por exemplo, se os dados foram armazenados sob a sandbox do usuário do
baseball / raw pasta, o uso hdfs: // <your_sandbox_ip_address>: 8020 / user / sandbox / baseball / raw /
Salaries.csv.
6. Mude para o Campos guia e clique em Obter Fields. Clique em Está bem no Número de linhas
para provar pronto. Chaleira fornece um melhor palpite para os campos no arquivo.
9. Agora precisamos filtrar os campos que não precisamos. De Transformar seção, trazer
mais de dois Selecionar Valores passos. Conectar um para cada um dos Entrada Hadoop Arquivo passos.
10. Para o salários dados, queremos remover o yearID, ID da equipa, e lgID Campos.
11. Pela mestre dados, queremos remover todos, mas o playerid, nameFirst, e
nomear última Campos.
119
Trabalhando com Big Data e Fontes nuvem
12. Adicionar uma Classificar linhas passo e ordenar a salários dados sobre playerid. Nós também precisamos
adicionar outro Classificar linhas passo para o mestre dados e também classificar playerid.
13. Sob Estatisticas, selecionar e trazer ao longo de um grupo de passo do Estatisticas seção.
Para o Grupo campo, adicione playerid. Debaixo de agregados: seção, adicionar os seguintes detalhes:
?? Nome: salary_sum
?? Sujeito: salário
?? Tipo: Soma
14. Ora, os dois conjuntos de dados podem ser fundidos com um merge Join degrau. Adicionar saltos para trazer tanto
córregos na merge Join degrau. o Chave campo para ambas as etapas serão playerid. o
Junte-Tipo será INTERIOR. O passo agora deve ser semelhante à imagem seguinte:
120
Capítulo 3
15. Por último, adicione um Saída de arquivo de texto passo e conecte-o ao merge Join degrau. Seu
transformação deve ser semelhante à imagem a seguir:
16. Executar a transformação e olhar para o csv arquivo criado. Assim como a fonte csv
arquivos foram armazenados localmente, fomos capazes de acessá-los e construir um pequeno conjunto de dados agregados em
Kettle.
Como funciona...
Hadoop é um sistema de ficheiros distribuído gigante. Nesta receita, lemos dados do Sistema de Arquivo Hadoop e utilizado
capacidades de integração de dados da chaleira para agregar os dados por jogador, e mesclá-lo com os nomes dos jogadores.
Enquanto os dois Entrada Hadoop Arquivo passos foram chamando em um arquivo específico, se os dados eram em muitos arquivos,
poderíamos facilmente ter adicionado uma expressão regular para trazer os arquivos que precisávamos. Os dados podem
efetivamente vivem em todo o cluster do Hadoop, mas só temos de chamar ao cluster com o nosso pedido e a etapa faz o resto.
Veja também
fA receita Juntando-se dois ou mais fluxos com base nas condições dadas em Capítulo 7,
Entendendo e otimizando fluxos de dados
121
Trabalhando com Big Data e Fontes nuvem
Preparando-se
Nesta receita, estaremos a carregar o Schools.csv, Master.csv, e SchoolsPlayers. csv arquivos. Os dados dizem respeito
(através do SchoolsPlayers.csv arquivo) escolas (encontrados no
Schools.csv arquivo) para jogadores (encontrada no Master.csv Arquivo). Esta informação é projetado para um banco de dados relacional, por isso
vamos estar aprimorando os dados para tirar vantagem das capacidades de armazenamento de dados do HBase. Antes de nós pode carregar
qualquer coisa em HBase, precisamos criar o esquema no qual os dados serão armazenados. Vamos primeiro olhar para o modelo relacional para
A relação pode ser classificada como muitos para muitos. Há muitos jogadores, e muitas escolas, com alguns jogadores indo para mais
de uma escola. O desafio com o uso de ferramentas como o HBase são de que eles não têm um conceito de modelagem relacional.
conjuntos de dados juntando pode se tornar bastante complicado tanto para desenvolvedores, bem como para o desempenho. A
solução é desnormalizar os dados para que ele irá atender nossas exigências de consulta. É importante arquiteto do modelo para os
tipos de consultas que vão estar em execução. Para esta receita, queremos encontrar os jogadores que participaram em uma escola
para um determinado ano. Com isso em mente, o nosso modelo de dados torna-se o seguinte:
122
Capítulo 3
chave chave
de linha escola
-----------------------
colunas SchoolName
schoolCity
schoolState
schoolNick
playerid
nameFirst
nameLast
nameNick
yearMin
yearMax
Nós temos agora um conjunto de dados plana em que para responder às nossas perguntas. O script de esquema para executar dentro da Shell
HBase é o seguinte:
Esta é HBase taquigrafia para criar uma tabela chamada escola, com uma coluna de chave chamada chave, e 11 famílias
de colunas ( schoolID, SchoolName, schoolCity, schoolState, schoolNick, playerid, nameFirst, nameLast, nameNick, yearMin, e yearMax).
Outra maneira de modelar os dados seria a de tirar proveito de um recurso avançado de HBase, que é a capacidade de
conjuntos de dados ninho juntos. Este pouco imita a muitos para muitos relação modelada no banco de dados
relacional, mas pode torná-lo um desafio para consultar dados se os dados aninhada vai mais de um ou dois níveis no
modelo seria parecido com a figura a seguir.:
Escola
123
Trabalhando com Big Data e Fontes nuvem
Onde o Jogador objeto seria apenas outra família coluna dentro do Escola mesa.
2. Traga mais de três Entrada Hadoop Arquivo passos da Big Data categoria para carregar o
Master.csv, School.csv, e a SchoolsPlayers.csv arquivos.
3. Antes de juntar-se os conjuntos de dados em conjunto, temos de classificar cada conjunto de dados com uma Classificar linhas
passo por arquivo. Classificar os dados com base nas chaves para esse conjunto de dados. Para Escola, A chave seria SchoolID,
Mestre teria playerid, e assim por diante.
5. A Master / SchoolsPlayers conjunto de dados precisa ser resolvido por schoolID para que ele
pode ser mesclado com o Escola dados. Adicionar outro Classificar linhas passo para classificar os dados.
6. Adicione outro merge Join passo para mesclar o Master / SchoolsPlayers conjunto de dados com
a Escola dados. Os dois conjuntos podem ser fundidas através schoolID.
7. Adicione uma Calculadora passo do Transformar categoria. Esta etapa irá criar os valores
para o campo de chave, combinando o schoolID e playerid campos com uma | delimitador. Adicione duas linhas na Campos:
grelha, como mostrado na imagem seguinte:
124
Capítulo 3
8. Antes de carregar dados em HBase, precisamos remover todos os campos que não deseja armazenar no banco de
dados. Trazer ao longo de um Selecionar Valores passo do Transformação
seção. Selecione os Remover guia e clique em Obter campos de remover. Isto irá adicionar todos os campos de fluxo para o Campos
para remover: grade. Precisamos manter os campos que correspondem aos nomes de família coluna listados anteriormente ( CschoolID,
SchoolName, e assim por diante).
9. Por último, adicione um saída HBase passo, que pode ser encontrado sob o Big Data categoria.
No configurar conexão guia, digite o endereço IP do sandbox e do porto. O padrão deve ser 2181
para a porta.
10. Mude para o Criar / Editar mapeamentos aba. Clique em Obter nomes de tabela e selecione o
Escola mesa no menu suspenso.
12. Clique no Obter campos de entrada. Isso fará com que os campos de fluxo no mapeamento. Encontrar
a chave remar e mudar o Chave valor a Y, Deixe o família de colunas e Nome da coluna campos em branco. o Tipo
campo deve ser alterado para Corda.
13. Todos os outros campos ( schoolCity, SchoolName, schoolNick, e assim por diante) pode ser
adicionados às famílias com o mesmo nome da coluna. O mapeamento deve ser semelhante à imagem a
seguir:
14. Clique no Salvar o mapeamento. Um aviso irá aparecer pedindo para salvar o mapeamento para a
Escola mesa. Clique em sim e voltar para o configurar conexão aba.
125
Trabalhando com Big Data e Fontes nuvem
15. Para o HBase nome da tabela campo, insira escola. selecionar jogador para o Mapeamento
nome campo. Clique em ESTÁ BEM. A transformação final deve ser semelhante à imagem a
seguir:
Como funciona...
Com base na receita, Carregando dados em Hadoop, tomarmos os dados do Hadoop e usar Kettle é construído em recursos para classificar e
associar os dados e construir um conjunto de dados desnormalizada que podem nos ajudar a responder a perguntas a respeito de estatísticas
do jogador com base nas escolas. É importante notar que HBase não é como bancos de dados típicos; na medida em que pode ser bastante
difícil para se juntar em mesas e famílias de colunas. À medida que novos requisitos para determinados conjuntos de dados chegam, é muito
provável que os mesmos dados será reestruturado através de múltiplas mesas e muitas famílias de colunas.
Tem mais...
Enquanto aproveitamos o trabalho feito na receita, Carregando dados em Hadoop poderíamos facilmente ter usado o original csv arquivos,
outro banco de dados, ou mesmo planilhas para carregar em HBase. Assim como com qualquer uma das fontes de dados mais
comuns, uma vez que os dados são parte de um fluxo PDI, é tratada da mesma forma.
Veja também
fA receita Juntando-se dois ou mais fluxos com base nas condições dadas em Capítulo 7,
Entendendo e otimizando fluxos de dados
126
Capítulo 3
Preparando-se
A fim de seguir esta receita, você vai precisar para realizar o Carregando dados em HBase receita. Nós estaremos usando o conjunto de
dados criado em HBase com essa receita, para responder à questão colocada ao projetar o modelo de que os dados jogadores assistiram
o que a escola em um determinado ano?
3. Encontre o HBase nome da tabela campo e clique em Obter nomes de tabelas mapeadas. Isso vai
fornecer uma lista suspensa de tabelas do HBase. Selecione os escola mesa.
4. Clique no Obter mapeamentos para a tabela especificada botão ao lado do nome de mapeamento
campo e selecione o jogador mapeamento.
127
Trabalhando com Big Data e Fontes nuvem
5. Clique em Obter Key / Info Fields. Todos os campos para o mapeamento jogador escola deve
preencher na grade nesta guia. A grade deve corresponder à imagem seguinte:
6. Mude para o conjunto de resultados filtro aba. Adicionar filtros para yearMax e yearMin para que ele
corresponda à imagem seguinte:
7. Certifique-se de que Combinar todas é selecionada e, em seguida, clique em Está bem para fechar a passo.
8. Adicionar uma Classificar linhas passo e ligar o input HBase passo a ele com um hop.
9. No Classificar linhas etapa, classificar os dados em ordem crescente por SchoolName, nameLast,
e nome primeiro. Isto irá fornecer uma lista ordenada por ambos escola e jogador.
10. Traga um saída de arquivo de texto passar por cima. Debaixo de Campos guia, clique em obter Campos e adicione todos
os campos de fluxo. A transformação final deve parecer com a seguinte imagem:
11. Executar a transformação. Você deverá ver um arquivo de texto produzido com todos os jogadores que estavam em uma escola durante o
ano de 1989. Você pode executar novamente a transformação com diferentes critérios de filtro e receber correspondentes conjuntos de
resultados.
128
Capítulo 3
Como funciona...
Ao combinar os conjuntos de dados em uma estrutura plana, somos capazes de usar HBase para consultar rapidamente os dados para os
dados critérios de filtro. Podemos consultar a mesma mesa contra muitos mapeamentos diferentes para melhor atendam os tipos de
consultas que deseja executar. O mapeamento mostrado na configurar consulta guia baseia-se nos mapeamentos criados ou editados no Criar
/ Editar mapeamentos aba. Esta mesma funcionalidade pode ser encontrado no saída HBase degrau. o conjunto de resultados filtro guia
permite a filtragem complexa do conjunto de dados.
Veja também
JSON-como em um formato chamado BSON (JSON binário), que permite consultas rápidas e escaláveis.
Java Script Object Notation (JSON), são pares nome / valor que pode ser aninhados para armazenar dados complexos. Outra maneira de
pensar de um documento MongoDB é que eles são semelhantes a uma matriz multidimensional. Como muitos bancos de dados NoSQL, a
estrutura do esquema é dinâmico. Isto significa que os descritores de um conjunto de dados podem ser adicionados, removidos, ou nem
sequer necessário para registos para ser armazenado em um determinado documento.
Preparando-se
Vamos continuar a usar banco de dados de beisebol do Lahman mencionado anteriormente neste capítulo para carregar
MongoDB e depois usá-lo para consultar dados específicos. Antes de podermos fazer qualquer outra coisa, porém,
precisamos ter certeza de que temos uma instância de MongoDB para brincar, quer localmente em uma máquina virtual
ou em outro lugar. Para baixar uma cópia do MongoDB, visite o site http: //www.monodb/org/downloads. Há também alguma
grande documentação lá se quiser avançar além do básico.
129
Trabalhando com Big Data e Fontes nuvem
4. Adicionar um saída MongoDb passo do Big Data categoria. Ligue o entrada de arquivo CSV
passo a ele com um hop. Abra a passo.
5. Aponte para sua instância MongoDB digitando o Nome do host ou endereço IP e Porta
que MongoDB está sendo executado.
8. Interruptor para o campos de documentos Mongo guia e clique em Obter campos. Os campos de fluxo
será preenchida na rede. Clique em ESTÁ BEM.
9. Executar a transformação. Os dados de rebatidas deve ser carregado no banco de dados de beisebol.
Como funciona...
Ao utilizar o saída MongoDB passo, chaleira é capaz de definir o fluxo de dados numa estrutura de documento MongoDB, mesmo se os
dados são encaixados de um modo complexo. Para garantir que a estrutura de dados corresponde ao esquema de uma loja de documento
já existente, há um recurso extra na campos de documentos Mongo aba chamada estrutura do documento pré-visualização que irá
mostrar-estrutura de dados do documento, de modo que se o caminho do documento Mongo coluna precisa ser ajustado de antemão, o
desenvolvedor pode fazê-lo. Lembre-se, o passo não será necessariamente falhar se a estrutura do documento não corresponde. Ele irá
carregar uma estrutura ruim direita ao lado do boa estrutura, porque MongoDB só vê os dados. Observe também que a maioria dos
bancos de dados NoSQL não são definidos como um compatível com ACID. ÁCIDO é o padrão usado para determinar se os dados serão
perdidos, substituídos, ou de outro modo manipulado de uma maneira controlada. Enquanto MongoDB e outros bancos de dados NoSQL
oferecer enormes aumentos no desempenho para consultar enormes conjuntos de dados, ele vem com algum custo.
Veja também
capazes de filtrar os dados para produzir um subconjunto menor de uma loja de documento de origem.
Preparando-se
Vamos estar puxando um subconjunto de dados do conjunto de dados de rebatidas carregado a partir de banco de dados de
beisebol do Lahman na receita, Carregando dados em MongoDB. Ele também será benéfico para ler mais sobre o modelo de
dados do MongoDB. Há uma boa visão geral fornecido pelo site MongoDB em http://docs.mongodb.org/manual/core/data-modeling/.
130
Capítulo 3
2. Sob a Big Data categoria, selecione o input MongoDb passo e trazê-lo mais para
a tela.
4. Digite beisebol para o Base de dados campo e no críquete para o Coleção campo.
6. Para o expressão campos (JSON) campo, insira {" playerid ": 1, "yearID": 1," G_
rebatidas ": 1}. Este está dizendo MongoDB para incluir apenas a playerid, yearID, ID da equipa, e G_batting
Campos.
7. Clique em visualização para visualizar uma amostra do conjunto de dados filtrados. Repare que os dados é
8. Os dados devem ser traduzido do JSON para Kettle para ser capaz de fazer mais com ele. Debaixo de Entrada categoria,
encontrar o Json Input passo e adicioná-lo para a tela. Adicionar um salto a partir do MongoDB Input passo para o Json Input degrau.
9. Abrir a Json Input degrau. Clique no Fonte é definido em um campo? checkbox para true.
o Obter fonte do campo suspensa deve ter a json campo selecionado que foi criado com o MongoDB
Input degrau.
10. Mude para o Campos separador e introduzir os dados de fluxo como mostrado na
imagem seguinte:
11. Clique no ESTÁ BEM. Adicionar um Saída de arquivo de texto passo e adicionar um hop entre a Json Input degrau
12. Abrir o Saída de arquivo de texto passo e dar um caminho de arquivo para o arquivo de saída.
13. Interruptor para o Campos guia e clique em Obter Fields. Isto irá preencher a grade com a
campos de fluxo.
14. Salvar e executar a transformação. Agora você tem um arquivo listando o playerid s e o
anos em que bateu em mais de 10 jogos.
131
Trabalhando com Big Data e Fontes nuvem
Como funciona...
o MongoDB Input passo é capaz de traduzir consultas JSON (que são a forma padrão de consulta MongoDB) e puxar os dados de volta para a
corrente. O conjunto de resultados é também uma matriz JSON que precisa de apenas um toque mais interpretação antes que possa ser mais
utilizado por Chaleira, assim que um Json Input etapa é necessária para transformar a matriz JSON em algo mais manejável. A partir daí,
podemos utilizar todas as capacidades do chaleira para transformar e purificar os dados para coincidir com as nossas necessidades.
Veja também
132
4
Manipulação de
estruturas XML
Introdução
XML (Extensible Markup Language) é uma linguagem de marcação utilizada para descrever os dados em um formato que os seres
humanos e máquinas possam entender; o oposto de HTML que foi projetado apenas para exibir dados em um navegador web. É uma
linguagem auto-descritiva porque suas marcas não são predefinidas. documentos XML não são usados apenas para armazenar dados,
mas também para a troca de dados entre sistemas.
Manipulação de estruturas XML
XML é recomendado por W3C (World Wide Web Consortium). Você vai encontrar os detalhes no seguinte URL: http://www.w3.org/XML/.
PEDI (Integração de dados Pentaho) tem um rico conjunto de passos e as entradas de trabalho para manipular estruturas
XML. As receitas neste capítulo são destinadas a ensiná-lo a ler, escrever e validar XML usando esses recursos.
A maioria das receitas são baseadas em um banco de dados com livros e autores.
Para saber mais sobre a estrutura do banco de dados, consulte o Apêndice A,
estruturas de dados, ou os exemplos
Capítulo 1, Trabalhando com bancos de dados.
As receitas supor que você sabe o básico de XML, que é, você sabe o que é XML, o que é um atributo, e assim por
diante. Se você não fizer isso, você deve começar por ler algo sobre isso antes de prosseguir. O tutorial a seguir é um
bom começo: http://www.w3schools.com/xml/.
PEDI tem uma etapa chamada Obter dados XML usado para ler estruturas XML. Esta receita mostra como ler um arquivo XML contendo
informações sobre os museus que usam este passo.
Preparando-se
Neste exercício, você vai usar um arquivo chamado museum.xml com a seguinte estrutura:
<museus>
<Museu id_museum = '...'>
<Name> ... </ name> <cidade> ...
</ city> <país> ... </ país> </ museu> </
museus>
Nós estaremos fazendo uso de Caminho, que é usado para consultar documentos XML para recuperar e calcular
informações. Se você é novo para Path, recomenda-se verificar os excelentes tutoriais sobre a http://www.w3schools.com/xpath/
para obter uma melhor compreensão do Caminho antes de cavar para a receita.
134
Capítulo 4
3. De acordo com o Arquivo guia, você deve selecionar o documento XML. Procure o arquivo museus.
xml e clique no Adicionar botão.
4. Sob o Conteúdo guia, tipo / museus / museu no Caminho caixa de texto Loop. Isso vai
ser o atual node.text caixa
Debaixo de Campos guia, você precisa especificar os campos usando a notação Path. Use o obter Campos
botão para obtê-los automaticamente. Você deve obter um resultado semelhante ao seguinte:
No caso de atributos XML, se você incluir o caractere @ no caminho como um prefixo (por exemplo, @ id_museum),
não é necessário para selecionar Atributo debaixo de Elemento
coluna. O caractere @ é utilizado em Caminho para indicar que um atributo está sendo consultado para: Fazendo uma prévia
135
Manipulação de estruturas XML
Como funciona...
o Obter dados XML passo permite ler dados em formato XML usando uma especificação de caminho. Nesta receita, você leu um único
arquivo. No entanto, como em qualquer etapa de entrada, você tem a opção de ler um diretório inteiro, vários arquivos, ou mesmo usar uma
expressão regular para especificar quais arquivos para ler. Alternativamente, você pode usar esta etapa para ler estruturas XML a partir de
outras fontes, tais como campos ou URLs. Para mais detalhes, consulte a seção dados XML em um campo mais tarde nesta receita. Para
contar Kettle onde obter os campos, a primeira coisa que você tem a fazer é preencher o
Caminho de loop caixa de texto. Você pode fazer isso digitando-a ou clicando no Obter nós de caminho botão e
selecionando-o na lista de nós disponíveis. Para gerar o conjunto de dados, Kettle vai varrer o nó seleccionado.
Para cada elemento que coincide com o nó selecionado, Chaleira irá gerar uma
nova linha.
o Caminho e Elemento colunas na Campo grade são os campos utilizados para definir a origem dos campos. O caminho deve ser
relativo ao nó atual. o Elemento coluna simplesmente diz Kettle se o elemento é um nó ou um atributo. O restante das colunas na
grade deve ser preenchido, tal como faria em qualquer etapa de entrada, fornecendo o tipo, o formato, e assim por diante. Se você
estiver usando este passo para a leitura de um arquivo, você tem a opção de preencher essa grade automaticamente, clicando no
Tem mais...
Por padrão, os arquivos XML são interpretados através de codificação unicode. Se nenhum for especificado, você tem a
opção de selecionar a codificação sob o Conteúdo aba. Para mais informações sobre codificação, siga o link no http://en.wikipedia.org/wiki/Character_encoding.
Se você tem grandes arquivos XML, em seguida, ver as recomendações de http://wiki.pentaho.com/ display / EAI / Get +
dados + de + XML + - + Manipulação + arquivos grandes +.
Em algumas situações, você não tem o XML como um arquivo, mas como um campo em seu conjunto de dados. Um exemplo disso é
uma transformação, onde você chamar um serviço web que retorna o resultado no formato XML. Nestas situações, em vez de
especificar o nome do arquivo, você deve completar a secção
XML fonte do campo debaixo de Arquivo guia do Obter dados de XML degrau. Verificando a opção
XML fonte é definido em um campo? permitirá a lista suspensa chamada get source XML a partir de
um campo. A partir dessa lista, você tem que selecionar o campo que contém os dados em formato XML.
136
Capítulo 4
O resto das guias devem ser preenchidos exatamente como quando você lê um arquivo. A principal diferença é que o obter campos botão
não será habilitado. Conseqüentemente, você terá que preencher a grade manualmente, ou siga esta dica:
Pode acontecer que a sua estrutura XML está em um arquivo, mas você não sabe o seu nome com antecedência. Se o nome do
arquivo está em um campo, você ainda pode lê-lo usando a Obter dados de XML degrau. Para ler o arquivo, você deve completar a
secção fonte XML do campo debaixo de Arquivo guia do Obter dados de XML degrau. Verifique as duas opções: fonte XML é definido
em um campo? e
XML fonte é um nome do arquivo?. o get source XML a partir de um campo lista suspensa será preenchida com os nomes dos campos de
entrada. A partir dessa lista, selecione o campo que contém o nome do arquivo. Como na seção anterior, o obter campos botão será
desativado. Para obter conselhos sobre o preenchimento do
Campos grelha, ler a ponta anterior.
Veja também
Se você pretende ler ou escrever estruturas XML, é obrigatório que você entender pelo menos o básico de Caminho, o idioma
para encontrar informações em um documento XML, ou definir partes de um documento XML. Nesta receita você será
introduzido para a notação de caminho, de modo que você vai achar que é mais fácil trabalhar com o resto das receitas no
capítulo. Suponha que você tenha uma estrutura XML, como o seguinte:
<Ferida>
<data>
<Pedido>
<Type> Cidade </ type>
<Query> Buenos Aires, Argentina </ query>
</ Request> <current_condition>
137
Manipulação de estruturas XML
. . .
</ Current_condition> <tempo>
. . .
</ Data>
<data>
. . .
</ Data>
. . .
</ Ferida>
Essa estrutura contém a previsão do tempo para um grupo de cidades. Para cada cidade, você tem o tempo atual ea
previsão para os próximos três dias.
O XML amostra foi obtida usando uma API de tempo local livre.
Para saber como usar essa API, visita
www.worldweatheronline.com. Note-se que a amostra é uma versão
ligeiramente modificada do resultado original.
Agora, você quer para especificar o caminho para os seguintes dados (destacado na estrutura da amostra):
f Cidade
f tempo de observação
fA inscrição tempo
138
Capítulo 4
Preparando-se
Esta receita é teórica e tem a finalidade de ajudá-lo quando é hora de introduzir uma notação Path. Você não vai desenvolver
uma transformação aqui. No entanto, para uma melhor compreensão do que está sendo explicado, você pode fazer o
seguinte:
3. Tente introduzir as notações diferentes caminhos no Campos grade, como eles são explicados.
4. Para verificar se você está entrando as notações corretos, fazer uma pré-visualização e verificar por si mesmo.
1. Escolha o nó que será a base para a especificação de seus campos. Nos dados de exemplo, o nó estará / ferida /
dados.
2. Olhe para a estrutura XML para ver se ele é um nó ou um atributo. Nos dados da amostra, a escala de temperatura e
as unidades para a velocidade do vento são atributos. O resto dos campos são nós.
3. Identificar a localização absoluta do elemento, isto é, o caminho completo do elemento de raiz para o elemento
desejado. Por exemplo, para cidade a localização absoluta seria
/ Ferida / data / pedido / consulta. Se o elemento é um atributo, prepend @ ao nome.
4. Identificar a localização em relação ao nó base identificado no passo 1. Por exemplo, para a cidade a
localização relativa seria pedido / consulta. Se o elemento é um atributo, prepend @ ao nome.
observation_time observation_time
139
Manipulação de estruturas XML
As localizações anteriores são as notações caminho para os dados selecionados na estrutura XML amostra.
Como funciona...
Caminho é um conjunto de regras utilizadas para a obtenção de informações a partir de um documento XML. Path trata de uma estrutura XML
como uma árvore de nós. A árvore pode ser comparado a uma árvore de diretórios em seu sistema. A maneira como você especificar locais
relativas ou absolutas em que a árvore é a mesma em ambos os casos. Em Chaleira, você usar o caminho tanto para a obtenção de dados de
A razão para especificar locais tanto absolutos e relativos na receita é que em Kettle você precisa de um ou outro,
dependendo do que você está fazendo. Por exemplo, quando você lê uma estrutura XML, você tem que selecionar um nó e
definir os campos como localizações relativas a esse nó. Quando você junta duas estruturas XML, a declaração caminho que
você precisa especificar uma localização absoluta.
Tem mais...
As notações de Caminho na receita são os mais simples notações caminho que você vai encontrar, mas Path permite
escrever expressões muito complexas. As próximas seções lhe fornecer mais detalhes sobre como especificar os nós com
a notação Path. Para mais informações sobre Path, você pode seguir este link: http://www.w3schools.com/Path/ ou ver a
recomendação do W3C:
http://www.w3.org/TR/xpath.
Então, para obter a localização em relação ao nó atual, basta cortar / ferida / data / e você começa
current_cond / weatherDesc.
Se os dados que você precisa não está na árvore abaixo do nó selecionado, você tem que usar a notação .., que é
usado para especificar o pai do nó atual. Por exemplo, suponha que o nó atual é / ferida / data / current_cond e você
quer saber o nome da cidade para a qual esta condição pertence. o cidade elemento não está dentro do nó
seleccionado. Para alcançá-lo, você tem que digitar ../ request / cidade.
140
Capítulo 4
Estas linhas pertencem ao Celsius e a Fahrenheit escalas respectivamente. Ambas as linhas compartilham a mesma notação Path.
Suponha que você está interessado na linha Celsius. Para obter esse elemento, você tem que usar um predicado. Um predicado é uma
expressão usada para encontrar um nó específico ou um nó que contém um valor específico. Neste caso, você precisa de um predicado
para encontrar um nó que contém um atributo chamado escala com valor C. A notação para conseguir que o nó é temp [escala @ = 'C'].
Em geral, para a obtenção de um nó que contém um valor específico, a notação é Path [condição],
isto é, a expressão caminho seguido pela condição dentro de parêntesis.
Agora, vamos torná-lo um pouco mais complicado. Suponha que você nem sequer sabe que escala para retornar porque a
escala é parte da estrutura do XML, como mostrado no exemplo a seguir:
<Pedido>
<Type> Cidade </ type>
<Query> Buenos Aires, Argentina </ query>
<PreferredScale> C </ preferredScale>
</ Request>
Cada cidade terá sua própria escala preferido e você deve retornar a temperatura em Celsius ou Fahrenheit, dependendo
escala preferencial da cidade. O que você precisa é um predicado dinâmico. A maneira de implementar isso é através do uso
de uma extensão não-padrão chamado fichas.
Vamos explicar isso com base em nosso exemplo:
1. A primeira coisa que você precisa fazer é adicionar o campo em que o token é baseado:
preferredScale. Então, adicione um campo denominado preferredScale e para Caminho, digite ../
request / preferred_scale.
2. Em seguida, adicione um novo campo para a temperatura na escala desejada. Para Nome, tipo
temperatura e como Caminho tipo ../ temp [@scale = @ _ PreferredScale -] / text ().
3. Finalmente, sob o Conteúdo guia, cheque Use fichas. Se não o fizer, isso não vai funcionar!
141
Manipulação de estruturas XML
PEDI vai construir um predicado dinâmica, substituindo cada < tokenized_field> pelo seu valor atual e, em seguida, retornar
o valor do nó apropriado.
<Tempo>
<Data> 2010-10-24 </ data>
<tempMaxC> 23 </ tempMaxC>
. . .
</ Weather>
<tempo>
<Data> 2010-10-25 </ data>
<tempMaxC> 23 </ tempMaxC>
. . .
</ Weather>
<tempo>
<Data> 2010-10-26 </ data>
<tempMaxC> 24 </ tempMaxC>
142
Capítulo 4
Suponha que você quer ler todos eles. Neste caso, você tem que usar um predicado apenas como explicado na
seção anterior. Neste caso, o predicado não é usado para encontrar um nó que contém um valor específico, mas
para encontrar os nós por posição, você precisa primeiro, segundo e terceiro clima nós. A notação que você tem que
usar é Path [posição], isto é, a expressão caminho seguido pela posição do elemento desejado dentro de parêntesis.
No exemplo, a notação para o primeiro, segundo, e terceiro clima nós seria
tempo [1], tempo [2], e tempo [3] respectivamente. Para obter os nós dentro aqueles, a notação é como de
costume. Por exemplo, para obter a data do segundo nó, você deve escrever tempo [2] / data.
Note que se você está lendo uma estrutura XML, cada elemento que você começa usando esta notação pode ser usada
como uma nova coluna no conjunto de dados. Em vez disso, se você deseja gerar uma linha diferente para cada clima nó,
então você deve tomar uma outra abordagem: em vez de usar essa notação, basta alterar o nó atual ( Caminho de loop elemento)
de / ferida / dados
para / ferida / data / tempo.
f Ele terá apenas os campos que estão abaixo do nó que você digitou como Path Loop.
f Ele vai trazer todos os elementos. Para obter elementos selectivamente, como na temperatura
exemplo acima, você terá que modificar a grade manualmente.
que você vai economizar tempo, mas na maioria das vezes, você ainda terá que ajustar os dados na grade manualmente.
f Elas devem conter um único elemento de raiz-isto significa uma única abertura e fechamento
tag para todo o documento.
143
Manipulação de estruturas XML
f As tags são case-sensitive, isto significa que início e etiquetas terminam jogo
(Por exemplo, < exemplo Tag> </ example Tag> contra < exemplo Tag> </ Exemplo Tag>). O
segundo conjunto tag irá lançar um erro.
Nesta receita você vai aprender a validar se um documento é bem formado, que é o tipo mais simples de validação XML.
Suponha que você deseja extrair dados de vários documentos XML com informações do museu, mas apenas deseja
processar os arquivos que são bem formados.
Preparando-se
Para usar esta receita, você precisa de um conjunto de arquivos XML em um diretório chamado museus. Esta receita lê um diretório
contendo três arquivos, onde o primeiro tem uma etiqueta de erro intencional. Você pode baixar os arquivos de exemplo do site da
Packt.
2. Gota um Verifique se XML está bem formado entrada da XML categoria na tela.
3. De acordo com o Geral guia, você deve digitar o caminho para o museu diretório no
fonte de arquivo / pasta caixa de texto, e tipo. + \. xml no curinga caixa de texto, a fim de utilizar apenas os arquivos com
a extensão. xml extensão.
144
Capítulo 4
6. Em seguida, crie uma nova transformação, a fim de processar os arquivos XML bem formados obtidos a partir da entrada de trabalho
10. Sob a Conteúdo guia, tipo / museus / museu no Caminho de loop caixa de texto.
11. Finalmente, a grade sob a Campos separador deve ser completada manualmente, como mostrado na
imagem seguinte:
12. Quando você executa o trabalho, você vai obter o museus dataset com a vinda somente os dados
a partir dos arquivos XML bem formados. Você pode dar uma olhada no Exploração madeireira janela para verificar isso.
Você verá algo como o seguinte:
2010/11/01 11:56:43 - Verifique se o arquivo XML está bem formado - ERROR (versão 4.1.0, construir 13820
de 2010-08-25 07.22.27 por tomcat): Erro ao verificar arquivo [file: // /C:/museums1.xml]. exceção:
2010/11/01 11:56:43 - Verifique se o arquivo XML está bem formado - ERROR (versão 4.1.0, construir 13820
de 2010-08-25 07.22.27 por tomcat): org.xml.sax.SAXParseException:
Tipo de elemento museu deve ser seguido por atribuir especificações,> ou />.
13. Além disso, você pode ver na Exploração madeireira janela que apenas dois arquivos em cada três eram lidas:
145
Manipulação de estruturas XML
Como funciona...
Você pode usar o Verifique se o XML é bem-formado entrada de trabalho para verificar se um ou mais arquivos XML são bem-formado.
Na receita o trabalho valida os arquivos XML do diretório de origem e cria uma lista com apenas os arquivos XML válidos.
Como você viu na janela de registo, apenas dois arquivos foram adicionados à lista e usado mais tarde na transformação. O
primeiro arquivo ( C: /museums1.xml) teve um erro; não foi bem-formado e por isso não foi adicionado à lista de arquivos. o Obter
arquivos de resultado passo na transformação obtém a lista de documentos XML bem formado criados no trabalho. Então uma Obter
dados de XML passo ler os arquivos para processamento adicional. Observe que, nesse caso, você não definir os nomes dos
arquivos de forma explícita, mas usou o campo caminho proveniente do passo anterior.
Veja também
Por exemplo, suponha que você tenha um arquivo XML com informações do museu, como segue:
<museus>
<Museu>
<Name> Fundacion Federico Klemm </ name> <cidade>
Buenos Aires </ cidade> <país> Argentina </ país> </ museu>
146
Capítulo 4
<! DOCTYPE museus [<! Museus Elemento (Museu +)> <! Museu
ELEMENT (nome +, cidade, país)> <! Nome do elemento
(#PCDATA)> <! ELEMENT cidade (#PCDATA)> <! ELEMENT país
(#PCDATA )>
Com esta definição, você está declarando os elementos da estrutura museu: nome, cidade, e
país, e definindo o atributo id_museum como requerido.
Preparando-se
Para esta receita, você precisa de um museum.xml documento com a definição DTD incluído. Você pode baixá-lo do
site da Packt.
Você pode ter a definição DTD como um arquivo independente ou dentro do documento XML. Se o DTD é declarada
dentro do arquivo XML, ele deve ser envolto em um DOCTYPE definição com a seguinte sintaxe: <! DOCTYPE -raiz elemento [elemento
declarações]>.
3. Aqui, você deve apontar para o arquivo XML na O nome do arquivo XML caixa de texto.
5. Execute este trabalho, para que os dados XML fica validado contra as definições DTD, que são dentro do arquivo
XML.
147
Manipulação de estruturas XML
6. Você pode ver o resultado da validação, incluindo informações sobre os erros sob a
Exploração madeireira guia no resultados da execução janela. Neste caso, os resultados são os seguintes:
Como funciona...
o DTD Validador entrada de trabalho faz toda a tarefa de validar um arquivo XML contra uma definição DTD. Na receita, você verificou
o DTD Intern checkbox porque as definições DTD estavam dentro do arquivo XML. Caso contrário, você deve preencher o DTD Nome
do arquivo caixa de texto com o nome do arquivo DTD apropriada.
Tem mais...
DTD tem uma série de limitações. Por exemplo, você não pode definir os tipos para os elementos XML ou atributos. Se você precisar de
mais flexibilidade, mais um passo que pode ser usado é o XSD validatior degrau.
Veja também
Nesta receita, você vai aprender como usar o XSD Validador passo, a fim de verificar uma estrutura particular, utilizando um XML XSD
(XML Schema Definition). Por exemplo, você irá usar um banco de dados de livros (com a estrutura mostrada na Apêndice A,
Estruturas de Dados) e um arquivo de esquema XSD com os livros, estrutura. Você deseja validar cada elemento livro contra o
arquivo de esquema XSD.
148
Capítulo 4
<Xs: complexType>
<xs: sequence>
<Xs: element name = "título" type = "xs: string" /> <xs: element name = "gênero"
type = "xs: string" /> <xs: element name = tipo "preço" = "positiveDecimal" /> <xs:
element name = tipo de "autor" = "xs: string" /> </ xs: sequence>
<Xs: attribute name = tipo "id_title" = "idTitle" /> </ xs: complexType> </ xs:
element> </ xs: schema>
149
Manipulação de estruturas XML
Preparando-se
Você precisa de um banco de dados com os livros e autores da informação. Você também vai precisar do esquema XSD como um arquivo
separado. Você pode baixar o arquivo do site da Packt. Uma vez que estamos validando os dados contra um XSD, precisamos editar um par
de registros na tabela de livros do banco de dados de livros:
2. Gota um Entrada Tabela passo e fazer uma seleção a partir do livros banco de dados com o
declaração seguinte:
id_title SELECIONAR
, título
, gênero
, preço
, concat (sobrenome, "", nome) autor dos livros LEFT JOIN
autores
EM authors.id_author = books.id_author
3. Use o Adicionar XML passo do Transformar categoria, a fim de criar uma nova coluna
com os dados de cada livro em formato XML.
4. Sob o Conteúdo guia, tipo xmlBook em Valor de saída e livro Como Raiz
XML elemento.
5. Sob o Campos guia, use o obter Campos botão para preencher a grade automaticamente.
modificar o Atributo campo para o id_title linha para Y. Em seguida, modificar o Formato e
Decimal campos para o preço fila, como mostrado na imagem seguinte:
150
Capítulo 4
6. Se você faz uma prévia neste passo, então você verá uma nova coluna com uma estrutura XML para cada livro. O
seguinte é uma estrutura XML de exemplo criado com esta etapa:
A estrutura é mostrado em várias linhas para maior clareza. Na pré-visualização, você vai ver a
estrutura em uma única linha.
8. No campo XML localizado sob o Definições guia, seleccionar a coluna xmlBook que você criou no passo
anterior.
9. De acordo com a mesma guia, completar o Campos de saída quadro, como mostrado na
imagem seguinte:
10. No XSD Fonte listagem no interior da XML Schema Definition quadro, selecione a opção
é um arquivo, deixe-me especificar nome do arquivo.
151
Manipulação de estruturas XML
11. Em seguida, no XSD Matrícula caixa de texto, digite ou selecione o books.xsd Arquivo. Quando você
executar esta transformação, você vai obter o conjunto de dados com livros junto com um campo que indica
o resultado da validação e a mensagem de validação em caso de falha. Supondo que você tenha
introduzido os erros do Preparando-se seção, a sua base de dados final será semelhante ao mostrado na
imagem seguinte:
Como funciona...
Um arquivo XSD define um conjunto de regras para a validação de um documento XML. Um arquivo XSD permite verificar
se um documento, escrito em formato XML, é bem formado e também respeita essas regras. Neste exemplo, você criou uma
nova coluna com cada livro em formato XML, e depois aplicada a XSD Validador passo para verificar esta coluna contra a books.xsd
arquivo de esquema. No resultado de sua transformação, você poderia ver que um livro não segue o padrão esperado para
o id_title campo, porque não contêm um hífen. Nesse caso, você obteve a seguinte mensagem:
Além disso, um livro tinha um preço incorreto (um negativo). Nesse caso, você tem o seguinte erro:
Tem mais...
Na receita, você usou o Validação XSD passo para validar uma estrutura XML, que por sua vez foi feita a partir de um campo numa base
de dados. Em geral, você pode usar esta etapa para validar qualquer estrutura XML, ambos fornecidos como um campo, ou salvos em um
arquivo.
Nos casos em que você deseja validar um arquivo, você também pode tirar proveito da mesma funcionalidade de uma entrada de trabalho
nomeado Validação XSD dentro de XML categoria. A configuração dessa entrada é simples, é só definir os caminhos para o arquivo XML e
o arquivo de esquema XSD.
152
Capítulo 4
Você pode aprender mais sobre XSD a partir do seguinte URL: http://www.w3.org/TR/ xmlschema-0 /.
Veja também
Preparando-se
Você vai precisar de um livros base de dados com a estrutura descrita em Apêndice A, Estruturas de Dados.
id_title SELECIONAR
, título
, gênero
, preço
, concat (sobrenome, "", nome) autor dos livros LEFT JOIN
autores
EM authors.id_author = books.id_author
4. No Nome do arquivo caixa de texto do Arquivo guia, digite o nome do arquivo de destino, incluindo seu caminho
completo (sem extensão). No Extensão caixa de texto, deixe o valor padrão, xml.
5. Encha o Conteúdo guia como elemento XML pai, tipo livros e como o XML Row
elemento, tipo Livro.
153
Manipulação de estruturas XML
6. Sob o Campos guia, use o obter Campos botão para obter os campos. No preço campo,
colocou o Formato para US $ 0.00.
7. Execute a transformação e olhar para o arquivo XML gerado. Ele deve parecer com o seguinte:
<Books>
<Book>
<Id_title> 123-346 </ id_title> <title> Carrie </ title>
<gênero> Ficção </ gênero> <price> $ 41,00 </
price> <author> King, Stephen </ author> </ Book>
<Book>
Como funciona...
o saída XML etapa faz toda a tarefa. Ele cria o arquivo XML com linhas que entram na corrente, usando o elemento
XML pai e elemento XML Row valores para completar a estrutura do arquivo XML. Abrange cada linha entre as
tags com o nome fornecido para
elemento XML Row (< book> e </ Book>), e toda a estrutura entre as tags com o nome fornecido para elemento
XML pai (< livros> e </ Livros>).
o saída XML passo tem algumas propriedades em comum com outros passos de saída. Por exemplo, há a opção de adicionar
a data e hora como parte do nome do arquivo ou para dividir a saída em vários arquivos usando o Dividir cada ... linhas caixa
de texto a partir do Conteúdo aba.
Tem mais...
Na receita, você escreveu a informação XML em um arquivo, mas você pode querer ter a informação em formato XML
como uma nova coluna do conjunto de dados. A seção seguinte explica como fazer isso.
154
Capítulo 4
o Adicionar XML passo codifica vários campos em um fragmento XML. Nesta etapa, você deve definir
XML raiz elemento ( por exemplo Livro) e o nome para a nova coluna. o Campos guia é bastante semelhante ao do
mesmo na saída XML passo, mas aqui você também pode especificar se o elemento é um nó ou um atributo. No
exemplo, você pode definir o campo id_title como um atributo do elemento Livro, conjunto Atributo Como Y e Nome do
atributo pai Como Livro, e você terá a seguinte estrutura XML:
Esta etapa é particularmente útil para a geração de estruturas complexas, como você verá na próxima receita.
Veja também
<Result>
<autores>
<Autor id_author = ...>
<Sobrenome> ... </ lastname> <firstname> ...
</ firstname> <nacionalidade> ... </
nacionalidade> <birthyear> ... </ birthyear>
<books>
155
Manipulação de estruturas XML
Preparando-se
Nesta receita que você irá usar um banco de dados de livros com a estrutura mostrada na Apêndice A, Estruturas de Dados.
4. Para criar a estrutura XML raiz, adicionar um Adicionar XML passo do Transformar
categoria. Nome este passo Criar estrutura de raiz XML.
5. Sob o Conteúdo separador desta etapa, tipo xmlResult no Valor de saída caixa de texto, e
resultado no elemento XML raiz caixa de texto.
6. Sob o Campos guia, adicione o único campo que você tem: autores. Não se esqueça de definir
o tipo Corda. Se você fizer uma pré-visualização on Nesta etapa, você verá um novo campo chamado
xmlResult com as seguintes informações:
156
Capítulo 4
1. Elimine a Entrada Tabela passo para a tela, e selecione o autores utilizando a tabela
seguinte instrução SQL:
SELECT * FROM
authors
3. Adicione outro Adicionar XML degrau. Nome este passo como Criar Autores XML.
4. Sob o Conteúdo guia, tipo autor para elemento XML raiz e xmlAuthors para
a Valor de saída.
5. Clique no obter Campos botão para adicionar à rede todos os campos (incluindo o vazio
livros campo). Para o id_author campo, selecione atributo Como Y. Fazendo uma prévia sobre esta etapa, para cada
autor você vai ver algo como o seguinte:
Na pré-visualização, você vai ver a estrutura XML em uma única linha. Nos exemplos, as estruturas são mostrados ao longo de várias
linhas e recuado apenas para melhor compreensão. Agora, você precisa inserir os dados dos autores dentro da estrutura da raiz XML
1. Adicione uma XML Junte passo do Junte-se categoria e usá-lo para ligar os fluxos, como mostrado
na imagem seguinte:
157
Manipulação de estruturas XML
4. No campo XML resultado dentro de Propriedades resultado Corrente tipo de moldura xmlauthors2.
5. Faça uma prévia desta etapa. Você vai ver que há um novo campo chamado xmlauthors2
contendo a estrutura XML para o XML de raiz e os autores. Além disso, note que há uma tag vazia com o
nome livros para o nó de cada autor:
<Result>
<autores>
<Autor id_author = "A00001">
<Sobrenome> Larsson </ lastname> <firstname> Stieg </
firstname> <nacionalidade> Swedish </ nacionalidade>
<birthyear> 1954 </ birthyear> <livros /> </ author>
. . . </ Author>
. . .
</ Autores> </
result>
158
Capítulo 4
Finalmente, é hora de criar a estrutura do XML para os livros e fundi-los com a estrutura principal:
1. Elimine a A introdução da tabela entrar na tela, a fim de selecionar todos os livros. Use o
seguinte instrução SQL:
* SELECT FROM livros
ORDER BY título
2. Adicionar um Adicionar XML degrau. Nome este passo como Criar Livros XML.
3. De acordo com o Conteúdo guia, tipo livro no elemento raiz XML caixa de texto e xmlBooks em
a Valor de saída caixa de texto.
4. Sob o Campos guia, use o obter campo botão para obter todos os campos. selecionar atributo
Como Y para o id_title campo. Além disso, para o preço campo, definir Formato para US $ 0.00.
5. Faça uma prévia sobre este passo. Você verá um novo campo XML chamado xmlBooks com o
dados do livro. Por exemplo:
6. Finalmente, você deve fazer o último merge; desta vez entre a saída do fundir
Autores e XML raiz passo e a saída do recentemente criado Criar Livros XML degrau. Adicionar mais uma XML
Junte passo e ligar estas duas etapas. A transformação deve ser semelhante ao seguinte:
159
Manipulação de estruturas XML
9. Você pode fazer uma previsão sobre esta última etapa e você vai obter algo como o seguinte:
<Result>
<autores>
. . .
<Autor id_author = "A00002">
<Sobrenome> King </ lastname> <firstname> Stephen </
firstname> <nacionalidade> American </ nacionalidade>
<birthyear> 1947 </ birthyear> <books>
160
Capítulo 4
Como funciona...
A idéia básica quando você tem que gerar uma estrutura XML complexo é criar saídas XML parciais em diferentes
etapas e, em seguida, usar o XML Junte passo para criar a estrutura mesclada. o XML Junte etapa permite incorporar
uma estrutura XML (com uma ou várias linhas) dentro de outra estrutura XML líder que deve ter apenas uma linha.
Na etapa primeiro unir-se da transformação de exemplo, é combinado o XML que contém a estrutura de raiz vazio com
estrutura XML do autor. Este é um simples juntar-o passo substitui a tag < autores /> da estrutura XML raiz (o fluxo de
destino) com todos os autores que vêm da estrutura XML autor (o fluxo de origem). A expressão Caminho, / Resultado /
autores, diz Chaleira qual nó na estrutura de raiz é para ser preenchido com estrutura do autor. O segundo XML Junte passo
é um pouco mais complexa. Ele combina o resultado do primeiro XML Junte passo ea seleção de livros. Neste caso, você
tem um complexo de participar, porque você precisa para se juntar a cada grupo de livros com seu autor correspondente.
Para fazer isso, você deve digitar a condição da junção com a seguinte expressão Path: / resultado / autores / autor [@
id_author = '?'] / livros. O ? caractere é usado como um espaço reservado. Durante a execução, este personagem vai ser
substituído pelo Junte-se a comparação de campo valor (neste caso, a id_author
valor do campo). Assim, todos os livros em formato XML com um determinado id_author irá substituir a tag
<Livros /> dentro da tag < author> que têm o mesmo id_author. Por exemplo, o seguinte livro de Stieg Larsson
(já convertido para o formato XML) está em uma linha onde
id_author é igual a A00001:
Portanto, esta estrutura será inserido na estrutura XML principal no seguinte caminho:
/ Result / autores / autor [@ id_author = 'A00001'] / livros.
Veja também
161
Manipulação de estruturas XML
XSLT é mais do que apenas a construção de arquivos HTML de XML! Ele atua como um
tradutor, permitindo criar praticamente qualquer tipo de saída de texto desejado. Enquanto
esta receita concentra-se na capacidade de construir HTML, não se esqueça que ele também
pode construir CSV e outros arquivos delimitados, arquivos semi-estruturados, e sim, mesmo
outros arquivos XML! Para saber mais sobre XSLT, consulte a introdução grande tutoriais
sobre a http://www.w3schools.com/xsl.
Suponha que você deseja publicar um catálogo de livros em um site. Nesta receita, você vai gerar uma página HTML, tendo como sua
fonte, os dados que você tem em um banco de dados.
Preparando-se
Você deve ter um banco de dados de livros com a estrutura mostrada na Apêndice A, Estruturas de Dados.
O primeiro grupo de passos é para exportar informações do livro do banco de dados para um arquivo XML. se você já tem a
informação neste formato, então você pode pular para a etapa 7.
2. Gota um Entrada Tabela passo para a tela e selecionar informações do livro. Use o
seguinte instrução SQL:
SELECT * FROM livros
LEFT JOIN autores
EM books.id_author = authors.id_author
4. Preencha o Arquivo guia dando o arquivo o nome livros e deixando o padrão xml Enquanto o
proposta de extensão.
5. Sob o Conteúdo guia, tipo livros em elemento XML pai e Livro em Linha
XML elemento.
162
Capítulo 4
6. Sob o Campos tab, pressione o obter Campos botão, a fim de recuperar a toda
informações de campo. modificar o Preço campo dando-lhe a Format $ 0.00. O resultado destes passos serão um
arquivo chamado books.xml com a estrutura do livro. Ele deve parecer com o seguinte:
<Books>
<Book>
<Title> Carrie </ title> <price> $ 41,00 </ price>
<gênero> Ficção </ gênero> <sobrenome> King </
lastname> <firstname> Stephen </ firstname> </
Book> <Book>
<Tr bgcolor = "lightblue"> <td> Título </ td> <td> Autor </ td>
<Td> Preço </ td> <td> Gênero </ td> </ tr> <xsl:
apply-templates select = "Book">
<Xsl: sort escolha = "título" /> </ xsl:
apply-templates> </ table> </ body> </ html> </ xsl:
template>
163
Manipulação de estruturas XML
<Td> <xsl: value-of select = "título" /> </ td> <td> <xsl: value-of select = "sobrenome" />,
<xsl: value-of
selecionar = "nome" /> </ td> <td> <xsl: value-of select =
"preço" /> </ td> <td> <xsl: value-of select = "gênero" /> </ td > </ tr>
</ xsl: template> </ xsl: stylesheet>
Você pode economizar muito tempo baixando o arquivo XSL amostra do site da
Packt!
2. Adicione uma Transformação entrada para executar a transformação anterior. Adicionar um XSL
Transformação entrada de trabalho do XML categoria. Colocou o arquivos quadro para o seguinte:
3. Execute o trabalho. Um arquivo chamado Books.htm será criado, com a seguinte disposição:
164
Capítulo 4
Como funciona...
XSL é usado para transformar e tornar documentos XML. Nesta receita, você gerou um arquivo XML com informações do livro e, em
seguida, usou um arquivo XSL para transformar o arquivo XML em uma página HTML. Olhando para o arquivo XSL, você pode ver
como ele transforma os campos da fonte em um código HTML. O arquivo tem seções diferentes, que são as seguintes:
f Uma seção para o cabeçalho: a < table> de etiqueta com uma fileira contendo cabeçalhos do campo
fO modelo Livro, que cria uma nova linha com os valores do campo para aplicar a transformação definida no
arquivo XSL de forma eficaz, você usou o Transformação XSL entrada de trabalho. A configuração da entrada é
simples; você simplesmente fornecer nomes do arquivo XML, o arquivo XSL, e o arquivo resultante, e está feito.
Tem mais...
Como opção, logo após a criação da página, você pode publicá-lo automaticamente no site. Para fazer isso, simplesmente
estender o trabalho com uma entrada de transferência de arquivo. Você vai encontrar mais informações sobre XSL em http://en.wikipedia.org/wiki/XSLT.
Veja também
Preparando-se
Para esta receita, nós estaremos usando um feed RSS do site da Packt Publicação que apresenta as últimas novidades e
lançamentos. A alimentação está disponível ao https://www.packtpub.com/rss.xml.
Tome um momento e olhar através do feed abrindo o link em um navegador para se familiarizar com os dados antes de
atravessar a receita. Você também pode salvar uma cópia da página e visualizar a estrutura XML.
165
Manipulação de estruturas XML
2. A partir do Entrada seção, selecione uma Entrada RSS passo e adicioná-lo para a tela.
3. Abra o passo RSS Entrada. Na seção Lista URL, adicione o seguinte URL:
https://www.packtpub.com/rss.xml.
4. Mude para o Campos guia e clique no obter Campos botão. Isto irá analisar o RSS
alimentar para todos os campos disponíveis.
5. Adicione uma Filtrar linhas degrau. Na condição, selecione Título como o campo, CONTÉM Enquanto o
avaliação e SQL como o valor. Este irá filtrar todos os registros que não têm SQL no Título campo. Sua
condição linhas de filtro deve parecer com o seguinte:
clique com o botão direito 6. Agora na Filtrar linhas passo e selecione Visualizar. Agora você deve ver apenas
as entradas que contêm SQL em seus títulos.
Como funciona...
Desde um feed RSS é um formato XML padronizado, Chaleira pode analisar o conjunto de dados e fornecer todos os campos que são
disponibilizados dentro dele. Contanto que a alimentação está devidamente formatada, os dados podem ser alimentados em Kettle e
analisado como qualquer outro fluxo de dados. Para saber mais sobre RSS, confira os tutoriais que estão disponíveis via http://www.w3schools.com/rss/.
Veja também
166
Capítulo 4
Preparando-se
Você deve ter um banco de dados de livros com a estrutura mostrada na Apêndice A, Estruturas de Dados.
3. Abra o Entrada Tabela passo e selecione o livros conexão com o banco. Para o SQL
declaração, adicione o seguinte:
SELECIONAR
id_title
, título
, preço
, gênero
, CONCAT (nome, '', sobrenome) AS author_name
, b.create_date AS publish_date
A partir de livros b
Cadastre-autores de um ON b.id_author = a.id_author
5. A partir do Transformação categoria, selecione uma Adicionar constantes degrau. Adicione o seguinte
detalhes para o Campos grade de dados:
167
Manipulação de estruturas XML
6. A partir do Transformação categoria, selecione uma Calculadora degrau. Precisamos definir um novo
campo chamado link_detail, que irá adicionar o campo site e do campo de título juntos para criar um vínculo válido.
os detalhes do campo será semelhante a imagem seguinte:
7. A partir da Saída categoria, selecione uma saída de RSS degrau. No Canal guia, preencha
a título do canal campo com CHANNEL_TITLE, a descrição do canal campo com
descrição do canal, e a link de canal campo com CHANNEL_LINK.
8. No Item guia, queremos incluir os detalhes do livro que correspondem aos valores de fluxo.
Preencha os campos como na imagem seguinte:
10. Executar a transformação. Abra o book_rss.xml arquivo que foi criado e olhar sobre
o feed RSS que foi criado.
Como funciona
Enquanto RSS feeds são um formato XML padronizado, pode ser mais complicado do que a saída típico fluxo de dados de Kettle. RSS
requer alguns valores estáticos para o arquivo a ser criado de forma adequada que adicionado ao fluxo através do Adicionar constantes degrau.
Nós também queríamos nossos links para ser uniforme, por isso criamos o stub link (chamado local na rede Internet) no fluxo, para que
pudéssemos criar links personalizados para cada título do livro.
Cada livro é adicionado como um item individual para o feed RSS em que o título do livro, gênero, data de publicação (que
não é o livro da data de publicação, mas quando o registro foi criado), eo autor são adicionados como elementos. Em um
feed típico, esses detalhes que descrevem os itens na lista e fornecer um link para ler o restante do post ou notícia.
168
Capítulo 4
Tem mais...
o saída de RSS etapa também fornece uma maneira de gerar campos personalizados no feed RSS. Abra o
saída de RSS passo e selecione o saída personalizado aba. Aqui você pode adicionar marcas personalizadas e seus campos
correspondentes a cada canal e item no feed.
Veja também
169
5
Gerenciamento de arquivos
Introdução
Em muitas ocasiões, o desenvolvimento de trabalhos de chaleira e transformações envolve a manipulação de arquivos,
como a leitura ou gravação de um arquivo junto com outras manipulações. Olhe para o cenário de exemplo a seguir, onde
você tem que:
f Gerar um arquivo de log com detalhes dos erros e colocar esse arquivo de log de volta para o servidor
para posterior revisão se as ordens no arquivo não são válidos
Gerenciamento de arquivos
Nesta situação, além de ler e escrever arquivos, você também tem de transferir, mudar o nome, e movê-los.
Copiar, mover, excluir e transferência de arquivos, e listagem de arquivos ou diretórios, são tarefas não só necessários para
estas situações, mas na vida cotidiana. É comum ter monte de arquivos que precisam ser organizados de várias maneiras, e
para diferentes fins.
Chaleira tem um rico conjunto de passos e as entradas de trabalho para fazer isso. No entanto, você pode se perder ou frustrado tentando
escolher e, em seguida, configurar a opção que atenda às suas necessidades. As receitas deste capítulo deve ajudá-lo com essa tarefa.
Preparando-se
Você vai precisar de um diretório chamado sampleFiles contendo um conjunto de arquivos com extensões diferentes,
incluindo. TXT e. xls. Você também vai precisar de três diretórios de destino, nomeados txtFiles, xlsFiles, e Outros
arquivos.
2. Adicione uma Copiar arquivos entrada de trabalho. Nesta entrada, você irá adicionar as indicações para copiar o
arquivos nas três pastas de destino disponíveis. Dê um duplo clique sobre a entrada para abri-lo.
3. No fonte de arquivo / pasta caixa de texto, digite ou navegue para o sampleFiles pasta. No
Arquivo de destino / Pasta caixa de texto, digite ou navegue para o txtFiles pasta. Além disso, o tipo
. * \.TXT no Universal (Regexp) caixa de texto. Clique no Adicionar botão.
4. No fonte de arquivo / pasta caixa de texto, digite ou navegue para o sampleFiles pasta. No
destino do arquivo / pasta, digite ou procure o xlsFiles pasta. Além disso, tipo. * \. xls
no Universal (Regexp) caixa de texto. Clique no Adicionar botão.
5. No fonte de arquivo / pasta caixa de texto, digite ou navegue para o sampleFiles pasta. No destino do arquivo /
pasta, digite ou procure o Outros arquivos pasta. Além disso, o tipo
. + (?! <(Txt | xls)) $ no Universal (Regexp) caixa de texto. Clique no Adicionar botão.
172
capítulo 5
Assumindo que todas as pastas estão dentro do diretório onde você tem o seu trabalho, o Arquivos / pastas
grade será parecido com a tela a seguir:
Chaleira usa Java de Expressões regulares (RegExp) sintaxe onde quer que ele pode ser usado. Além disso, observe que Internal.Job.Filename.Directory
é uma variável Chaleira pré-definido cujo valor é o diretório completo onde o trabalho é salvo. Quando você executa o
trabalho, cada arquivo do sampleFiles pasta, serão copiados para a pasta associada na janela de configurações, dependendo de
sua extensão.
Como funciona...
Você usa o Copiar arquivos entrada de trabalho para executar a tarefa de copiar arquivos. Como você pode ver na receita, você
pode executar várias instruções de cópia com uma entrada única tarefa, introduzindo diferentes linhas no Arquivos / pastas seção do Geral
aba.
Na grade de amostra, você tem três linhas. Para cada linha, o objetivo é copiar todos os arquivos da pasta de origem (primeira
coluna) para a pasta de destino (segunda coluna) que correspondam a expressão regular (terceira coluna). As primeiras e
Os terceiros cópias de linha o restante dos arquivos. A expressão regular que corresponde a esses arquivos é um pouco
mais complexa; os personagens? <! representam uma negação sobre o resto da expressão, então a expressão. + (? <! ( txt
| xls)) $ significa todos os arquivos cuja extensão é nem. TXT nem. xls.
Tem mais...
A receita mostrei-lhe as noções básicas de cópia de arquivos com chaleira. As secções seguintes explicam como adicionar mais
funcionalidades, por exemplo, validando a existência de arquivos ou pastas antes de copiar. Você também verá as configurações extras
disponíveis para o Copiar arquivos entrada de trabalho.
movendo arquivos
Você pode mover o arquivo (em vez de copiar), verificando a Remover arquivos de origem caixa de seleção na Definições sob a secção Geral guia
no Copiar arquivos entrada de trabalho. Se você verificar que, Chaleira irá apagar os arquivos após uma cópia bem-sucedida. Esta é análoga à
utilização de um excluir arquivo entrada de trabalho logo após o Copiar arquivos entrada.
173
Gerenciamento de arquivos
Suponha que você deseja que os arquivos a serem copiados somente se houver uma mistura de extensões de arquivo. Se houver apenas arquivos
do Excel ou arquivos de texto, eles não vão ser copiados e a situação será gravado em um log. A fim de fazer isso, você pode criar uma
transformação que sucede se houver uma mistura de arquivos, ou não, se você tem apenas arquivos Excel ou apenas arquivos de texto.
A transformação deve começar com uma Obter nomes de arquivos passo para obter a lista
de arquivos na pasta, e proceder de forma diferente de acordo com as validações que você
quer fazer.
Então, em seu trabalho, você chamar a transformação antes de copiar os arquivos. A cópia será feita somente após o
sucesso da transformação, como mostrado na figura a seguir:
No caso mais simples onde você tem que copiar arquivos especificados pelo seu nome, isto é exato, não expressa com expressões-lo
regulares podem verificar a sua existência simplesmente com um O arquivo existe
(Para um único arquivo) ou um Verifica se existem arquivos ( para vários arquivos) de entrada.
criação de pastas
Você pode criar o diretório de destino automaticamente, selecionando o Criar pasta de destino caixa de seleção na Definições sob
a secção Geral guia no Copiar arquivos entrada de trabalho. Você também pode criar esses diretórios usando um Crie uma pasta entrada
de trabalho do Gerenciamento de arquivos categoria. A diferença é que, com a Crie uma pasta entrada, você pode detectar se o
diretório já existe; se você não esperava essa situação, você pode agir em conformidade, por exemplo, abortando o trabalho.
Veja também
174
capítulo 5
Chaleira fornece duas entradas de emprego para a exclusão de arquivos: excluir arquivo e Deletar arquivos. Você pode encontrar tanto na Gerenciamento
Nesta receita, você vai ver um exemplo de como excluir um arquivo. Você vai excluir um arquivo que inclui a data atual
como parte de seu nome, por exemplo test_20101020.txt.
Preparando-se
Você deve criar um arquivo de amostra; por exemplo, test_20101020.txt. Certifique-se de usar a sua data atual, em vez
de 20.101.020. Use o mesmo formato ( aaaaMMdd).
3. Dê um clique duplo na etapa e adicione um campo denominado encontro. No Tipo coluna, seleccionar
data do sistema (fixo).
5. A partir do Trabalho categoria, adicione um definir variáveis degrau. Dê um duplo clique sobre ele e preencher a grade,
6. A transformação está pronto. Salve isso. Agora, crie um novo emprego e soltar um Começar entrada.
7. Adicione uma Transformação entrada de trabalho e configurá-lo para executar a transformação criado
anteriormente. No Matrícula transformação: caixa de texto digite o caminho completo para o arquivo de transformação.
9. Dê um duplo clique sobre este passo. No Nome do arquivo caixa de texto, digite o local do arquivo a
ser excluída e concatenar-lo com teste_ e a hoje variável, por exemplo,
$ {Internal.Job.Filename.Directory} \ test _ $ {} hoje .txt.
175
Gerenciamento de arquivos
Como funciona...
o excluir arquivo entrada de trabalho simplesmente exclui um arquivo. Na receita, você usou para excluir um arquivo cujo nome não
era fixo, mas depende da data atual.
A transformação tem o propósito de construir a última parte do nome do arquivo. Fica a presente data com um Obter
Informações do Sistema passo, converte a data para um Corda usando um
Selecione os valores passo, e define uma variável chamada hoje com esta informação. Como o escopo, você especificou Válido
no trabalho pai.
Em geral, se você não tem certeza do escopo para definir, você deve escolher Válido no
trabalho raiz. Isso é geralmente a melhor escolha. Uma variável com esse escopo será
válido no trabalho de raiz e todos os sub empregos e transformações.
Nesse caso, Válido no trabalho pai será suficiente, porque você vai usar a variável no trabalho que chama essa
transformação.
O principal trabalho é executado a transformação e, em seguida, usa a variável $ { hoje} para construir o nome do arquivo a
ser excluído. Supondo que sua transformação está localizado em / home / my_work /, quando você executar o trabalho, o
texto $ { Internal.Job.Filename.Directory} \ test _ $ {hoje}. TXT será substituído por / home / my_work / test_20101020.txt, e a excluir
arquivo etapa irá remover esse arquivo se ele existir.
Tem mais...
Se você precisar excluir um conjunto de arquivos em vez de apenas um, você pode usar o Deletar arquivos entrada de trabalho
do Arquivo Gestão categoria. Com esta entrada, você pode excluir vários arquivos ou pastas, incluindo subpastas e também pode
usar curingas para a seleção. Se você só quer excluir pastas em vez de arquivos, você pode usar o excluir pastas entrada de
Seja qual for o seu caso de uso, excluindo um ou mais arquivos, com ou sem pastas, dê uma olhada no seguinte subseção.
Dá-lhe mais truques para usar quando a exclusão de arquivos.
176
capítulo 5
Arquivo não foi eliminado devido a um erro o excluir arquivo entrada tarefa falhar
Arquivo não foi excluído porque não existia Se você marcou Falhar se o arquivo não existe :,
a excluir arquivo entrada tarefa falhar
O problema surge quando você tentar excluir vários arquivos com o Deletar arquivos entrada. Como você pode ter certeza se o seu
trabalho está se comportando corretamente e apagar os arquivos esperados? Como você pode saber os nomes exatos dos arquivos que
foram apagados?
Não há nenhuma maneira direta de determinar isso, mas existem algumas soluções interessantes. Quando você executar um trabalho que exclui os
arquivos, os nomes dos arquivos sendo excluídos são gravados no log. Se você estiver desenvolvendo o trabalho, basta dar uma olhada na Exploração
painel em Spoon. Se você quer ter a lista de arquivos para processamento adicional, salvar o log em um arquivo; em seguida, você
pode abrir esse arquivo e procure as linhas que contêm o texto Excluindo arquivo. Para ser mais preciso, você vai encontrar um monte de
linhas com os detalhes, como no exemplo a seguir:
. . . - Exclua alguns arquivos - arquivo Excluindo [file: /// C: / test / test_20101021.txt] ...
. . .
. . . - Exclua alguns arquivos - Total apagou arquivos = 5
Outra maneira de obter a lista de arquivos apagados seria o seguinte: criar uma transformação que lista os arquivos
existentes com as mesmas especificações diretório / arquivo como as do
Deletar arquivos entrada.
Você deve executar a transformação com um Transformação entrada pouco antes da Deletar arquivos
entrada. Se o Deletar arquivos entrada bem-sucedido, você sabe que os arquivos apagados são os únicos na lista que você criou.
Este método é fácil, mas você tem que ter cuidado. Se mais de um processo ou pessoa está a aceder a pasta ou arquivos ao
mesmo tempo, há um risco de que a lista interna e os nomes reais dos arquivos excluídos não coincidem.
Veja também
177
Gerenciamento de arquivos
Quando você precisa para copiar arquivos de ou para máquinas remotas, você pode usar o protocolo de rede padrão File Transfer
Protocol (FTP) construída em arquitetura cliente-servidor. Chaleira fornece a Obter um arquivo com FTP entrada de trabalho para obter
arquivos de um servidor FTP. No exemplo, você irá se conectar a um diretório remoto chamado remoteDir em um servidor FTP e copiar
alguns arquivos de texto a partir desse servidor para uma pasta local chamada destinationDir.
Você precisa ter acesso a um servidor de FTP para ser capaz de continuar com esta receita. Execute os
seguintes passos:
2. Adicione uma Obter um arquivo com FTP entrada de trabalho do Transferência de arquivo categoria.
3. De acordo com o Geral guia, digite o nome do servidor ou seu endereço IP no servidor FTP
nome / endereço IP caixa de texto.
4. Tipo o número de porta no Porta do servidor caixa de texto. Normalmente, ele é a porta 21.
5. No Nome de Usuário e Senha caixas de texto, digite as credenciais para fazer logon no servidor FTP.
6. No diretório remoto caixa de texto sob o arquivos guia, você deve digitar o nome do diretório remoto no servidor FTP
a partir de onde os arquivos de origem serão recuperados.
178
capítulo 5
8. No diretório de destino caixa de texto dentro do Local quadro, digite o diretório de destino na máquina local.
Debaixo de arquivos guia, você tem vários campos, como mostrado na imagem seguinte:
9. Execute o trabalho. Os arquivos com a extensão. TXT extensão serão copiados remoteDir no
servidor FTP para destinationDir na máquina local.
Como funciona...
o Obter um arquivo com FTP entrada de trabalho executa a tarefa de cópia, ele usa a configuração definida sob o Geral guia
para se conectar ao servidor FTP remoto. Debaixo de arquivos guia, você definiu o diretório de origem (no exemplo, a pasta
remota
remoteDir) e diretório de destino (no exemplo, a pasta local destinationDir).
Você também forneceu uma expressão regular para os arquivos de obter. Neste caso, você digitou. * \. TXT
que é uma expressão regular que representa todos. TXT arquivos.
Tem mais...
As seções a seguir dar-lhe algumas informações adicionais e dicas úteis para transferir arquivos de um servidor remoto.
179
Gerenciamento de arquivos
Na receita, você copiou todos os arquivos com uma determinada extensão; você fez isso, fornecendo uma expressão regular que todos os
arquivos combinados. Como outra possibilidade, você pode precisar de transferir um único arquivo.
Note-se que mesmo se você tiver o nome exato do arquivo, você ainda tem que fornecer
uma expressão regular.
Por exemplo, se o nome do arquivo é meu_arquivo.txt você tem que digitar my_file \ .txt.
Como uma última possibilidade, em vez de digitar um curinga, você pode fornecer um nome de variável Chaleira. Usando uma
variável é particularmente útil se você não sabe o nome do arquivo de antemão. Suponha que você tem que ter um arquivo
chamado daily_update_yyyyMMdd.csv Onde yyyyMMdd representa o ano, mês e dia. Nesse caso, você pode criar uma
transformação que constrói uma expressão regular que representa o nome do arquivo (por exemplo, daily_update_20101215 \ .csv) e
define uma variável com esse valor. No trabalho, você deve executar essa transformação antes do
Finalmente, no Obter um arquivo com FTP entrada, você deve digitar essa variável (por exemplo,
$ {DAILY_FILENAME}) como o carácter universal.
Se você precisa fornecer credenciais de autenticação para o acesso através de um proxy, você também deve concluir as
seguintes caixas de texto: hospedeiro proxy, a porta de proxy, nome de usuário proxy, e
password Proxy.
180
capítulo 5
se Obter um arquivo com FTP entrada. Mais informações sobre SFTP, podem ser encontradas em http://en.wikipedia.org/wiki/
SSH_file_transfer_protocol.
Veja também
Esta receita é semelhante ao anterior, Obtendo arquivos de um servidor remoto, mas neste caso, você deseja copiar os arquivos de texto a
partir de uma máquina local para uma máquina remota usando o protocolo de rede FTP eo Coloque um arquivo com FTP entrada de
trabalho.
Preparando-se
181
Gerenciamento de arquivos
2. Adicione uma Coloque um arquivo com FTP entrada de trabalho do Transferência de arquivo categoria.
3. De acordo com o Geral guia, digite o nome do servidor (ou o seu endereço IP) na servidor FTP
nome / endereço IP: caixa de texto.
4. Tipo o número de porta no Porta caixa de texto. Normalmente, ele é a porta 21.
5. No Nome de usuário: e Senha: caixas de texto, digite as credenciais para fazer logon no servidor FTP.
6. Digite a pasta de origem no Directório local caixa de texto dentro do arquivos (locais) Fonte
estrutura localizada sob o arquivos aba. Neste exemplo: c: \ SourceDir.
8. No diretório remoto caixa de texto, digite o diretório de destino na máquina remota, por
exemplo, remoteDir.
10. Executar o trabalho. Os arquivos com um. TXT extensão será copiado do SourceDir local
pasta para o destinationDir no servidor de FTP.
182
capítulo 5
Como funciona...
o Coloque um arquivo com FTP entrada de trabalho usa a configuração definida sob o Geral guia para se conectar ao servidor FTP
remoto. A entrada copia os arquivos da máquina local para o servidor remoto usando a configuração digitado sob a arquivos aba.
Na receita, você define o diretório de origem como c: \ SourceDir e o diretório de destino como remoteDir e, como a lista de arquivos
para transferir você digitou uma expressão regular que representa todos. TXT arquivos. Você também pode ter digitado uma
expressão regular que representa o nome exato do arquivo para transferir, bem como variáveis Chaleira, tanto para os arquivos de
e para os diretórios.
Tem mais...
Na receita, você coloca alguns arquivos em um servidor FTP. Kettle também fornece entradas de trabalho para colocar arquivos em servidores
SFTP e FTPS. Eles são o Coloque um arquivo com SFTP e a Upload de arquivos para FTPS entradas respectivamente. A configuração para
essas entradas é bastante semelhante ao que usou anteriormente.
Veja também
Às vezes, você não tem os nomes de arquivos para mover ou copiar de antemão. Nestes casos, você pode tirar vantagem do Adicionar
nome do arquivo para resultar solicitar existente em várias etapas chaleira e entradas de trabalho.
Vamos ver um exemplo. Suponha que você recebe arquivos do Excel diariamente, com pedidos de livros de diferentes ramos, e você precisa
para processar esses arquivos criando um novo arquivo de Excel com todas as ordens recebidas. Então, finalmente, você quer mover os
arquivos de origem para uma pasta de destino.
Preparando-se
A fim de fazer este exercício, você precisa de um diretório chamado booksOrders com vários arquivos do Excel. Cada
arquivo deve ter duas colunas: uma para o id_title e outro para o
Quantidade. Além disso, é necessário ter uma pasta de destino nomeado processedOrders.
183
Gerenciamento de arquivos
1. Criar uma nova transformação. Esta transformação vai levar todos os arquivos do Excel a partir do diretório de origem e
gravá-los em um único arquivo Excel.
3. De acordo com o arquivos guia, preencher a grade, a fim de ler todos os arquivos do Excel na fonte
5. Sob o Campos guia, adicione à grade de uma Corda campo chamado id_title e uma
Número campo chamado Quantidade.
7. Sob a Arquivo guia, digite o arquivo de destino Excel (por exemplo, allBookOrders)
incluindo o caminho, e licença. xls Enquanto o Extensão. Além disso, verifique o data no nome do arquivo inclui? pronto.
Com essas configurações, o arquivo final terá um nome como
allBookOrders_101011.xls.
Observe que aammdd é o formato padrão da data anexado para. Se você deseja
anexar a data com um formato diferente, verifique a Especificar formato de hora Data opção
e selecione ou digite o formato desejado na formato de data e hora opção.
8. De acordo com a mesma guia, desligue o Adicionar nome do arquivo para resultar pronto.
9. Sob o Campos guia, clique no obter Campos botão para preencher a grade.
3. Adicione uma Copiar ou mover os nomes de arquivo de resultado entrada da Gerenciamento de arquivos categoria.
4. Abra a passo. No Pasta de destino caixa de texto, navegar ou digitar o diretório de destino
(por exemplo, $ { Internal.Job.Filename.Directory} \ processedOrders).
5. Altere o valor no Açao campo de cópia de para Mover. Clique em Está bem fechar
o passo.
6. Execute o trabalho. Ele irá executar a transformação e irá mover os arquivos de origem do
booksOrders pasta para o processedOrders pasta.
184
capítulo 5
Como funciona...
Na receita, você usou o Kettle filelist resultado função para criar automaticamente uma lista de arquivos a serem copiados.
Na transformação, você usou um input Excel passo para ler todos os arquivos com o. xls
extensão a partir de um diretório de origem e um saída de Excel passo para escrever esta informação para um novo arquivo.
A definição importante aqui é a Adicionar nome do arquivo para resultar prompt de na input Excel degrau. Quando esta opção estiver
marcada (que é a configuração padrão), os nomes dos arquivos lidos na etapa são salvos no filelist resultado, que não é mais que
uma lista de arquivos na memória. De volta ao trabalho, o Copiar ou mover os nomes de arquivo de resultado entrada lê os nomes
guardados na memória e move os arquivos da lista, a pasta de destino. Note que, no saída de Excel etapa, você desmarcado a Adicionar
pronto. Se você tinha deixado este prompt marcada, o trabalho teria movido o
completeBookOrders_101011.xls arquivo também.
Veja também
Considere um cenário onde você tem que apagar alguns arquivos, mas você não tem os nomes dos arquivos a serem excluídos de
antemão. Se você pode especificar que a lista com expressões regulares, não seria um problema, mas às vezes isso não é possível.
Nesses casos, você deve usar uma transformação auxiliar que cria a lista de arquivos a serem excluídos. Esta receita mostra como
fazer isso. Para esta receita, suponha que você deseja excluir um diretório de origem todos os arquivos temporários que atendam
185
Gerenciamento de arquivos
Preparando-se
A fim de criar e testar esta receita, você precisa de um diretório com um conjunto de arquivos de amostra; alguns deles deve ter
o. tmp extensão e tamanho zero. Alguns arquivos de exemplo são mostrados na imagem seguinte:
Na imagem anterior, os arquivos que devem ser excluídos são sample3.tmp, sample5.tmp,
e sample7.tmp porque eles correspondem aos requisitos de ter. tmp como seu tipo de arquivo e eles não contêm nada
(sendo 0 bytes de tamanho).
3. De acordo com o Arquivo guia, preencher o arquivos selecionados: grade. Debaixo File / Directory, tipo
$ {Internal.Transformation.Filename.Directory} \ sample_directory
e abaixo Universal (RegExp), tipo .*\. tmp.
5. Use esta etapa para filtrar os arquivos com um tamanho igual a 0. A fim de fazer isso, adicione o
condição tamanho = 0.
6. Depois do Filtrar linhas etapa, adicione o Selecione os valores degrau. Quando perguntado sobre o tipo de
hop para criar, selecione saída principal da etapa. Isso fará com que apenas as linhas que atendam a condição de
passar o filtro.
186
capítulo 5
8. A partir da Trabalho categoria de Passos, adicionar um linhas de cópia para resultar degrau.
9. Salve a transformação.
13. Dê um duplo clique sobre ele e verificar o Copiar os resultados anteriores para args? pronto.
14. Salve o trabalho e executá-lo. Os arquivos com um. tmp extensão e um tamanho de 0 bytes vai
ser excluído.
Como funciona...
Nesta receita, você excluiu uma lista de arquivos usando o Deletar arquivos entrada de trabalho. No arquivos selecionados: grade de
que a entrada, você tem que fornecer o nome completo dos arquivos ou o diretório para apagar e uma expressão regular. Em vez de
digitar essa informação diretamente, aqui você construiu as linhas de grade em uma transformação separado. O primeiro passo
usado na transformação é Obter nomes de arquivo. Este passo permite-lhe obter informações sobre um arquivo ou um conjunto de
arquivos ou pastas. Neste exemplo, o passo obtém a lista de. tmp arquivos do sample_directory pasta.
A imagem seguinte mostra todas as informações que você obter com esta etapa:
187
Gerenciamento de arquivos
Você pode ver esses nomes de campo, pressionando a barra de espaço ao ter o foco no Obter nomes de arquivos degrau. Após essa
etapa, você usou um Filtrar linhas passo para manter apenas os arquivos com um tamanho de 0 bytes. Se você fizer uma pré-visualização
on Nesta etapa, você verá um conjunto de dados com a lista dos arquivos desejados, ou seja, aqueles que atendem as duas condições:
ter a. tmp extensão e um tamanho igual 0 bytes. Depois disso, você selecionou apenas os campos segurando a caminho e a short_filename e
copiado estas linhas para a memória. Você fez isso com o linhas de cópia para resultar degrau. Agora, vamos voltar para o trabalho. o Copie
resultado anterior para args? linha seleccionada no Deletar arquivos entrada faz com que o trabalho de ler as linhas que vêm da
transformação, e copiá-los para a rede. Em outras palavras, cada linha que sai da transformação (a par de dados: caminho, short_filename) torna-se
uma linha na Arquivos / pastas: grade. Com essa informação, o trabalho é finalmente capaz de excluir os arquivos especificados.
Veja também
Preparando-se
Para criar e testar esta receita, você vai precisar de dois arquivos: a versão mais antiga do arquivo do museu ( LastMuseumsFileReceived.xml),
e o novo arquivo ( NewMuseumsFileReceived.xml).
188
capítulo 5
2. Adicione uma file Compare entrada de trabalho do Gerenciamento de arquivos categoria. Aqui você deve digitar
ou navegue até os dois arquivos que devem ser comparados, como mostrado na imagem a seguir:
3. Adicione uma Transformação entrada de trabalho e uma MANEQUIM entrada de trabalho, tanto do Geral
categoria. Criar um hop do file Compare entrada de trabalho para cada uma dessas entradas.
4. Botão direito do mouse sobre o hop entre a file Compare entrada de trabalho ea Transformação
trabalho de entrada para mostrar as opções, escolha a Avaliação item e, em seguida, selecione o Siga quando resultado é falsa item.
5. Dê um clique direito sobre o hop entre a file Compare entrada de trabalho ea MANEQUIM entrada de trabalho,
escolha o Avaliação item, e desta vez, selecione a Siga quando resultado é verdadeiro item.
7. Em seguida, crie uma nova transformação, a fim de ler o arquivo XML. soltar um Adquirir dados
de XML passo do Entrada categoria na tela e digite o caminho completo para o arquivo XML na Arquivo
ou diretório caixa de texto sob o Arquivo aba. Neste caso, é $ { Internal.Transformation.Filename.Directory}
\ sampleFiles \ NewMuseumsFileReceived.xml. Usar / museus / museu no circuito XPath
caixa de texto sob o Conteúdo guia e usar o obter campos botão sob a Campos guia para preencher a lista de campos
automaticamente.
8. Guardar a transformação.
189
Gerenciamento de arquivos
9. Configurar o Transformação entrada de trabalho para o trabalho principal para executar a transformação
você acabou de criar.
11. Supondo que os arquivos são iguais, na Exploração madeireira janela, você verá uma linha semelhante
ao seguinte:
2010/11/05 10:08:46 - FileCompare - entrada de trabalho acabado [MANEQUIM] (resultado = [verdadeiro])
12. Se seus arquivos são diferentes, no métricas de emprego janela, você verá que o FileCompare
entrada falhar, e sob o Exploração madeireira guia, você verá algo semelhante ao seguinte:
. . .
. . . - Ler o arquivo XML - Carregando transformação a partir do arquivo XML [file: /// C:
/readXMLFile.ktr]
. . . - ReadXMLFile - Despacho começou para transformação [ReadXMLFile]
. . . - ReadXMLFile - Esta transformação pode ser repetido com data de repetição: 2010/11/05
10:14:10
. . . - Leia museu data.0 - processamento de acabamento (I = 4, S = 0, R = 0, W = 4, L = 0, E = 0)
Como funciona...
o file Compare entrada de trabalho executa a tarefa de comparação. Ele verifica se os dois arquivos têm o mesmo conteúdo. Se forem
diferentes, a entrada trabalho falhar. Então, o trabalho prossegue com a execução da transformação que lê o novo arquivo. No entanto,
se os arquivos são os mesmos, a entrada de trabalho bem-sucedido e os fluxos de continuar para a MANEQUIM entrada. Em outras
palavras, o novo arquivo é processado se e somente se o file Compare falha, ou seja, se os dois arquivos são diferentes.
Tem mais...
Além de comparar arquivos com chaleira, você também pode comparar diretórios; Vamos ver como isso funciona.
comparando pastas
Se você quiser comparar o conteúdo de duas pastas, você pode usar o Compare pasta entrada de trabalho do Gerenciamento de
arquivos categoria.
190
capítulo 5
Neste entrada de trabalho, você deve procure ou digite os caminhos completos das duas pastas no
O nome do arquivo / pasta 1 e O nome do arquivo / pasta 2 caixas de texto, respectivamente, e configurar a comparação a ser
feito. Você pode ver as configurações possíveis na imagem seguinte:
o Comparar opção, defina a Todos por padrão, pode ser alterado para comparar apenas arquivos, apenas as pastas, ou apenas os arquivos
indicados por uma expressão regular. A exigência usual seria comparar a lista de arquivos e, em seguida, seus tamanhos.
Note que você pode até mesmo comparar o conteúdo dos arquivos, mas isso vai afetar o
desempenho consideravelmente.
Arquivos compactados são um método de armazenamento conveniente. Se você tem muitos arquivos ou os arquivos são muito grandes,
compactá-los faz com que seja mais fácil para armazená-los e transferi-los através de e-mails ou entre diferentes meios de comunicação (PC,
Por exemplo, considere gerir as informações de log de um servidor web, o que gera um novo arquivo de texto todos os dias com dados sobre o
tráfego da Web (páginas, IPs, operações, códigos de status, e assim por diante). Depois de vários meses, você tem um monte de arquivos com
uma quantidade substancial de informações. Agora, suponha que você deseja criar uma cópia local dos arquivos. Você não tem acesso ao servidor
do seu computador, então você tem que copiar os arquivos para alguns meios de comunicação e, em seguida, para o seu computador. À medida
que o tamanho desses arquivos podem ser enormes, em vez de copiar diretamente os arquivos, você vai comprimi-los em primeiro lugar.
Assim que tiver o arquivo ZIP no seu computador, você quer descompactá-lo e criar um separado
. fecho eclair arquivo por mês. Assumindo que os arquivos são nomeados exyymmdd.log você irá criar. fecho eclair
arquivos chamados YYMM.zip. Por exemplo, um arquivo chamado ex101115.log será fechado juntamente com todos os outros registos de
novembro de 2010 como 1011.zip.
Preparando-se
191
Gerenciamento de arquivos
Você vai criar essa receita em duas etapas diferentes. Na primeira etapa, você irá comprimir os arquivos de log, e, na segunda
etapa, você descompactar-los e organizá-los em arquivos ZIP mensais. Então, vamos comprimir os arquivos weblog, realizando
os seguintes passos:
3. De acordo com o Geral guia, selecione o diretório de origem clicando no Pasta... botão.
O exemplo aponta para um diretório de log do servidor web, tais como C: \ WINDOWS \ system32 \ Logfiles \
W3SVC1 \ Test_files.
4. Digite. + \. registro no Incluir curinga (RegExp): caixa de texto, a fim de ler todos os arquivos
com o . registro extensão.
5. No Zip nome do arquivo: caixa de texto, digite o caminho eo nome para o arquivo de destino ZIP. Por
exemplo, C: \ WINDOWS \ system32 \ Logfiles \ W3SVC1 \ Test_files \ web logs.zip.
6. Você tem várias opções adicionais para a inclusão de data e hora para o nome do arquivo ZIP. Você não precisa definir
essas opções para esta receita.
7. Sob a avançado aba, escolha Deletar arquivos no depois Fechando drop-down list.
8. Ao executar este trabalho, um novo arquivo chamado logs.zip web será criado contendo
as informações de log do servidor web e os arquivos de log serão apagados. Agora supondo que você copiou o
arquivo ZIP gerado para o seu computador, você deseja descompactar os weblogs e gerar pequenos arquivos ZIP
3. No Zip O nome do arquivo caixa de texto, você deve procurar o arquivo ZIP criado anteriormente ( logs.zip web).
7. Sob a avançado guia, definir o sucesso em condição para Pelo menos nós com sucesso
arquivos x descompactados, e defina o valor de arquivos limite caixa de texto para 1.
8. O próximo passo para o trabalho estará chamando uma transformação que cria os grupos de registos para os arquivos ZIP menores.
Adicionar um Transformação entrada de trabalho.
192
capítulo 5
Quando perguntado sobre o tipo de hop para criar, sempre escolher o saída principal da etapa opção.
A transformação deve ser semelhante ao mostrado na imagem seguinte:
11. Dê um clique duplo na primeira etapa. Com este passo, você vai obter a lista completa dos arquivos de log.
13. Dê um duplo clique sobre o cordas cortadas degrau. Esta etapa irá gerar uma Corda com o ano
e parte do mês dos nomes de arquivos. Em seguida, preencha os seguintes campos:
?? Debaixo Corta para tipo 6 e fechar a janela. Isto irá remover tudo depois
o sexto personagem, o que seria DD.log. Isso nos deixa com YYMM.
193
Gerenciamento de arquivos
14. Dê um duplo clique sobre o UDJE degrau. Com este passo, você irá criar os campos para a
. fecho eclair grade. Adicionar três Corda campos chamado curinga, wildcardexc, e
destino. Como expressão Java, tipo ex + year_month + [0-9] \\. log,
e path + \\ zip_files \\ + year_month + .zip respectivamente. Não se esqueça de definir o tipo de valor para
Corda.
15. Dê um duplo clique sobre o Selecione os valores degrau. Use-o para selecionar o campo de caminho,
16. Dê um duplo clique sobre o Classificar linhas degrau. Use-o para classificar por destino. Verifica a
Apenas passar as linhas exclusivas? (Verifica única chaves) opção. Com isso, você gera uma única linha por
mês.
19. Dê um duplo clique sobre a entrada, verifique a Obter argumentos do anterior opção
e fechar a janela.
21. Procure o registro pasta. Você verá todos os arquivos de log que foram comprimidos no
logs.zip web apresentar juntamente com uma subpasta chamada fecho eclair.
22. Procure a pasta ZIP. Você vai ver um arquivo ZIP para cada mês para o qual você tinha arquivos de log.
Como funciona...
Nesta receita, você viu a funcionalidade do Arquivo Zip e Arquivo de descompactação entradas de trabalho. Primeiro, você fechou todos
os arquivos de log em uma pasta. Você especificou os arquivos zip e o nome ea localização do arquivo ZIP para gerar. Este é bastante
simples e não requer maiores explicações. Na segunda parte da receita, você executou duas tarefas diferentes: O primeiro foi para
descompactar um arquivo. Você especificou o arquivo ZIP, a expressão regular que indica quais arquivos para extrair o arquivo ZIP, e o
A última parte, a tarefa mais elaborada da receita, foi comprimir os arquivos de log agrupadas por mês. A fim de fazer isso, você
não poderia preencher a grade na arquivo zip entrada de trabalho manualmente, porque você não sabia com antecedência os
nomes dos arquivos de log. Portanto, em vez de preencher a grade que você verificou o Obter argumentos do anterior opção. A
transformação foi responsável por gerar os valores para a grade no arquivo zip entrada janela de configuração. As colunas gerados
pela transformação foram como se segue:
194
capítulo 5
f expressão regular para os arquivos a serem excluídos (neste caso, você define um valor nulo)
f Destino ZIP filename Estes são os quatro campos que os arquivo zip entrada precisa para fechar os arquivos.
Para cada linha gerada na transformação, um novo arquivo ZIP foi criado com base nesses valores.
Tem mais...
Na receita você descompactou um arquivo porque você tinha que manipular os arquivos. Se, em vez de manipular os arquivos
que você fez, você precisa lê-los, você não tem que usar a entrada do arquivo Descompacte. Kettle é capaz de ler os arquivos
como eles são. Para uma referência completa sobre este assunto, você pode dar uma olhada no seguinte entrada no Slawomir
Chodnicki de blog em
http://type-exit.org/adventures-with-open-source-bi/2010/11/directlyaccessing-remote-andor-compressed-files-in-kettle/.
Veja também
fo Envio de e-mails com arquivos anexados receita de Capítulo 10, Obtendo o máximo
Fora de Kettle
Mover arquivos, por vezes, requer dados sensíveis de ser expostos de forma que exigem medidas mais seguras a serem tomadas que
simplesmente empurrar ou puxar os dados sem criptografá-los em primeiro lugar. Felizmente, Chaleira fornece etapas que fazem interface
com uma aplicação de segurança comum (GnuPG) e irá criptografar, descriptografar e verificar se os arquivos estão seguros.
Gnu Privacy Guard (GnuPG) é uma implementação da norma OpenPGP. Abrir Pretty Good Privacy (OpenPGP) é um dos sistemas de
criptografia mais usados em tecnologia e é amplamente utilizado devido à sua capacidade para assinar digitalmente arquivos para
garantir que eles não foram adulterados. O uso de chaves públicas e privadas permite que os arquivos sejam criptografados até que
a tecla direita pode ser usada para descriptografar o arquivo e torná-lo acessível novamente. Para saber mais sobre OpenPGP,
195
Gerenciamento de arquivos
Preparando-se
Esta receita exige GnuPG para ser instalado no sistema que executa Chaleira. Ela pode ser encontrada no website do
GnuPG no http://www.gnupg.org.
3. De acordo com o Criptografia de Arquivos seção, encontrar o Criptografar arquivos com PGP passo e adicioná-lo
a tela.
4. Criar um hop do Começar passo para o Criptografar arquivos com PGP degrau.
5. Abra a Criptografar arquivos com PGP degrau. Para o GPG local campo, digite o caminho
onde GnuPG está instalado.
6. Para o fonte de arquivo / pasta, digite o local onde os arquivos sejam criptografados são
localizados ($ { Internal.Transformation.Filename.Directory} / Test_files).
7. Para o destino do arquivo / pasta, digite o local onde os arquivos criptografados será
ser colocado ($ { Internal.Transformation.Filename.Directory} / encrypted_files).
8. Clique no Adicionar botão ao lado do fonte de arquivo / pasta campo para o registro para ser
adicionado ao Arquivos / pastas grade de dados.
9. Clique em Está bem e executar o trabalho. Os arquivos criptografados agora deve estar no
encrypted_files pasta. A configuração similar pode ser feito com o Desencriptar
1. No mesmo trabalho, adicionar um Desencriptar arquivos com PGP passo, que pode ser encontrado no
3. Para a fonte de arquivo / pasta, vamos estar usando o local do arquivo criptografado
($ { Internal.Transformation.Filename.Directory} / encrypted_files).
5. Clique no Adicionar botão ao lado do fonte de arquivo / pasta campo para o registro de
ser adicionados à Arquivos / pastas grade de dados.
6. Adicione um hop entre a Criptografar arquivos com PGP e Desencriptar arquivos com PGP passos.
196
capítulo 5
7. Execute o trabalho e visualizar os arquivos nas pastas criptografados e descriptografados. Os arquivos criptografados são protegidos e não
pode ser visto como facilmente como se nenhuma criptografia tinham sido adicionados.
Como funciona...
o arquivos criptografar / descriptografar com PGP etapas utilizar um aplicativo padrão que lida com criptografia e assinatura digital de arquivos.
Ao contar os passos, onde GnuPG está localizado, os passos são capazes de executar os comandos necessários para processar quaisquer
arquivos dados e fixá-los conforme necessário.
Tem mais...
Nós só usamos os recursos de criptografia básicas dessas etapas. Em os arquivos Criptografar com PGP
passo, cada Pasta de arquivo combinação origem eo destino pode realmente ser Criptografado, assinado, ou Criptografadas e
assinadas dependendo de como garantiu os arquivos precisam ser. Isto pode ser comutado no Açao coluna no Arquivos / pastas grade
de dados, como mostrado:
Veja também
197
6
Procurando por Dados
Introdução
Com as transformações, você manipular dados em muitas maneiras-fazer operações matemáticas ou lógicas,
aplicando funções de cadeia, agrupamento por uma ou mais colunas, ordenação, e muito mais. Além de transformar os
dados que você já tem, você pode precisar pesquisar e trazer dados de outras fontes. Vejamos os exemplos a seguir:
f Você tem alguns códigos de produto e você quer olhar para suas descrições em um
arquivo Excel
f Você tem um valor e deseja obter todos os produtos cujo preço é inferior ao valor
a partir de um banco de dados
Busca de informações em bancos de dados, arquivos de texto, serviços web, e assim por diante, é uma tarefa muito
comum, e Kettle tem várias etapas para fazê-lo. Neste capítulo, você vai aprender sobre as diferentes opções.
A fim de procurar dados em um banco de dados, Chaleira oferece várias maneiras de acessar os dados. A situação mais simples é aquela
em que você precisa para obter uma ou mais colunas de uma tabela de banco de dados único. Nesta receita, você vai aprender como
fazer isso usando o pesquisa de banco de dados
degrau. Vamos trabalhar com o Steel Wheels dados de amostra. Se você deseja se tornar mais familiarizado com o conjunto de dados de amostra
1, Trabalhando com Bancos de dados. Suponha que você quer olhar para os produtos que correspondam a um determinado termo de busca, e
cujos preços são abaixo de um determinado valor, esta receita mostra como fazer isso.
Preparando-se
A fim de seguir esta receita, você precisa do banco de dados Steel Wheels.
2. Trazer ao longo de um Grade de dados passo do Entrada categoria. Abra a passo. Debaixo de meta
guia, adicionar dois itens corda estímulo e MAX_PRICE. Em seguida, preencha o Dados guia, como mostrado na
imagem seguinte:
4. Use essa etapa para adicionar uma seqüência de caracteres chamado like_statement. Em expressão Java, tipo
% +% + +% Prod. +%.
5. Adicione uma pesquisa de banco de dados degrau. Você vai encontrá-lo na Olho para cima categoria de passos.
6. Dê um clique duplo na etapa. Como Conexão, seleccionar (ou criar se ele não existe)
a conexão com o dados de amostra base de dados. Como Tabela de pesquisa digite ou procure PRODUTOS.
200
Capítulo 6
8. Feche a pesquisa de banco de dados janela de configuração e fazer uma prévia sobre este passo. Você
vai ver algo como a imagem seguinte:
Como funciona...
o pesquisa de banco de dados passo permite-lhe olhar para os valores em uma tabela de banco de dados. Para realizar a pesquisa, você precisa
especificar, pelo menos, as seguintes coisas:
fA conexão de banco de dados ea tabela de banco de dados que você deseja pesquisar
A grade superior é onde você especifica as condições. Cada linha na grade representa uma comparação entre
uma coluna na tabela, e um campo em sua corrente, usando um dos comparadores prestados.
201
Procurando por Dados
Se tomarmos, por exemplo, a primeira linha no conjunto de dados, a condição pode ser reescrita como:
Essa é exatamente a pesquisa que você queria realizar para essa linha-olhar para os registros onde a coluna BUYPRICE foi
inferior a 90, e a coluna NOME DO PRODUTO continham Aston Martin.
o pesquisa de banco de dados passo nos permitirá recuperar qualquer número de colunas com base nos critérios de pesquisa.
Cada coluna de banco de dados você entra na grade inferior se tornará um novo campo em seu conjunto de dados. Você pode
renomeá-los (isto é particularmente útil se você já tem um campo com o mesmo nome) e fornecer um valor padrão se nenhum
registro for encontrado na pesquisa. Na receita, você adicionou três campos: PRODUCTNAME, PRODUCTSCALE, e BUYPRICE. Por
padrão, para NOME DO PRODUTO você digitou não disponível. Na visualização final, você pode ver que a descrição na segunda fila.
Isto significa que não havia produtos com Ford Falcon como parte de sua descrição e um preço inferior 70.
Tem mais...
A receita mostrou a configuração mínima do pesquisa de banco de dados degrau. O passo tem mais opções que podem
ser úteis, como explicado nas subseções a seguir.
1. Se os dados devem estar presentes, em seguida, o fracasso da pesquisa é considerado um erro. Nesse caso, você
pode manipular o erro. Você pode, por exemplo, enviar as linhas que causam a falta de um fluxo diferente, como
mostrado na imagem seguinte
202
Capítulo 6
Lembre-se que você pode capturar erros clicando com o botão direito sobre o
pesquisa de banco de dados passo, seleccionar a Definir o tratamento de erros ... opção e configurar o configurações
de tratamento de erros passo janela corretamente. Pelo menos, você tem que verificar o Permitir a
manipulação de erro? opção e selecione o Escrever para log etapa Enquanto o etapa alvo.
Se você fizer isso, as linhas para as quais a pesquisa falhar, vá diretamente para o fluxo que captura o erro,
neste caso, a Escrever para log degrau.
2. Se as linhas são inúteis sem os campos que você está procurando, então você pode descartá-las. Você faz isso através da
verificação da Não passe a linha se a pesquisa falhar opção. Desta forma, apenas as linhas para as quais a pesquisa for
bem-sucedido vai passar para a próxima etapa.
1. Se você verificar o Falhar em vários resultados? opção, as linhas para as quais a pesquisa recupera mais de uma linha
fará com que a etapa a falhar. Nesse caso, no Exploração madeireira
janela da guia, você verá um erro semelhante ao seguinte:
. . . - pesquisa de banco de dados (falha em vários res.) 0 - ERRO ... Por causa de um erro, este passo não
pode continuar.:
. . . - pesquisa de banco de dados (falha em vários res.) 0 - ERRO ...:. Apenas 1 linha era esperada
como resultado de uma pesquisa, e pelo menos 2 foram encontrados!
Então você pode decidir se você quer deixar a transformação ou capturar o erro.
2. Se você não verificar o Falhar em vários resultados? opção, a etapa irá retornar a primeira linha que encontra. Você
pode decidir qual deles para retornar ao especificar a ordem. Você faz isso digitando uma cláusula de ordem no Ordenar
por caixa de texto. No dados de amostra banco de dados, existem três produtos que atendam as condições para a Corveta
linha. Se, por Ordenar por, você digita PRODUCTSCALE DESC, PRODUCTNAME, então você vai ter Chevy 1958 Corvette
Limited Edition, que é o primeiro produto após a ordenação dos três produtos encontrados pelo critério especificado.
Se, em vez de tomar algumas dessas ações, você percebe que você precisa de todas as linhas resultantes, você deve tomar outra abordagem de
substituir o pesquisa de banco de dados passo com um banco de dados juntar-se ou um
fila SQL dinâmico degrau. Para receitas que explicam essas etapas, consulte o seguinte Veja também seção.
203
Procurando por Dados
Neste caso, o fluxo que você usa para capturar o erro torna-se seu principal corrente. As linhas que não falham serão
descartados, e as linhas para as quais a pesquisa não conseguiu ir diretamente para a corrente principal para tratamento
posterior.
Veja também
Na receita anterior, você viu como a busca de colunas em uma tabela de banco de dados com base em condições simples. Com Chaleira,
você também pode pesquisar, fornecendo condições complexas ou que envolvam mais de uma tabela. Nesta receita, você vai aprender a
realizar esse tipo de pesquisa usando o banco de dados juntar-se degrau. Para deixar você comparar as diferentes opções para pesquisar
dados em um banco de dados com facilidade, vamos trabalhar com o mesmo exemplo que você viu na receita-os dados da amostra de aço
Rodas anteriores. Você quer olhar para produtos que correspondam a um determinado termo de pesquisa e cujos preços estão abaixo de um
determinado valor.
Preparando-se
A fim de seguir esta receita, você precisa do banco de dados Steel Wheels. O código para gerar este banco de dados está
disponível em vários locais, como mencionado no Capítulo 1, Trabalhando com bancos de dados.
204
Capítulo 6
2. Adicione uma Grade de dados passo que gera um conjunto de dados, como a mostrada na
imagem seguinte:
Você pode digitar os dados em um arquivo e ler o arquivo, ou usar uma grade de
dados.
3. Adicione uma banco de dados juntar-se degrau. Você vai encontrá-lo na Olho para cima categoria de passos.
4. Clique duas vezes no degrau. Como Conexão, seleccionar (ou criar se ele não existe) a
conexão ao dados de amostra base de dados.
, PRODUCTSCALE
, BUYPRICE
DE PRODUTOS
ONDE PRODUCTNAME COMO concat (<%>,?,>%>) E
BUYPRICE <?
7. Clique em obter Campos para preencher a grade com dois Parametros- estímulo e MAX_PRICE.
8. Feche a banco de dados juntar-se janela de configuração e fazer uma prévia sobre este passo. Você irá
ver algo como a imagem seguinte:
205
Procurando por Dados
Como funciona...
o banco de dados juntar-se passo é um passo poderoso para procura de dados em um banco de dados, com base em determinadas condições.
As condições geralmente envolvem comparações entre colunas em tabelas e campos em seu fluxo; portanto, ele é chamado a participar.
Esta não é realmente um banco de dados aderir. Em vez de se juntar tabelas em um banco de
dados, você está juntando o resultado de uma consulta de banco de dados com um conjunto de
dados Chaleira.
Os pontos de interrogação que você digita na instrução SQL (os das linhas destacadas na receita) representam parâmetros.
O objetivo desses parâmetros deve ser substituído com os campos fornecidos na grade inferior. Para cada linha em sua
corrente do banco de dados juntar-se etapa substitui os parâmetros na mesma ordem em que estão na grade, e executa a
instrução SQL. Se tomarmos como exemplo a primeira linha no conjunto de dados, a instrução SQL após a substituição dos
parâmetros seria semelhante a seguinte consulta:
PRODUCTNAME SELECIONAR
, PRODUCTSCALE
, BUYPRICE
DE PRODUTOS
ONDE PRODUCTNAME COMO concat ( '%', 'Aston Martin', '%') AND
BUYPRICE <90
E isso é exatamente a busca que você queria fazer para essa linha: olhar para os registros onde a coluna BUYPRICE foi inferior a 90 e
a coluna NOME DO PRODUTO continham Aston Martin. Como resultado do banco de dados juntar-se, você pode recuperar qualquer
número de colunas. Cada coluna de banco de dados que você digitar o SELECIONAR cláusula vai se tornar um novo campo em seu
conjunto de dados. Na receita, esses campos foram PRODUCTNAME, PRODUCTSCALE, e BUYPRICE. Em particular, se você tivesse
digitado * SELECT, você teria recuperado todas as colunas nas tabelas envolvidas na declaração.
Na receita, você verificou o Junção externa? opção. O efeito disto é a seguinte: Para as linhas onde a pesquisa falhar,
os novos campos são recuperados com valores nulos. Esse foi o caso para a segunda linha. Não havia produtos com Ford
Falcon como parte de sua descrição e um preço inferior 70. Portanto, essa linha mostra valores vazios para o PRODUCTNAME,
PRODUCTSCALE, e BUYPRICE Campos.
Note-se que na receita, você preencheu a grade com dois campos. Isso é exatamente o mesmo número de pontos de interrogação no
comunicado.
206
Capítulo 6
Além disso, observe que na grade do estímulo campo estava em primeiro lugar ea MAX_PRICE Em segundo lugar. Se você olhar
para as linhas destacadas na receita, você vai ver que a declaração esperava que os parâmetros exatamente nessa ordem.
Até agora, os resultados são bastante semelhantes aos que você tem com uma pesquisa de banco de dados. Há uma diferença
significativa, no entanto. Para a terceira fila, o Corveta produto, você pode ver dois resultados. Isto significa que o banco de dados juntar-se encontrou
duas linhas correspondentes no banco de dados, e recuperados os dois. Isso não é possível com um pesquisa de banco de dados degrau.
Tem mais...
o banco de dados juntar-se passo pode ser um pouco complicado de usar, ou de compreender, em comparação com o
pesquisa de banco de dados degrau. Enquanto o pesquisa de banco de dados etapa tem uma interface que faz com que a configuração da etapa fácil,
na banco de dados juntar-se etapa, você tem que escrever uma instrução SQL. Isso implica que você precisa de um bom conhecimento de SQL. No
entanto, o banco de dados juntar-se passo tem várias vantagens sobre o pesquisa de banco de dados 1:
f Ele permite que você olhar para cima a partir de uma combinação de tabelas.
f Ele permite que você para recuperar campos de mais de uma mesa ao mesmo tempo.
f Ele permite que você para recuperar resultados agregados, fragmentos de um campo (por exemplo, um
subsequência de um campo), ou uma combinação de campos (por exemplo, duas cadeias concatenadas).
f Ele permite que você recuperar mais de uma linha do banco de dados para cada entrada
remar no conjunto de dados Chaleira. Este é de longe o mais importante vantagem. Por padrão, todas as linhas
correspondentes são recuperadas. Se você quiser limitar o número de linhas a serem recuperadas para cada linha em sua
corrente, basta alterar o Numero de linhas para retornar o valor.
Veja também
o banco de dados juntar-se passo que você aprendeu a usar na receita anterior é bastante poderoso e tem várias vantagens sobre
a simples pesquisa de banco de dados degrau. Há um passo ainda mais poderoso para pesquisar em um banco de dados; o fila
SQL dinâmico degrau. Esta receita explica-lhe as suas capacidades e mostra-lhe como usá-lo.
207
Procurando por Dados
A fim de permitir que você compare as diferentes opções para pesquisar em um banco de dados com facilidade, vamos trabalhar com um
exemplo semelhante ao que você viu nas duas anteriores receitas-vamos trabalhar com os dados da amostra Steel Wheels. Você quer olhar
para os seguintes produtos:
f Os produtos que contêm Ford Falcon em seu nome e com uma escala de 01:18
f Os produtos que contêm Corveta em seu nome e com uma escala de 01:24
Preparando-se
A fim de seguir esta receita, você precisa do banco de dados Steel Wheels.
Você pode digitar os dados em um arquivo e ler o arquivo, ou usar uma grade de dados.
4. Use essa etapa para adicionar uma Corda nomeado declaração. Como expressão Java, digite o
seguinte consulta:
5. Faça uma prévia sobre este passo. Você verá uma nova coluna chamada declaração com um
completar instrução SQL, por exemplo:
6. Adicione uma fila SQL dinâmico degrau. Você vai encontrá-lo na Olho para cima categoria de passos.
208
Capítulo 6
7. Dê um clique duplo na etapa. Como Conexão, seleccionar (ou criar se ele não existe) a
conexão ao dados de amostra base de dados.
10. No SQL modelo (para recuperar dados de Meta) quadro, tipo a consulta seguinte:
11. Feche a fila SQL dinâmico janela de configuração e fazer uma prévia sobre este passo.
Você verá algo parecido com a imagem seguinte (note que o declaração
campo é oculto):
Como funciona...
o fila SQL dinâmico passo é um passo muito poderoso para procura de dados em um banco de dados. Se tomarmos, por exemplo, a
primeira linha no conjunto de dados, a instrução SQL (aquele que você constrói com a expressão Java) é semelhante à seguinte
consulta:
Essa é exatamente a pesquisa que você queria realizar para essa linha-olhar para os registros onde a coluna DESCRIÇÃO
DO PRODUTO continham Aston Martin.
Neste caso, você está filtrando tanto pelo nome e pela escala.
Como você vê, o que você está fazendo é criar dinamicamente uma instrução SQL. Em seguida, no
fila SQL dinâmico janela de configuração, basta usar o nome do campo SQL para indicar que o campo contém a instrução SQL
para executar. Como a saída do fila SQL dinâmico etapa, você pode recuperar qualquer número de colunas. Cada coluna na base
de dados SELECIONAR declaração vai se tornar um novo campo em seu conjunto de dados.
209
Procurando por Dados
Para contar Chaleira os metadados dos novos campos que está sendo adicionado com esta declaração dinâmico, você deve preencher o SQL
modelo (para recuperar dados de Meta) quadro, Armação. Aqui, você tem que digitar qualquer declaração que retorna a mesma estrutura
que os novos campos. Chaleira vai levar daqui ambos os nomes e os tipos para os novos campos. Na receita, você digitou SELECT
'NOME', 'ESCALA', 1 como BUYPRICE. Com esta declaração, você está dizendo Kettle que você está adicionando três campos e dois
Tanto a declaração e esse modelo são escritos usando a sintaxe do MySQL. É obrigatório
que você reafirmar-los para coincidir com a sintaxe do motor de banco de dados você está
usando.
Na receita, você verificou o Junção externa? opção. O efeito disto é o mesmo que na
banco de dados juntar-se passo para as linhas onde a pesquisa falhar, os novos campos são recuperados com valores nulos.
Esse foi o caso para a segunda linha. Não havia produtos com Ford Falcon
como parte de seu nome e uma escala de 1:18. Portanto, essa linha mostra valores vazios para o
NOME DO PRODUTO, PRODUCTSCALE, e BUYPRICE Campos. Para a terceira fila, o Corveta
produto, você pode ver dois resultados. Isto significa que o fila SQL dinâmico etapa encontrou duas linhas correspondentes na base de
dados e recuperados os dois. Isso também se assemelha ao comportamento do banco de dados juntar-se degrau.
Finalmente, note que na receita, a declaração foi diferente para cada linha. Pode acontecer no entanto, que suas declarações não
mudam muito. Se este for o caso, você pode reduzir o número de consultas de banco de dados físicos, verificando a Consulta
apenas em alterar os parâmetros opção.
Tem mais...
o fila SQL dinâmico passo é o passo mais flexível para procurar dados em um banco de dados. Como você viu, há um par de
semelhanças entre este eo banco de dados juntar-se degrau. O que realmente faz a diferença entre eles é que, com a fila SQL
dinâmico passo, qualquer parte da declaração pode ser construída dinamicamente com base nos campos em seu fluxo. Por
exemplo, as colunas utilizadas para comparação na receita foram a descrição do produto na primeira linha e o nome do
produto nos outros. O que você fez na receita não é possível alcançar usando a Banco de dados juntar-se, pelo menos, de
uma forma simples.
Note que você também poderia ter tido a declaração já construído, por exemplo, em um arquivo de propriedades ou salvos em uma coluna em
uma tabela de banco de dados. Nesse caso, você também poderia ter usado o fila SQL dinâmico passo para executar a instrução e que é
definitivamente impossível fazer com qualquer outro passo.
Veja também
210
Capítulo 6
As primeiras receitas no capítulo mostrou-lhe como olhar para obter mais informações em um banco de dados. Há ainda muitas outras
fontes de informação. Você pode precisar de olhar em arquivos de propriedade, em arquivos do Excel, em arquivos de texto, e assim por
diante. Chaleira permite-lhe olhar para os dados provenientes de todas as fontes com o lookup fluxo degrau. Neste exemplo, você tem
informações sobre livros provenientes de um arquivo do Excel, e você precisa para completar este conjunto de dados, observando-se os
dados do autor e descrição do gênero, que estão em fontes externas. Neste caso, o autor da informação é dentro de um arquivo de texto e
os gêneros estão em uma lista predefinida fixa.
Preparando-se
f Um arquivo CSV ( authors.txt) com os dados dos autores. O arquivo deve ter o seguinte
colunas: sobrenome, nome, nacionalidade, e id_author. A seguir, são linhas de amostra deste ficheiro:
f Um arquivo do Excel com as informações dos livros ( books.xls). A folha deve ter a
colunas seguinte: título, id_author, preço, id_title, e id_genre como mostrado na imagem seguinte:
211
Procurando por Dados
2. Deixe cair uma entrada Microsoft Excel e um passo entrada de arquivo de texto passo para a tela.
3. No entrada Microsoft Excel passo, procure o books.xls arquivo sob o arquivos guia e clique no Adicionar botão.
Preencher a grade sob a Campos guia clicando no
6. Criar uma hop do entrada Microsoft Excel passo para o lookup fluxo passo e
outra do entrada de arquivo de texto, também para o lookup fluxo degrau.
7. Dê um duplo clique sobre o lookup fluxo passo e no passo Lookup caixa de listagem, selecione a
nome do entrada de arquivo de texto etapa criado anteriormente.
Para economizar tempo, você pode clicar no obter Campos botão para carregar
automaticamente os campos na grade superior, eo
Obter campos de pesquisa botão para preencher a grade inferior.
9. Como visualizar esta etapa, você pode verificar que o conjunto de dados inclui, para cada livro, as informações para o seu
autor. Agora, vamos adicionar a descrição do gênero.
212
Capítulo 6
10. Gota um Grade de dados passo do Entrada categoria. sob o seu meta guia, adicione dois
itens corda id_genre e gênero. Em seguida, preencha o Dados guia, como mostrado na imagem
seguinte:
11. Adicione uma nova lookup fluxo passo e criar um hop do Grade de dados passo para
esta nova etapa.
12. Além disso, criar um hop entre ambos fluxo Lookup passos. A transformação deve
parecido com o mostrado na imagem seguinte:
13. Dê um duplo clique no último lookup fluxo degrau. No passo Lookup listagem, ou tipo
selecione o nome do Grade de dados passo criado anteriormente.
14. Na grelha superior, adicionar uma digitação linha id_genre debaixo de Campo e coluna identidade debaixo
LOOKUPFIELD.
15. Na grade inferior, adicionar um gênero Campo, do Corda Tipo. Adicionar Desconhecido Enquanto o
Padrão valor.
213
Procurando por Dados
16. Fazendo uma prévia desta etapa, você irá obter um conjunto de dados dos livros, os seus autores, e também a
descrição de seus gêneros. Um exemplo é mostrado na imagem seguinte:
Como funciona...
o fluxo Lookup passo é o passo que você deve usar para procurar informações adicionais em outras fontes. Nesta receita, os
principais dados vem de um arquivo do Excel com títulos de livros e, ainda, a identificação de seus autores e gêneros. Você
usou dois fluxo Lookup etapas de olhar para cima para cada título, o autor da informação, ea descrição gênero respectivamente.
Em primeiro fluxo Lookup etapa, o objetivo é olhar para os dados do autor; Nesta etapa, você configura o passo Lookup listbox
apontando para a entrada de arquivo de texto passo, que é onde os dados do autor está vindo. Na grelha superior chamado A
chave (s) para pesquisar os valores (s), você tem que especificar os campos usados para juntar as duas fontes de dados. Neste
A segunda grade intitulado Especificar os campos para recuperar é declarar os campos para adicionar ao conjunto de dados
principal. Você digitou o Fields primeiro nome, ultimo nome, e nacionalidade. O último
fluxo Lookup passo foi criado, a fim de recuperar a descrição gênero que corresponde a identificação de gênero no conjunto de
dados principal. Aqui os valores de chave são os campos id_genre e identidade
e os únicos dados para recuperar é o campo gênero. Aqui você inseriu Desconhecido Enquanto o Padrão
valor. Isto significa que, se o fluxo Lookup etapa não encontrar um gênero de correspondência para uma linha, a descrição do gênero será
definido como Desconhecido.
Tem mais...
As seções a seguir lhe fornecer algumas alternativas para o uso do fluxo Lookup degrau.
214
Capítulo 6
Se você não tem certeza sobre a semelhança dos valores entre os campos que você está comparando, uma comparação por igual pode falhar.
Nesse caso, você poderia usar o correspondência difusa passo, que lhe permite procurar valores semelhantes. Por exemplo, se você está
comparando um conjunto de dados de nomes, Bob iria corresponder a Bob. Às vezes, os erros de entrada de dados pode ocorrer, e você pode
ter que comparar Bob para arremessar ou qualquer outro erro de ortografia. correspondência difusa proporcionaria a probabilidade de que Lob
realmente deveria ter sido Bob. Isso poderia se tornar problemático se houve também uma Rob no conjunto de dados; mas correspondência
difusa fornece uma maneira de, pelo menos, chamar problemas potenciais. Se você precisa comparar o uso de outros operadores, por exemplo,
<=, então você deve olhar também para uma etapa alternativa. Uma abordagem possível seria a utilização do Junte-se a linhas (produtos
artesiano)
para recuperar todos os dados e filtrar as linhas a partir desse passo com um Filtrar linhas ou um Filtro Java
passo depois.
Tenha em mente que Junte-se a linhas (produto cartesiano) pode aumentar o número de registros
que você está processando, abrandar o seu processo de forma significativa. produtos cartesianos
fornecer todos os emparelhamentos dos dois conjuntos de dados, por exemplo, se foram juntando
um conjunto de dados com dez registros e outro conjunto de dados com trinta registros,
acabaríamos com 300 registros. Outra opção seria transferir os dados de origem para uma tabela
de banco de dados e, em seguida, consulta no banco de dados. Essa abordagem leva um pouco
mais de esforço, mas tem suas vantagens. Você tem formas mais flexíveis para procurar dados em
um banco de dados em comparação com olhando para cima em um córrego. Além disso, para
grandes conjuntos de dados, você também pode ganhar desempenho como explicado na próxima
subseção.
trabalhar. Como solução para acelerar as coisas, você deve considerar mover os dados para uma tabela de banco de dados antes de olhar
em cima dele. As principais vantagens desta abordagem é que você pode armazenar em cache e dados de índice, o que torna a tarefa de
pesquisa mais rápido. E se o seu projeto não envolve tarefas de banco de dados? Por estas tabelas de pesquisa temporários, você pode
querer usar um banco de dados in-memory como HSQLDB ou H2. Dados em memória, fornecer todos os benefícios de bancos de dados
tradicionais para situações em que os dados não têm que ser constantemente persistiu.
215
Procurando por Dados
Para um exemplo prático deste, dê uma olhada no post por Slawomir Chodnicki em
http://type-exit.org/adventures-with-open-source-bi/2011/01/using-anon-demand-in-memory-sql-database-in-pdi/.
Usando o passo Valor Mapper para procurar a partir de uma pequena lista de valores
O segundo fluxo Lookup passo na receita só retorna uma descrição simples e tem uma pequena lista de possíveis
valores. Nestes casos, você pode substituir esta etapa com um valor Mapper
de Transformar categoria.
No value fonte coluna, você define os valores possíveis para o id_genre campo e na valor-alvo coluna, você define
suas descrições. Além disso, no Padrão na não-correspondência caixa de texto, você pode inserir um valor padrão a
ser devolvido para as linhas com identificação do gênero inválido.
Veja também
fA receita Gerando todos os pares possíveis formados a partir de dois conjuntos de dados em Capítulo 7,
216
Capítulo 6
Este capítulo é sobre a procura de valores em diferentes fontes com base em determinadas condições. Essas condições são uma
comparação entre os campos em seu fluxo e campos na fonte que você está procurando. Como você sabe, ou podia ver no resto
das receitas, normalmente você comparar pela igualdade e às vezes você fazer isso usando operadores diferentes, tais como LIKE,
não é igual, <, e assim por diante. E se você precisa olhar para um valor que é mais ou menos igual a um campo em seu stream?
Nenhuma das opções que você viu nas outras receitas lhe dará a solução para este problema. Nessas situações, você precisa
executar uma pesquisa difusa, ou seja, uma pesquisa que procura por valores semelhantes. Chaleira permite executar tal busca,
fornecendo-lhe o correspondência difusa degrau. Nesta receita, você vai aprender como usar esta etapa.
Suponha que você recebe um arquivo de texto externo com pedidos de livros e você precisa encontrar os preços para estes
livros. O problema é que você não tem a identificação para esse livro, você só tem o título, e você não tem certeza se a
ortografia está correta.
Preparando-se
Você deve ter um banco de dados de livros com a estrutura mostrada na Apêndice A, Estruturas de Dados.
A receita usa um arquivo chamado booksOrder.txt com os seguintes títulos de livros, que inclui deliberadamente alguns erros
de digitação:
2. Gota um entrada de arquivo de texto passo para a área de trabalho, a fim de recuperar a ordem livro.
3. No Arquivo ou diretório caixa de texto sob o Arquivo aba, navegue até o booksOrder.txt
arquivo e, em seguida, clique no Adicionar botão.
217
Procurando por Dados
6. Deixe cair mais um passo para ler o banco de dados de livros. Use um A introdução da tabela passo e
digite a seguinte instrução SQL:
SELECT title
, O preço
dos livros
7. Adicione uma correspondência difusa passo do Olho para cima categoria. Adicionar um salto a partir do A introdução da tabela
passo para este passo. Adicionar outro hop do entrada de arquivo de texto etapa criado antes, também em direção ao correspondência
difusa degrau.
8. Dê um duplo clique sobre o correspondência difusa degrau. Debaixo de Geral guia, vá para o Olho para cima
corrente (fonte de) quadro e como etapa de pesquisa, selecione os A introdução da tabela etapa criado antes. No campo de
10. Agora, você deve selecionar o algoritmo de correspondência difusa para ser usado. Neste caso, você vai usar
12. De acordo com a mesma guia, adicione o preço campo para a grade.
218
Capítulo 6
14. Se você selecionar a correspondência difusa passo e visualizar a transformação, o resultado vai olhar
como a imagem seguinte:
Como funciona...
o correspondência difusa passo é usado para procurar em outro fluxo para valores que são semelhantes ao valor de um campo
em seu fluxo. Para cada linha no conjunto de dados, é feita uma comparação entre o campo de fluxo principal ( TitleApprox neste
caso) e cada campo de pesquisa no fluxo secundário ( título). Em outras palavras, para cada livro na lista, é feita uma comparação
entre o título fornecido e os títulos reais provenientes do banco de dados.
A comparação consiste na aplicação de um determinado algoritmo de correspondência difusa. UMA algoritmo de correspondência difusa
compara duas cordas e calcula um índice de similaridade. A linha com o menor índice é devolvido, como
desde que seja entre o valor mínimo e a Valor máximo.
Nesta receita, foi utilizado o algoritmo de jogo Levenshtein que calcula uma distância métrica. O índice de similaridade para este
algoritmo representa o número de edições necessárias para transformar um campo para o outro. Estas edições podem ser
inserção de caracteres, supressão ou substituição de um único personagem.
Como valores mínimos e máximos, você especificado 0 (o que significa que o título exacto foi encontrado) e 3 (o que significa que
você vai aceitar um título como válida com um máximo de três edições). Por exemplo, quando você visualiza o resultado desta
etapa, você pode ver um título chamado O sone Ded
que coincide com o título real, The Dead Zone com uma distância de 2. Para o Star Island título é a distância 0 porque a ortografia
estava correto e foi encontrado um livro com exatamente o mesmo título. Finalmente, para o Harry Potter linha, não há registros
coincidentes, porque você precisa de muitas edições para transformar o título fornecido em um dos títulos de Harry Potter no
banco de dados.
219
Procurando por Dados
Tem mais...
o correspondência difusa passo permite-lhe escolher entre vários algoritmos correspondentes, que são classificados em dois
grupos seguintes:
220
Capítulo 6
Par letras distância As cordas são divididos em pares e, em O emparelhamento de 'pciking' a 'colheita'
Similaridade métrica seguida, o algoritmo calcula um índice proporciona 3 pares comuns (ki, em, ng)
com base na comparação das listas de de um total de 6 pares. O valor devolvido
pares de ambas as cadeias. é
0,5.
A decisão de qual algoritmo para escolher depende do seu problema e o tipo de dados que você tem ou você espera receber.
Você pode até combinar uma pesquisa difusa com uma pesquisa regular. Por exemplo, na receita, você não encontrar uma
correspondência para o Harry Potter linha. Note-se que o aumento do valor máximo não teria encontrado o título próprio. Tente
aumentar o valor máximo para 10, e você vai ver que o algoritmo traz Carrie como resultado, o que claramente não tem nada a ver
com o assistente. No entanto, se você olhar para este valor com um banco de dados juntar-se passo a comparação com o GOSTAR operador,
você pode recuperar não apenas um, mas todos os títulos de Harry Potter. Mais detalhes sobre as métricas de similaridade
individuais podem ser encontradas em http: //en.wikipedia. org / wiki / String_metrics.
Wikipedia também tem artigos para os algoritmos que entrar em mais detalhes sobre como eles funcionam.
221
Procurando por Dados
f Pedido:
f Resposta:
Como acontece com qualquer XML, a estrutura tanto da solicitação e resposta são importantes. O pedido está
pedindo as horas do museu fornecido. A resposta irá retornar as horas no
GetMuseumHourResponse como uma string.
222
Capítulo 6
Preparando-se
Você deve ter um banco de dados com a estrutura do museu mostrado na Apêndice A, Estruturas de Dados
e acesso a um serviço web semelhante ao descrito anteriormente. No site da Packt, não há código de exemplo para esses
serviços. Os serviços são executados com um servidor que suporta ASP.NET, tais como Microsoft de Internet Information Services
(IIS) ou utilizando um servidor Apache com mono, uma plataforma cruzada, estrutura de desenvolvimento .NET open source.
2. Gota um A introdução da tabela passo na área de trabalho, a fim de obter os dados com a lista de
museus. Digite a seguinte instrução SQL:
id_museum SELECIONAR
, nome
, cidade
, País de
museus JOIN
cidades
EM museums.id_city = cities.id_city
3. Adicione uma pesquisa de serviço Web passo do Olho para cima categoria.
4. Clique duas vezes no degrau. No Serviços web guia, digite o endereço URL para a web
serviço. É importante apontar para o Web Service Definition Language (WSDL)
caminho de declaração, por exemplo, http: // localhost / museumHours / Service. asmx? wsdl.
6. No Operação caixa de listagem, selecione o método de web chamado GetMuseumHour. Isto gera as entradas
e saídas necessárias abas; você também pode gerá-los clicando no Adicionar Input e Adicionar Output botões.
Além disso, você também pode incluir credenciais de autenticação para o serviço
Web e informações de proxy, se necessário.
223
Procurando por Dados
9. Você poderia executar a transformação agora e examinar os resultados. Uma abordagem melhor seria verificar a
disponibilidade do serviço web antes da execução. Então, criar um novo trabalho e adicionar um Começar entrada.
10. Adicione uma Verifique a disponibilidade webservice entrada de trabalho do condições categoria.
11. Dê um clique duplo na etapa. Colocou o URL caixa de texto para o endereço WSDL, neste caso
http:? //localhost/museumsHours/Service.asmx wsdl.
12. Depois que a entrada, adicione um Transformação entrada para executar a transformação criou anteriormente.
Certifique-se de que a transformação é executado somente se a entrada anterior bem-sucedido. Isto é, clique direito sobre o
hop e verificar a Siga quando resultado é verdadeiro opção de avaliação.
13. A execução do trabalho retornará a lista de museus, sua localização geográfica, e seu horário de funcionamento.
Como funciona...
O objetivo do exemplo é procurar um valor que está hospedado em um servidor web. Você faz isso por consumir um serviço
web.
Note que a URL do serviço web no pesquisa de serviço Web passo aponta para um endereço WSDL. WSDL é uma linguagem
baseada em XML usado para descrever os serviços web. Quando você clica no Carga botão no pesquisa de serviço Web etapa,
as informações recuperadas do contrato WSDL é interpretada e utilizada para preencher o Operação Combo com a métodos da
web encontrados no serviço de web. Quando você escolhe um método, que ajusta automaticamente os valores necessários
para a entrada e a saída. Você só precisa escrever os valores locais que serão passados como parâmetros ( Em guia), e o valor
para o resultado ( GetMuseumHourResult aba). Se as guias para a entrada e saída não são criados automaticamente, você
pode escrever as especificações manualmente, clicando no Adicionar Input e Adicionar Output botões. Para cada linha museu,
haverá uma solicitação para o serviço Web passando a id_museum parâmetro declarado no Em aba. O resultado contendo o
museu abertura horas será guardada na
Tem mais...
Há também uma etapa chamada Verifique se webservice está disponível de Olho para cima categoria. Você pode usá-lo para verificar se
o serviço web está disponível apenas antes de consumi-la. Nesta etapa, você deve ter o endereço URL como um campo em cada linha.
Em alguns casos, o servidor web poderia ser inundada devido aos múltiplos pedidos simultâneos, e que poderia retornar um
erro semelhante ao Muitos usuários estão conectados.
Nestes casos, você pode verificar a configuração do servidor web. Alternativamente, você pode executar novamente a transformação
consumir o serviço web por grupos de linhas, forçando um atraso para evitar a saturação do servidor web.
224
Capítulo 6
Para mais informações sobre serviços da web, você pode visitar http://en.wikipedia.org/ wiki / Web_service.
Veja também
Preparando-se
Você deve ter um banco de dados com a estrutura do museu mostrado na Apêndice A, estruturas de dados,
e uma página web que fornece o museu do horário de funcionamento. A receita usa uma página ASP chamada hours.asp, mas
você pode usar o idioma de sua preferência. Esta receita vai exigir um servidor que suporta ASP (ou o idioma de sua
preferência), como o IIS da Microsoft, ou o servidor web Apache com mono, uma plataforma cruzada, estrutura de
desenvolvimento .NET open source. A página recebe identificação do museu e retorna um string com o cronograma.
Você pode baixar uma página web amostra do site da Packt.
, nome
, cidade
, País de
museus JOIN
cidades
EM museums.id_city = cities.id_city
225
Procurando por Dados
4. Clique duas vezes no degrau. No URL campo sob o Geral guia, digite o HTTP
endereço web da página que fornece as horas de abertura. Por exemplo:
http: //localhost/museum/hours.asp.
7. Sob a Campos guia, defina o parâmetro que será enviado para a página como um PEGUE
parâmetro. Tipo id_museum em ambos, o Nome e Parâmetro colunas.
8. O resultado para a transformação vai ser o mesmo que o obtido na receita anterior.
9. Dê uma olhada em que receita para uma pré-visualização dos resultados finais.
Como funciona...
o cliente HTTP etapa procura por horário de funcionamento dos museus mais o intranet-o passo faz uma solicitação
para a página web para cada museu no conjunto de dados. Um exemplo deste pedido passando o parâmetro seria http:?
//localhost/museum/hours.asp id_museum = 25.
Em seguida, a resposta da página que contém as horas de abertura do museu vai definir o horas campo. o estado campo irá
realizar o código de status da operação. Por exemplo, um código de status igual a 200 significa um pedido bem sucedido,
enquanto um código de status 400 é uma má pedido. Você pode verificar os diferentes códigos de status na http://en.wikipedia.org/wiki/List_of_HTTP_
status_codes.
Tem mais...
Suponha que cada museu tem um site diferente (e um endereço de URL diferente) com uma página web que fornece seu horário de
funcionamento. Neste caso, você pode armazenar esta URL específica como um novo campo no conjunto de dados museu. Em seguida,
no cliente HTTP passo verificar o Aceitar URL do campo?
caixa de seleção e selecionar o campo do nome do campo URL drop-down list.
226
Capítulo 6
Uma alternativa para esta etapa é o HTTP Post Lookup degrau. Usando esta etapa, você
se conectar ao site e passar os parâmetros através de um POSTAR método em vez de um PEGUE
método.
Veja também
Durante o processamento de dados não acabará por chegar um momento em que é fundamental para validar os dados, enquanto no fluxo, para
garantir que é de suficiente alta qualidade para continuar a executar o processo. Chaleira vem com várias etapas internas que fornecem
capacidades de validação, incluindo um genérico dados Validator passo que permite que os dados sejam processados com um conjunto
personalizado de regras. Para esta receita, estaremos construindo algumas regras personalizadas para validar os dados do autor da base de dados
dos livros.
Preparando-se
Você deve ter um banco de dados que coincide com estruturas de dados dos livros, como listado na Apêndice A, Estruturas de Dados. O
código para construir esta base de dados está disponível no site da Packt.
3. Abra o passo e configurá-lo para se conectar ao banco de dados dos livros. Para a consulta, clique em Obter SQL
select ... e selecione a tabela dos autores.
6. Sob o Validação categoria, selecione o dados Validator degrau. Adicionar um salto entre a
A introdução da tabela passo e o dados Validator degrau.
227
Procurando por Dados
10. Clique no New Validação novamente. Desta vez, chamar a nova regra lastname_check.
11. Preencha os detalhes como antes, com o tipo de dados ser Corda. No Regular
expressão não permitidos para corresponder campo, digite \ d +. No Nome de campo para validar
caixa de texto, digite o último nome campo.
12. Verifique a opção Relatar todos os erros, não só o primeiro. Clique em Está bem para sair do passo.
13. Visualização do dados Validator passo, e os dados do autor deve processar sem problema.
Agora, vamos introduzir um erro que faria com que o dados Validator regras para acionar um fracasso.
228
Capítulo 6
14. A partir da Transformar categoria, selecione uma Substituir na corda passo e trazê-lo para o
tela entre o Entrada Tabela e dados Validator passos. Abra o passo e inserir os detalhes, como
mostrado na imagem seguinte:
15. A partir da Fluxo categoria, selecione uma Manequim passo e torná-lo o passo de tratamento de erros
do dados Validator passo a criação de um hop a ele e clique com o botão direito sobre o dados Validator passo e
selecionando Definir o tratamento de erros ....
16. Visualize o Manequim degrau. Cada registro autor com um último nome valor do campo de Rei
agora erro fora e aparecem na etapa de tratamento de erros.
Como funciona...
o dados Validator etapa leva muito básico, a moderadamente lógica avançada para aplicar aos dados em stream, e validar se os dados, pelo
menos, está em conformidade com essas regras. Se os dados não é limpo, pode ser possível aplicar mais lógica de transformação para
limpar os dados, caso contrário um processo pode continuar a funcionar com os dados validados e não falhar devido a registros sujos.
Tem mais...
Existem algumas outras etapas de validação especializados que são personalizadas para determinados casos de uso. A tabela a
seguir lista essas etapas especializadas, e quando é apropriado usá-los:
validador de cartão de crédito Validar números de cartão de crédito para garantir que eles são pelo menos formatado de
forma adequada
validador correio Valida endereços de correio electrónico, em que eles sejam devidamente formatado. também pode ser
229
Procurando por Dados
Veja também
230
7
Entendendo e otimizando
fluxos de dados
Introdução
O principal propósito de transformações da chaleira é manipular dados sob a forma de um conjunto de dados, uma tarefa feito
pelos passos da transformação. Quando uma transformação é lançado, todos os seus passos são iniciados. Durante a
execução, as etapas de trabalho lendo simultaneamente linhas a partir do lúpulo de entrada, processá-los e entregá-los para o
lúpulo de saída. Quando não há mais linhas esquerda, a execução da transformação termina.
O conjunto de dados que flui passo a passo é efetivamente um conjunto de linhas com os mesmos metadados. Isto significa que
todas as linhas têm o mesmo número de colunas, e as colunas em todas as linhas têm o mesmo tipo e nome.
Suponha que você tenha um único fluxo de dados e que você aplicar as mesmas transformações para todas as linhas, ou seja,
você tem todas as medidas ligadas em uma linha após o outro. Em outras palavras, você tem a mais simples das transformações
do ponto de vista da sua estrutura. Neste caso, você não precisa se preocupar muito sobre a estrutura do seu fluxo de dados,
nem a origem ou destino das linhas. A parte interessante vem quando você enfrentar outras situações, por exemplo:
f Você quer um passo para iniciar o processamento de linhas somente após mais um passo dado tem
f Você tem mais de um fluxo e você tem que combiná-los em uma única
corrente. Por exemplo, o carregamento de dados a partir de múltiplas fontes que vai ser inserido um único alvo.
f Você tem que injetar linhas no meio do seu fluxo e as linhas não têm
a mesma estrutura que as linhas em seu conjunto de dados. Por exemplo, você tem dados que já está formatado, mas um
novo conjunto de dados (com uma estrutura diferente) precisa ser formatado antes de ambos os conjuntos são inseridos
em um alvo.
Com Chaleira, você pode realmente fazer isso, mas você tem que ter cuidado porque é fácil acabar fazendo coisas erradas e
obtendo resultados inesperados ou até mesmo pior; erros indesejáveis. No que diz respeito ao primeiro exemplo, não
representam um comportamento padrão, devido à natureza paralela das transformações como explicado anteriormente. Há duas
f Bloqueio passo: Este blocos etapa de processamento até que todas as linhas de entrada têm
foi processado
f Bloquear este passo até que passos terminar: Este blocos etapa de processamento até que o seleccionado
categoria.
232
Capítulo 7
Você vai encontrar exemplos do uso da última dessas etapas nas seguintes receitas:
fo Gerando um arquivo de log personalizado receita em Capítulo 10, Obtendo o máximo de Kettle
Este capítulo enfoca os outros dois exemplos e alguns casos de uso semelhantes, explicando as diferentes maneiras para
combinar, separação, ou manipular fluxos de dados.
pequenos. No Tem mais... seção, você também vai ver formas alternativas e mais eficientes para fazer a mesma coisa em
diferentes cenários. Vamos supor que você tem um conjunto de produtos ao ar livre em um arquivo de texto, e você quer se
diferenciar tendas de outros tipos de produtos, e também criar uma subclassificação das tendas, dependendo seus preços.
Preparando-se
Para executar esta receita, você vai precisar de um arquivo de texto chamado outdoorProducts.txt com informações sobre produtos
ao ar livre. O arquivo contém informações sobre a categoria e preço de cada produto.
2. Arraste um entrada de arquivo de texto passo para a tela e preencher o Arquivo guia para ler o arquivo
nomeado outdoorProducts.txt. Se você estiver usando o arquivo de texto de exemplo, tipo, como o Separador.
233
Entendendo e otimizando fluxos de dados
3. De acordo com o Campos guia, use o obter Campos botão para preencher a grade. Ajusta a
entradas para que a rede se parece com o mostrado na imagem seguinte:
4. Agora, vamos adicionar os passos para gerenciar o fluxo das linhas. Para fazer isso, arraste dois Filtro
linhas passos da Fluxo categoria. Além disso, arraste três Manequim passos que representam as três correntes
resultantes.
Manequim passos são usados para que possamos visualizar os dados filtrados. Normalmente,
iríamos continuar trabalhando com os dados até que ele estava pronto para ir em um passo de
saída.
5. Criar o lúpulo, como mostrado na imagem seguinte. Quando você cria o lúpulo, certifique-se de escolher as opções de
acordo com a imagem: Resultado é verdadeiro para a criação de um hop com um ícone verde, e Resultado é FALSE para
a criação de um hop com um ícone vermelho nele.
6. Dê um duplo clique no primeiro Filtrar linhas passo e completar a condição, como mostrado na
imagem seguinte:
234
Capítulo 7
8. Você acabou de dividir o conjunto de dados original em três grupos. Você pode verificá-lo, visualizando cada Manequim
degrau. O primeiro tem produtos cuja categoria não é tendas; o segundo, as tendas menos de 100 US $; eo
último grupo, as tendas caros, aqueles cujo preço é mais de 100 US $.
Como funciona...
O objetivo principal na receita é dividir um conjunto de dados com os produtos em função da sua categoria e preço. Para fazer isso, você usou o Filtrar
linhas degrau. No Filtrar linhas janela de configuração, você diz Kettle onde a transferência de dados para, dependendo do resultado da avaliação
de uma condição para cada linha. A fim de fazer isso, você tem duas caixas de listagem: Enviar dados 'verdadeiras' para a etapa e Enviar dados
'falsos' para a etapa. Os passos de destino pode ser definido usando as propriedades de lúpulo, como você fez na receita. Alternativamente,
diálogo de configuração selecionando o nome dos passos destino da lista drop-down disponíveis. Você também tem
que entrar no estado. Ao entrar condições, você verá um formulário condição semelhante à mostrada na imagem
seguinte:
fA caixa de texto no lado da mão esquerda é para selecionar o campo que será usado
para comparação.
235
Entendendo e otimizando fluxos de dados
f No lado direito você tem duas caixas de texto: a caixa de texto superior para comparar
contra um campo e a caixa de texto inferior para comparar com um valor constante. Além disso, você pode
incluir mais condições clicando no Adicionar condição botão no lado direito. Se você clicar com o botão direito em uma
condição, um menu contextual parece deixá-lo apagar, editar, ou movê-lo. Em primeiro Filtrar linhas etapa da receita, você
digitou uma condição simples: você comparou um campo ( categoria) com um valor fixo ( tendas) usando um é igual a (=)
operador. Você fez isso para separar os produtos de tenda dos outros. O segundo filtro teve o objetivo de diferenciar a
cara e as tendas baratos.
Tem mais...
As linhas que não satisfazem a condição terminará no Manequim degrau. Embora esta é uma solução muito comumente usado para
manter apenas as linhas que atendem as condições, há uma maneira mais simples de implementar. Quando você cria o hop do Filtrar
linhas passo para o próximo passo, você será solicitado para o tipo de salto que você planeja usar. Se você escolher saída principal da
etapa, as duas opções Enviar dados 'verdadeiras' para a etapa e Enviar dados 'falsos' para a etapa permanecerá vazio. Isso fará com
que duas coisas:
236
Capítulo 7
Vamos supor, por exemplo, você tem um parâmetro chamado chamado categ com cozinha Como
Valor padrão. Como você poderia saber, parâmetros nomeados são um tipo particular de Kettle variável.
Para usar essa variável em uma condição, você deve adicionar ao seu conjunto de dados com antecedência. Você pode fazer isso da seguinte
forma:
1. Adicione uma obter Variáveis passo do Trabalho categoria. Coloque-o na corrente após a Arquivo de texto
entrada passo e antes do Filtrar linhas degrau; usá-lo para criar um novo campo chamado categ
do Corda digitar com o valor $ { categ} no Variável coluna.
3. Após isso, você pode definir a condição do primeiro Filtrar linhas passo para categoria =
categ, seleção categ a partir da caixa de listagem de campos à direita. Desta forma, você estará filtrando a cozinha
produtos.
4. Se você executar a transformação e definir o parâmetro para tendas, você vai obter resultados semelhantes aos
que foram obtidos na receita principal.
Vamos supor que você tem que enviar as linhas para diferentes etapas, dependendo da categoria. A melhor maneira de fazer isso
é com o Switch / case degrau. Desta forma, você evitar a adição de um Filtrar linhas passo para cada categoria.
237
Entendendo e otimizando fluxos de dados
Nesta etapa, você tem que selecionar o campo a ser usado para comparar. Você fazê-lo na nome do campo para alternar listbox.
No valores de caso grade, você definir o etapa valor-alvo pares. A imagem seguinte mostra como preencher a grade para o nosso
problema particular:
f Você pode ter vários valores voltados para a mesma etapa alvo.
f Você pode deixar a coluna em branco valor para especificar um passo alvo para valores vazios.
f Você tem uma caixa de listagem com o nome passo alvo padrão para especificar a etapa alvo para linhas que
f Se você quiser comparar contra um substring do campo, você pode permitir que o Usar
cadeia contém opção e como Caso valor, digite o substring que você está interessado. Por exemplo, se para Caso
valor, você digita barraca_, todas as categorias que contêm tent_ tais
Como tent_large, tent_small, ou tent_medium será redireccionado para o mesmo passo alvo.
238
Capítulo 7
Os nomes dos listboxes- passo destino para linhas correspondentes (opcional) e passo destino para linhas não
correspondentes (opcional) -differ dos nomes no Filtrar linhas passo, mas sua finalidade é a mesma.
Como exemplo, o seguinte são as condições que você usou na receita reescrito como expressões Java: category.equals
( "tendas") e preço <100. Estes são extremamente simples, mas você pode escrever qualquer expressão Java, contanto
que é avaliada como um resultado booleano.
Se você não pode garantir que a categoria não será nulo, é recomendável
que você inverta a primeira expressão e colocá
"Tendas" .equals (categoria) em vez de. Ao fazer isso, sempre que você tem que
verificar se um campo é igual a uma constante, você evita um erro Java
inesperado.
Finalmente, suponha que você tem que dividir os fluxos simplesmente para definir alguns campos e, em seguida, juntar-se aos fluxos de novo.
Por exemplo, suponha que você quer mudar a categoria da seguinte forma:
Fazer isso com nested Filtrar linhas etapas leva a uma transformação, tal como o seguinte:
239
Entendendo e otimizando fluxos de dados
Você pode fazer a mesma coisa de uma forma mais simples: Substituir todos os passos, mas preencher o Arquivo de texto entrada com um User
1. Na janela de configuração desta etapa, adicionar uma linha para substituir o valor do
categoria campo: como Novo campo e substituir valor tipo categoria. Como tipo de valor selecionar
Corda. Como expressão Java, digite o seguinte:
2. Faça uma prévia sobre este passo. Você verá algo semelhante ao seguinte:
240
Capítulo 7
Suponha que você recebeu dados sobre montanhas-russas de duas fontes diferentes. Os dados em uma dessas fontes é
semelhante ao seguinte:
roller_coaster | velocidade | parque | localização | país | Ano Top Thrill Dragster | 120 mph | Cedar Point
| Sandusky, Ohio || 2003 Dodonpa | 106,8 mph | Fuji-Q Highland | Fujiyoshida-shi | Japão | 2001 Steel
Dragon 2000 | 95 mph | Nagashima Spa Land | Mie | Japão | 2000 Millennium Force | 93 mph | Cedar
Point | Sandusky, Ohio || 2000 Intimidator 305 | 90 mph | Kings Dominion | Doswell, Virginia || 2,010
Titan | 85 mph | Six Flags Over Texas | Arlington, Texas || 2001 Furious Baco | 84 mph | PortAventura |
Espanha || 2007
. . .
atração | park_name | top_speed | trains_qt | ride_time Expedition Everest | Animal Kingdom da Disney | 50 mph |
6-34 de passageiros |
Journey to Atlantis | SeaWorld Orlando || 8 barcos de passageiros | Kraken | SeaWorld Orlando | 65 mph | 3-32
passageiros | 2 minutos, 2 segundos
. . .
Você quer fundir as linhas em um único conjunto de dados com as seguintes colunas:
f atração
f park_name
f Rapidez
f trains_qt
f ride_time
Preparando-se
Faça o download dos arquivos roller_coasters_I.txt e roller_coasters_II.txt da página do livro. Esses arquivos
representam as duas fontes mencionadas na introdução.
1. Crie uma transformação e arraste dois entrada de arquivo de texto passos para a tela.
241
Entendendo e otimizando fluxos de dados
2. Use um dos passos para ler o arquivo roller_coasters_I.txt. Definir os tipos de dados
como se segue: o Rapidez Como Número com Formato # 0. ### mph, eo resto dos campos como Corda. Faça uma pré-visualização
para se certificar de que você está lendo o arquivo corretamente.
3. Arraste o cursor sobre a etapa e pressione a barra de espaço para ver os campos de saída:
4. Use o outro passo para ler o arquivo roller_coasters_II.txt. Defina o tipo de dados
velocidade máxima para número inteiro e o resto dos campos para Corda. Faça uma pré-visualização para se certificar de que você
5. Arraste o cursor sobre a etapa e pressione a barra de espaço para ver os campos de saída:
6. Como você pode ver, as saídas dos fluxos são diferentes. É necessário inserir as medidas necessárias para
torná-los iguais. Esse é o propósito dos próximos passos.
7. Após o primeiro entrada de arquivo de texto passo adicionar um Adicionar constantes degrau. Use-o para adicionar dois
8. Após isso, adicione um Selecione os valores degrau. Preencha o Selecione & Alter guia, como mostrado na
imagem seguinte:
242
Capítulo 7
9. Após o segundo entrada de arquivo de texto etapa, adicionar outro Selecione os valores degrau. Selecione os
10. Repita o procedimento para ver os campos do fluxo de saída: arraste o cursor sobre o último passo de cada corrente e
pressione a barra de espaço. Agora, ambos os fluxos devem ter o mesmo layout.
Você pode manter ambas as janelas abertas ao mesmo tempo: a que mostra os
campos do curso superior de saída, e aquele que mostra os campos do mais baixo de
saída. Se você colocar uma ao lado da outra, você pode ver imediatamente se eles
são iguais ou não.
11. Finalmente, junte-se os fluxos com um Manequim passo, conforme ilustrado no diagrama a seguir:
12. Fazer uma pré-visualização na Manequim degrau. Você verá algo semelhante ao resultado mostrado
na imagem seguinte:
243
Entendendo e otimizando fluxos de dados
Como funciona...
Quando você precisa mesclar as fileiras de dois fluxos em um único fluxo, você tem que fazer todo o possível para tornar os
metadados dos fluxos iguais. Isso é o que você fez nesta receita. No primeiro fluxo, você adicionou os campos necessários que
estavam ausentes. Você também selecionado e reordenados os campos desejados para assemelhar-se a segunda corrente. Depois
disso, você mudou os metadados do velocidade máxima campo na segunda corrente. Você convertido o campo de número inteiro para Número,
que foi o tipo de campo análogo na primeira corrente. Quando você fez a pré-visualização, você pode
Tem mais...
Na receita, você fundiu dois fluxos com dados provenientes de diferentes fontes. No entanto, essa não é a única situação em
que você pode precisar de mesclar córregos. É comum para dividir um fluxo em duas ou mais correntes para executar algumas
manipulações específicas e então juntá-las para trás em conjunto, tal como representado no diagrama a seguir:
Seja qual for o caso, quando você tem que mesclar dois ou mais fluxos, existem as seguintes duas coisas que você deve
se lembrar:
244
Capítulo 7
Se você tentar mesclar fluxos que não atendem a esse requisito, você receberá um aviso. Uma janela irá aparecer com o título Este
hop faz com que a etapa de destino para receber linhas com disposição mista! e um texto explicando as diferenças encontradas.
Isso significa que você tem que encontrar a maneira de corrigir essa situação. A seguir está uma lista rápida que irá ajudá-lo a
fazer os metadados de vários fluxos similares:
f Identificar os campos que pretende no conjunto de dados final que não estão presentes em todos
riachos. Nos fluxos que não têm esses campos, adicioná-los. Você pode obter o valor de qualquer fonte (um arquivo
de texto, a linha de comando, e assim por diante), ou simplesmente pensar em um valor padrão e adicione o campo
com um Adicionar constante passo do Transformação categoria. Isto é o que você fez com os campos trains_qt e ride_time.
f Identificar os campos que você deseja manter que estão presentes em todos os fluxos, mas com uma
estrutura diferente. Alterar os metadados desses campos nos riachos onde os metadados não é tão desejado.
Você pode fazer isso com um Selecione os valores etapa usando o
metadados aba. Isto é o que você fez para o campo velocidade máxima.
f Verificar os layouts dos córregos. Se eles ainda são diferentes, para cada fluxo que não tem
o layout adequado, adicionar um Selecione os valores passo no final. Com este passo, selecionar os campos que você deseja
manter (excluindo implicitamente os outros), renomear e reorganizar-los, a fim de coincidir com o layout desejado. Este foi o que você
fez com o primeiro Selecione os valores degrau. Agora, você está livre para mesclar os fluxos, como explicado na próxima subseção.
f Suponha que você quer colocar todas as linhas de um dos fluxos abaixo de todas as linhas de
o outro. Se você não se preocupam com a ordem dos córregos, você pode usar qualquer passo para fundi-los.
Este foi o que você fez na receita com o Manequim degrau.
f Se você se preocupa com a ordem dos fluxos, você deve usar o Anexar Streams degrau
de Fluxo categoria, a fim de mesclar os fluxos. Ao selecionar uma hop cabeça e uma hop cauda, você pode dizer
Chaleira qual fluxo vai primeiro.
245
Entendendo e otimizando fluxos de dados
Isso só funciona para apenas dois fluxos. Se você precisa mesclar vários fluxos, você
precisa adicionar aninhada Anexar Streams passos.
f Suponha que você realmente deseja mesclar as linhas dos fluxos e deixá-los
ordenados por determinados campos. Você faz isso com um Mesclar classificadas passo do Junte-se categoria. O passo
assume que cada fluxo, por sua vez são classificados pelos mesmos campos. Note-se que Chaleira avisa, mas não
impedi-lo de misturar layouts de linha quando você mesclar córregos. Se você ver um aviso deste tipo, consulte as
dicas no inciso anterior.
Se você quiser Chaleira para impedi-lo de executar uma transformação com disposição
mista, marque a opção Ativar o modo de segurança localizado nas janelas que aparece
quando você executar a transformação. Note-se que o uso do Ativar o modo de segurança opção
irá causar uma queda no desempenho e só deve ser usado quando você está depurando
uma transformação.
Veja também
Embora existam muitas maneiras de verificar que os seus conjuntos de dados são válidos, uma prática comum é criar uma soma de verificação
com base nos dados para determinar se ele é diferente de um conjunto de dados de referência.
checksums são um hash dos dados fornecidos para o algoritmo de geração de ele, fazendo com que cada uma quase único para os
dados que construiu.
Chaleira fornece uma maneira de adicionar uma soma de verificação para cada registro em seu conjunto de dados através da Adicionar um
checksum degrau.
Para esta receita, estaremos comparando dados entre o banco de dados montanha russa e um arquivo simples que pode ter novas
montanhas-russas listadas nele.
Preparando-se
Para esta receita, você vai precisar dos arquivos associados com esta receita, que pode ser baixado da página do livro.
Mais detalhes sobre os arquivos podem ser encontrados na receita
Comparando duas correntes e a geração de diferenças. Há um arquivo SQL que irá criar base de dados dos parques e uma
lima chata estaremos comparando os dados.
246
Capítulo 7
2. Arraste um A introdução da tabela passo para a tela. Este passo será usada para executar o
seguinte instrução SQL:
roller_coaster SELECIONAR
, Rapidez
, parque
, localização
, país
, ano
DE montanhas-russas
ORDER BY roller_coaster
, parque
3. arrastar um Arquivo de texto entrada para a tela e usá-lo para ler a top_roller_
coasters_updates.txt Arquivo. Como separador, tipo |.
4. No Campos guia, certifique-se de seleccionar obter Campos para puxar os metadados do arquivo para a etapa.
6. Arraste dois Adicionar um checksum passos para a tela. Criar um hop entre a Mesa
entrada e um do Adicionar um checksum passos. Repetir o processo entre o entrada de arquivo de texto passo e a
outra Adicionar um checksum degrau. Sua transformação deve parecer com o seguinte:
247
Entendendo e otimizando fluxos de dados
7. Abra o Adicionar um checksum passo para o Entrada Tabela degrau. Preencha o passo da seguinte forma:
9. Adicionar Classificar linhas passo para ambos os fluxos, a triagem nos campos de checksum.
10. Mesclar as duas correntes usando um Merge Join (diff) passo, comparando no
db_checksum e a file_checksum Campos.
11. Adicionar uma Filtrar linhas degrau. Para os critérios de filtragem, certifique-se de que o bandeira valor do campo
é igual a Novo.
12. A pré-visualização da Filtrar linhas passo mostra os registros que foram alterados desde o
dados foram carregados na base de dados. Você deverá ver dados semelhantes ao seguinte:
Como funciona...
Checksums são essencialmente hashes do conjunto de dados. Ele fornece uma maneira muito rápida e eficiente para comparar conjuntos de
f Checksums ignorar valores nulos, por isso não pode produzir um verdadeiro hash de um registro
f Não importa o algoritmo for escolhido, há sempre uma chance de dois registros diferentes
tendo o mesmo hash
248
Capítulo 7
Suponha que você tem duas correntes com a mesma estrutura e quer descobrir as diferenças nos dados. Chaleira tem
um passo destinado especificamente para esse fim: o Mesclar linhas (diff) degrau. Nesta receita, você vai ver como ele
funciona.
Suponha que você tem um arquivo com informações sobre as montanhas-russas mais rápidas de rolos ao redor do mundo. Agora,
você tem um arquivo atualizado e quer descobrir as diferenças entre os arquivos: pode haver novas montanhas-russas na lista;
talvez algumas montanhas-russas não entre os mais rápidos são. Além disso, lhe foi dito que no arquivo de idade, houve alguns
erros sobre a localização, país, e as informações ano, para que você também está interessado em saber se alguns destes
mudaram.
Preparando-se
Para esta receita, você vai precisar de dois arquivos com informações sobre montanhas-russas. Você pode baixá-los
da página do livro.
. . .
Para o Tem mais... seção, você também vai precisar de um banco de dados com o primeiro arquivo já carregado em uma tabela. Você vai
encontrar um script para criar e carregar também disponível para download.
2. Arraste um entrada de arquivo de texto entrar na tela e usá-lo para ler o arquivo
top_roller_coasters.txt. Como separador, tipo |.
3. Fazer uma pré-visualização para se certificar de que você está lendo o arquivo como esperado.
4. Adicionar um Classificar linhas passo para classificar as linhas por montanha russa e parque.
249
Entendendo e otimizando fluxos de dados
6. A partir do Junte-se categoria, adicione um Mesclar linhas (diff) passo, e usá-lo para se juntar ambos os fluxos,
7. Dê um duplo clique sobre o passo que você acabou de adicionar. No linhas de referência origem: selecione o nome
8. No Compare origem linhas: selecione o nome da etapa vindo do riacho que lê o top_roller_coasters_updates.txt
Arquivo.
10. Preencha o Chaves ao jogo: e Valores para comparar: grades, como mostrado na
imagem seguinte:
Agora que a etapa foi preenchida, podemos comparar os fluxos e obter a diferença
entre eles. Você pode economizar tempo clicando no obter chave campos e Obter
250
Capítulo 7
Como funciona...
o Mesclar linhas (diff) etapa é usada para comparar duas correntes e descobrir as diferenças entre eles. A saída do passo é
um único fluxo. O fluxo de saída contém um novo campo que atua como um sinalizador que indica o tipo de diferença
encontrada como explicado a seguir.
Quando você usa o Mesclar linhas (diff) etapa, as duas correntes que você está
fundindo devem ter o mesmo metadados, isto é, o nome, ordem e tipo de campos
deve ser o mesmo.
Vamos chamar os fluxos a serem reunidos corrente de referência e comparar fluxo. O primeiro contém os dados antigos,
enquanto a segunda contém os novos dados. Na receita, os dados antigos são os dados provenientes do top_roller_coasters.txt
arquivo e os novos dados são os dados provenientes do top_roller_coasters_update.txt Arquivo.
Para realizar a comparação, você tem que dizer Chaleira como detectar que uma linha é a mesma em ambos os fluxos, ou
seja, você tem que especificar os campos-chave. Você fazê-lo, inserindo-os no primeiro grid. Na receita, a chave era
composta pelo nome de montanha-russa e o nome do parque ( montanha russa e parque Campos).
Se os dados vem de um banco de dados em vez de usar um Classificar linhas passo para
classificar as linhas, você pode classificá-los na
A introdução da tabela degrau. Isso lhe dará um melhor desempenho.
251
Entendendo e otimizando fluxos de dados
Dadas as duas correntes, Chaleira tenta corresponder linhas de ambos os fluxos com base nos campos de chave fornecidas.
Dependendo do resultado, ele define um valor diferente para a bandeira, como explicado na tabela a seguir:
A tecla apenas foi encontrado na corrente de Novo fórmula Rossa montanha russa.
referência
A chave foi encontrada em ambos os fluxos e os idêntico Força do Milênio montanha russa. o localização
campos digitado no Valor para comparar grade são ( Sandusky, Ohio),
iguais país ( vazia), e ano ( 2000) foram os mesmos
em ambos os fluxos.
A chave foi encontrada em ambos os fluxos, mas pelo mudado furioso Baco montanha russa. O local foi alterado
menos um dos campos digitado no Valor para a partir de Espanha para Salou e do País mudou
comparar grade é diferente de vazio para a Espanha.
Note-se que se uma linha é encontrado em ambos os fluxos com campos de chave idênticos e comparar os campos, ele é marcado como
idênticos, mesmo que haja diferenças nos outros campos. Por exemplo, a Dodonpa
montanha russa tem uma velocidade de 106,8 mph na corrente de referência, mas uma velocidade de 106 mph no fluxo de comparar. Como
você não colocou o Rapidez nos valores à lista de comparação, as linhas são marcadas como idênticos.
Como observação final, note que para as linhas marcadas como Novo ou mudado, e os valores que passam para o fluxo de saída são
aqueles que vêm a partir do fluxo de comparação. Para as linhas marcadas como idêntico ou excluída, os valores que são transmitidos
Tem mais...
o Mesclar linhas (diff) passo é normalmente usado em conjunto com o Sincronizar após fusão passo para manter uma tabela de banco de
dados atualizado. A seção seguinte mostra um exemplo de como fazer isso.
252
Capítulo 7
À medida que novas montanhas-russas são construídos e velhas montanhas-russas são movidas ou aposentados, a tabela
terá de ser atualizado. usando o top_roller_coasters_updates.txt arquivo, podemos usar os dados atualizados e atualizar a tabela
com base nas diferenças.
Tente o seguinte:
, localização
, país
, ano
DE montanhas-russas
ORDER BY roller_coaster
, parque
3. Fazer uma pré-visualização na última etapa, que é a Mesclar linhas (diff) degrau. A saída deve
ser exatamente o mesmo que a saída na receita.
253
Entendendo e otimizando fluxos de dados
4. Agora, adicione um Sincronizar após fusão degrau. Selecione a conexão com o banco de dados ou
criá-lo se ele não existe e como tabela de destino, tipo montanhas-russas. Encha as grades, como mostrado na
imagem seguinte:
7. Execute um SELECIONAR declaração para ver os dados no montanha russa mesa. o rolo
bases para copos com a bandeira excluída deveriam ter sido excluídos da tabela. As linhas com a bandeira Novo
deveria ter sido inserido na tabela, e as linhas com a bandeira
mudado deveria ter sido atualizado.
Veja também
254
Capítulo 7
Esta é uma receita rápida que ensina como fazer um produto cartesiano entre conjuntos de dados. Um produto cartesiano é criado
tomando todas as linhas de um conjunto de dados, todas as linhas de um outro conjunto de dados, e gerando um novo conjunto de
dados com todas as possíveis combinações de linhas. Esta receita particular é, de fato, a implementação do Comunidade sigla
Generator
( CAG) como proposto por Nicholas Goodman (@ nagoodman) no Twitter:
Já existem vários projetos comunitários ao redor Pentaho como CDF (Comunidade Dashboard Framework), CDE (Comunidade
Editor do Dashboard), ou CDA (Comunidade de acesso a dados). Por que não vamos seguir a sugestão de Nicholas e
desenvolver o CAG como segue ?: Dado duas listas de palavras, a transformação Chaleira irá gerar todas as combinações de
1. Criar uma nova transformação e adicionar dois Grade de dados passos da Entrada categoria.
2. Use um dos Grade de dados passos para criar um conjunto de dados com uma única Corda campo chamado
middle_word. Debaixo de Dados guia, digite um conjunto de nomes para a palavra meio da sigla. Aqui, você
tem uma lista de exemplos: Painel, dados, Gráfico, sigla, Cubo,
e Relatório.
3. Use o outro Grade de dados passo para criar um conjunto de dados com uma única Corda campo chamado
última palavra. Debaixo de Dados guia, digite um conjunto de nomes para a última palavra da sigla. Aqui,
você tem uma lista de exemplos: Framework, Editor, Tradutor, Access, Gerador, Integrator, Component.
5. Criar lúpulo do Grade de dados passos em direção a esta etapa. Você vai ter algo parecido
Os seguintes:
255
Entendendo e otimizando fluxos de dados
7. Use o UDJE para adicionar dois Corda Campos. Nomear o primeiro new_component e como Java
Expressão tipo " CommunityCommunity "+ middle_word +" "+ last_word.
Nome do segundo campo acrônimo e como Expressão Java tipo " C "+ middle_word. Subsequência (0,1) +
last_word.substring (0,1). Fazer uma previsão sobre esta última etapa. Você verá uma lista de projetos
comunitários candidatos, como mostrado na imagem seguinte:
Como funciona...
o Junte-se a linhas (produto cartesiano) passo tem a tarefa de executar o produto cartesiano de todos os fluxos próximos a ele.
Neste caso, você tinha duas correntes, mas você poderia ter tido mais. O passo recebeu essas duas correntes e criou todas as
combinações de linhas. Então, com o UDJE, você simplesmente construir as cordas com o nome dos projetos comunitários
candidato e suas siglas, como por exemplo, Gráfico Quadro Comunitário (CCF). Enquanto nós tivemos um pouco de diversão
gerar nomes diferentes para projetos comunitários, é até você para adotar um nome gerado e construir o projeto por trás dele!
Tem mais...
Na receita, você usou o Junte-se a linhas (produto cartesiano) passo para unir dois conjuntos de dados. Você poderia
juntar-se mais conjuntos de dados se você quiser; no entanto, que não é um requisito comum. Há um par de ajustes no passo
que você não usar na receita. Eles são explicados nas subseções a seguir.
256
Capítulo 7
Como o fluxo que sai do obter variável etapa tem uma única linha, o produto cartesiano terá todas as possíveis
combinações de N linhas da corrente principal com uma única linha, ou seja,
N linhas. Neste caso, é importante que no passo principal para ler opção, você selecionar a corrente principal, o fluxo vindo do
UDJE. Fazendo isso, você dizer Kettle que a maioria dos dados virão de esta etapa e Kettle irá armazenar em cache ou a
bobina para o disco os dados provenientes do obter variável degrau.
Voltar para a receita. Como você deve ter notado, é possível para a transformação para gerar siglas que já existem,
por exemplo, CDF. Na subseção anterior, você adicionou um segundo
Junte-se a linhas (produto cartesiano) degrau. Nesta etapa, você pode adicionar uma condição para descartar as linhas com
siglas que já existem, exceto quando o produto é Enterprise Edition. A área condição na janela configuração do passo seria
parecido com o mostrado na imagem seguinte (exceto para a lista exata de siglas, que poderia ter mudado pelo tempo que
você está lendo este):
257
Entendendo e otimizando fluxos de dados
Se você fizer uma pré-visualização on Nesta etapa, você verá algo como o seguinte:
Se você der uma olhada na Métricas passo guia do resultados da execução janela, você vai notar que o número de linhas
escritas é menor do que o produto cartesiano de linhas de entrada. Note que a GUI para inserir a condição é a mesma
que a do Filtrar linhas degrau.
Veja também
258
Capítulo 7
Chaleira fornece a merge Join passo para se juntar dados provenientes de qualquer tipo de fonte. Vamos supor que você está
construindo uma casa e quer controlar e gerenciar os custos de construção. Antes de começar, você preparou um arquivo do Excel
com os custos estimados para as diferentes partes de sua casa. Agora, você é dado um arquivo semanal com o progresso e os custos
reais. Então, você quer comparar os dois para ver o progresso.
Preparando-se
Para executar esta receita, você vai precisar de dois arquivos do Excel, um para o orçamento e outra com os custos
reais. o BUDGET.XLS tem a data prevista de partida, data final estimado, e os custos para as tarefas planejadas. o costs.xls tem
a verdadeira data de partida, data final, eo custo para tarefas que já começaram.
3. Use um passo para a leitura da informação orçamental ( BUDGET.XLS arquivo) e outro para
ler as informações custos ( costs.xls Arquivo).
4. Sob o Campos guia destes passos, clique no Obter campos de linha de cabeçalho ... botão
a fim de preencher a grade automaticamente. Aplicar o formato dd / MM / aaaa para os campos de tipo Encontro e US
$ 0.00 para os campos com os custos.
5. Adicione uma merge Join passo do Junte-se categoria e criar um hop de cada sobressair
entrada passo para este passo. O diagrama a seguir mostra o que você tem até agora:
259
Entendendo e otimizando fluxos de dados
7. Se você fizer uma pré-visualização on Nesta etapa, você irá obter o resultado dos dois arquivos do Excel mescladas. Para
ter as colunas mais organizados, adicionar um Selecione os valores passo do Transformar categoria. Nesta nova etapa,
selecione os campos na seguinte ordem:
tarefa, data de início (est.), data, a data de final (est.), data final, o custo de partida (est.), e custo.
8. Fazer uma pré-visualização na última etapa, você irá obter os dados mesclados com as colunas de ambos os arquivos do Excel
intercaladas, como mostrado na imagem seguinte:
Como funciona...
No exemplo, você viu como usar o merge Join passo para se juntar dados provenientes de dois arquivos do Excel. Você pode usar esta
etapa para se juntar a qualquer outro tipo de entrada. No merge Join etapa, você definirá o nome das etapas de entrada e os campos para
usar como as chaves para se juntar a eles. Na receita, você se juntou aos fluxos por apenas um único campo: o tarefa campo.
260
Capítulo 7
Tem mais...
No exemplo, você definir o Junte-Tipo para LEFT OUTER JOIN. Vamos ver explicações sobre as possíveis opções de inscrição:
RIGHT OUTER O resultado contém todas as linhas Você obterá todos os custos das tarefas reais e suas
a partir da segunda fonte, e os valores informações relacionadas a partir do orçamento. Se
correspondentes para a primeira fonte (ou há um custo para uma tarefa que não tinha sido
valores de vazios para chaves não estimado, o custo estimado estará vazia.
relacionados)
FULL OUTER O resultado contém todas as linhas de ambas Você obterá todas as tarefas a partir do
as fontes (com valores vazios para chaves não orçamento e os custos reais. Este foi o caso
correspondentes) na receita.
Veja também
por exemplo:
f Em um conjunto de dados com itens vendidos, cada linha tem dados sobre um item.
f Em um conjunto de dados com a temperatura média durante um intervalo de dias em cinco regiões diferentes,
cada linha tem a temperatura média para um dia diferente em uma das referidas regiões.
f Em um conjunto de dados com uma lista de pessoas ordenados por faixa etária (0-10, 11-20, 20-40, e assim
261
Entendendo e otimizando fluxos de dados
Às vezes, há uma necessidade de intercalando novas linhas entre as linhas atuais. Tomando os exemplos anteriores,
imagine as seguintes situações:
f No itens dataset vendidos, a cada 10 itens, você tem que inserir uma linha com o funcionamento
quantidade de itens e funcionando preço vendido a partir da primeira linha até a linha.
f No conjunto de dados da temperatura, você tem que pedir os dados por região e a última linha para
cada região tem de ter a temperatura média para essa região.
f No conjunto de dados das pessoas, para cada faixa etária, você tem que inserir uma linha de cabeçalho apenas
Em geral, as linhas que você precisa para intercalar pode ter dados fixo, subtotais dos números em linhas anteriores, cabeçalho para
as linhas por vir, e assim por diante. O que eles têm em comum é que eles têm uma estrutura diferente, ou seja, em comparação com
as linhas em seu conjunto de dados. Intercalando essas linhas não é uma tarefa complicada, mas é um assunto delicado. Nesta
Suponha que você tem que criar uma lista de produtos por categoria. Para cada categoria, você tem que inserir uma
linha de cabeçalho com a descrição da categoria e do número de produtos dentro dessa categoria.
Preparando-se
Esta receita utiliza uma base de dados externa com a estrutura mostrada na Apêndice A, Estruturas de Dados. Como a fonte, você pode usar
um banco de dados como esta ou qualquer outra fonte, por exemplo, um arquivo de texto com a mesma estrutura.
262
Capítulo 7
Selecione a Categoria
, desc_product FROM
produtos p
, Categorias c
ONDE p.id_category = ORDEM c.id_category por categoria
3. Agora, você tem que criar e intercalar as linhas de cabeçalho. A fim de criar os cabeçalhos, faça o seguinte: a
partir do Estatisticas categoria, adicione um grupo de passo e preencher as grelhas, como mostrado na
imagem seguinte:
4. A partir do Scripting categoria, adicione um User Defined Expressão Java passo, e uso
-lo para adicionar dois campos: o primeiro será um Corda nomeado desc_product, com valor
( "Categoria:" + categoria) .toUpperCase (). A segunda será uma número inteiro
campo chamado ordem com valor 1.
5. Use um Selecione os valores passo para reordenar os campos como categoria, desc_product, qty_
produtos, e ordem. Fazer uma previsão sobre esta etapa; você deve ver o seguinte resultado:
263
Entendendo e otimizando fluxos de dados
6. Aqueles são os cabeçalhos. O próximo passo é a mistura de todas as linhas na ordem correta. arraste um Adicionar constantes e
um passo Classificar linhas passo para a tela. Ligá-los a outros passos, como mostrado:
7. Use o Adicionar constantes para adicionar dois número inteiro Campos: qty_prod e ordem. Como Valor,
deixar o primeiro campo vazio, e digite 2 para o segundo campo.
9. Selecione o último passo e fazer uma pré-visualização. Você deve ver as linhas exatamente como mostrado na introdução.
Como funciona...
Quando você tem que intercalam as linhas entre as linhas existentes, existem apenas quatro principais tarefas para fazer, como segue:
1. Criar um fluxo secundário que será utilizado para a criação de novas linhas. Neste caso, as linhas com os
cabeçalhos das categorias.
2. Em cada fluxo, adicione um campo que irá ajudá-lo a espalhar linhas na ordem correta. Neste caso, o campo de
chave foi nomeado ordem.
3. Antes de se juntar as duas correntes, adicionar, remover e reordenar os campos em cada fluxo para certificar-se de que os
campos de saída em cada fluxo tem os mesmos metadados.
4. Junte-se aos fluxos e ordenar pelos campos que considerem adequadas, incluindo o campo criado anteriormente.
Neste caso, você classificado por categoria, dentro de cada categoria pelo campo chamado ordem e, finalmente, pela
descrição produtos. Note-se que, neste caso, você criou um único fluxo secundário. Você poderia criar mais, se
necessário, por exemplo, se você precisa de um cabeçalho e rodapé para cada categoria.
Veja também
264
Capítulo 7
Como você deve saber, uma transformação Kettle é um grupo de passos ligados através do qual fluxos de dados. Cada passo é
destinado para receber linhas de dados, processar os dados de alguma forma, e entregar as linhas para a próxima etapa ou etapas. Se
não houver linhas que vêm para a etapa, a etapa não será executada. Isso parece razoável, mas em ocasiões, pode ser um problema.
Para se ter uma idéia de que tipo de situação, olhar para os seguintes cenários:
f Você tem uma transformação muito simples que lê um arquivo, faz alguns cálculos, e
finalmente atualiza uma tabela com a data do sistema e o número de linhas processadas. Se o arquivo não existe ou se
ela estiver vazia, então nenhuma linha vai sair da etapa de entrada de arquivo. Consequentemente, e ao contrário do que
você precisa fazer, o passo que atualiza a tabela nunca será executado.
f Você tem um arquivo que tem os valores de algumas variáveis que são necessários para um processo.
Enquanto o arquivo existe e tem as variáveis corretas na mesma, o processo será executado. Se o processo precisa
ser executado mesmo sem o arquivo, recomenda-se que as variáveis têm valores padrão definidos no processo.
f Você tem um banco de dados com produtos e quer gerar uma lista de produtos cuja
descrições correspondem a um determinado texto. Por exemplo, se o texto for luminária, seu arquivo terá todos os produtos
que contêm luminária em suas descrições. Se não houver lâmpadas, que pretende gerar um arquivo com uma única linha a
gravação da situação. O problema é que se não há lâmpadas, nenhuma linha sairá da etapa de entrada.
Consequentemente, a etapa de saída, como no primeiro exemplo, nunca será executado.
Para situações como essas, há uma maneira de superar o problema: o uso do Detectar fluxo vazia degrau. Esta
receita mostra como usá-lo. Ele implementa o último dos exemplos: a geração do arquivo com uma lista de produtos.
Preparando-se
Para esta receita, você vai precisar de um banco de dados com produtos ao ar livre com a estrutura definida na
Apêndice A, Estruturas de dados.
265
Entendendo e otimizando fluxos de dados
SELECIONAR
categoria
, id_product
, desc_product
, Preço FROM
produtos p
, Categorias c
ONDE p.id_category = c.id_category E desc_product like '% $
{PROD_FILTER}%' ORDER por categoria, desc_product
4. Adicionar um saída de Excel degrau. Configurar o passo para gerar um arquivo com todos os campos que vem
de Entrada Tabela degrau. De Fluxo categoria, adicione um Detectar fluxo vazia degrau. Além disso, adicionar um User Defined
Expressão Java ou UDJE passo, e ligar todas as etapas da seguinte forma:
1. Pressione o F9 chave para executá-lo; dar o PROD_FILTER o valor variável luminária ( ou qualquer
valor que você sabe que é parte da descrição de alguns dos seus produtos). Você pode fazer isso digitando o valor
na grade nomeada Variáveis. Clique em Lançamento.
266
Capítulo 7
3. Execute a transformação de novo, mas desta vez, digite um valor que você sabe que não faz parte das descrições
de seus produtos, por exemplo motocicleta.
4. Abra o arquivo. Desta vez, ele deve ter o conteúdo conforme mostrado na imagem a seguir:
Como funciona...
Quando um passo não retornar dados, o fluxo termina. Nenhum dos passos que se seguem essa etapa são executados
porque eles não receber dados para processamento. o Detectar fluxo vazia passo, como o nome sugere, detecta essa situação.
Como consequência, ele gera um fluxo com a mesma de metadados como o fluxo esperado, e uma fileira única com valores
nulos. Desta forma, você evita o fluxo de morrer.
A fim de entender o que o passo faz de uma maneira melhor, tente o seguinte:
2. Pressione o F9 chave para fazer uma pré-visualização, dar à variável PROD_FILTER O valor que luminária,
e clique em Lançamento.
3. Você verá uma mensagem informando que não há linhas para visualização. Isso porque o fluxo
principal teve filas e foram em direção ao passo Excel.
4. Tente o mesmo procedimento novamente, mas desta vez, digite um valor inválido, por exemplo,
motocicleta. Você vai ver uma única linha com as colunas categoria, id_product, desc_product, e preço, todos com
valores nulos. Na receita, no passo que se segue o Detectar fluxo vazia etapa, você substituiu o valor nulo no categoria
coluna com a mensagem que você queria escrever no arquivo, e enviou os dados para o arquivo de Excel. o saída de
Excel etapa não se importa se os dados vieram do fluxo principal ou a única alternativa que você criou para o fluxo de
vazio. Ele simplesmente envia as colunas para o arquivo Excel.
267
Entendendo e otimizando fluxos de dados
Finalmente, vale a pena mencionar porque usamos o UDJE degrau. A seleção desta etapa é inteligente, porque ele substitui o valor do categoria
campo. A maioria das etapas adicionar novos campos, mas não são capazes de manipular os já existentes.
Tem mais...
Você pode usar o Detectar fluxo vazia passo da mesma maneira você poderia implementar o tratamento de
erros. A diferença é que aqui não há erros; você simplesmente tem uma situação excepcional.
Como você faria ao lidar com erros, você pode corrigir ou manipular o fluxo e enviá-lo de volta para a corrente principal,
como você fez na receita, ou você pode ignorar completamente os metadados gerados pelo Detectar fluxo vazia passo e
simplesmente usar esse passo como o início de um novo fluxo independente. Por exemplo, em vez de gerar o arquivo Excel
quando não há linhas, você pode escrever uma mensagem para o log, como O critério não coincide com nenhum produto.
Vamos supor que você tem uma livraria e quer saber as cinco principais livros bestseller, os seguintes 10 best-sellers, eo
resto dos livros para propósitos diferentes (por exemplo, para fazer uma promoção de marketing diferenciada para cada
grupo). Para fazer isso, você vai dividir a lista de livros em diferentes grupos de acordo com suas vendas.
Preparando-se
Você precisa de um arquivo de planilha Excel contendo uma lista de livros com as seguintes colunas:
f título
f id_author
f preço
f id_title
f gênero
f vendas
Esta última coluna representa a quantidade de livros vendidos no último período. Você pode baixar um arquivo de exemplo
no site do livro.
268
Capítulo 7
1. Criar uma nova transformação e arraste um Entrada Excel passo do Entrada categoria.
4. Adicionar um Classificar linhas passo do Transformar categoria. Completar a grade passo com o
Fieldname vendas. Tipo N no Crescente coluna.
6. Ao visualizar esta etapa, você obterá uma lista de livros classificados por suas vendas. Adicionar dois
Filtrar linhas degraus e três Manequim passos (todos do Fluxo categoria) e criar os saltos, tal como representado
no diagrama a seguir:
269
Entendendo e otimizando fluxos de dados
12. Você pode fazer uma pré-visualização de cada uma delas Manequim passos e verificar os resultados.
Como funciona...
Esta receita lê o sales_books.xls Arquivo para criar um conjunto de dados dos títulos de livros, juntamente com suas informações de
vendas. o Classificar linhas etapa é necessária para encomendar os livros pelas vendas começando com o melhor vendedor. Então,
você deixou cair uma Adicionar seqüência passo a enumerar as linhas. Neste caso, o campo que você adicionou representa o valor
ranking. O livro mais vendido terá o número um. Neste momento, você tem a lista de livros classificados por suas vendas. Agora, você
só tem que filtrar os livros baseados em suas fileiras. Você faz isso usando a Filtrar linhas degrau. O primeiro Filtrar linhas
passo utiliza o estado classificação <= 5 para obter as cinco principais livros best-sellers. O restante dos livros será filtrada
novamente, agora com a condição classificação <= 15; isso vai trazer as linhas classificados de 6 para 15. Os livros restantes,
aqueles com um grau maior do que 15, vai para a última Manequim degrau.
Tem mais...
Na receita, você enumerou as linhas e, em seguida, você fez coisas diferentes com base no número da linha.
Existem também alguns casos de uso específicos, que são explicados nas subseções a seguir.
270
Capítulo 7
f as linhas 1 para 5
fA fila 9
f as linhas 15 para 20
O resto das linhas serão descartadas. Para o exemplo anterior, você deve apenas digitar 15..20.
Nesta etapa, você só precisa digitar um valor para o resultado fieldname caixa de texto. Quando você executar a
transformação, este novo campo vai voltar Y para a última linha e N de outra forma. No exemplo, você pode saber qual o livro
menos vendido foi filtrando a linha onde o campo é igual a Y.
Isto também se aplica quando você precisa para classificar as linhas como na receita, e os dados de entrada já está ordenada.
Veja também
271
Entendendo e otimizando fluxos de dados
processamento de dados é um dos principais recursos de qualquer Extrair, Transform, e carga (ETL) ferramenta e chaleira não é diferente. Às
vezes, porém, os dados devem ser processadas de forma diferente (geralmente devido a problemas de qualidade de dados ou regras de negócio).
Se essa lógica é necessária em vários lugares, faz sentido para quebrar esse código em sua própria transformação usando um Mapeamento
(sub-transformação).
Preparando-se
Para esta receita, estaremos construindo fora do Dividindo um córrego em dois ou mais fluxos com base em uma condição receita,
apresentado anteriormente neste capítulo. Recomenda-se que siga esta receita e entender como a Switch / case passo funciona
antes de continuar. Alternativamente, o código para esta receita está disponível no site do livro.
2. Criar duas novas transformações. Um será usado para processar o fluxo de dados produtos de cozinha e o outro
será usado para processar fluxo de dados das tendas.
3. A partir do palete, trazer mais de dois Mapeamento (sub-transformação) passos para colocar entre
o produto cozinha e tenda Manequim passos. Sua transformação agora deve ser semelhante ao
seguinte:
272
Capítulo 7
6. Abra o especificação de entrada mapeamento degrau. Adicionar desc_product como uma string ao
grade de dados campos. Certifique-se de verificar o Incluir campos não especificados, ordenados por caixa Nome e clique em ESTÁ
BEM.
8. Repita os passos 4 a 6 em subtransformation das tendas. Em vez de maiúsculas, mude o desc_product campo
para minúsculas.
11. Visualização de saída do produto cozinha Manequim passo e você deve obter uma saída semelhante
ao seguinte:
273
Entendendo e otimizando fluxos de dados
Como funciona...
Veja também
Durante o processamento de dados haverá a necessidade de alterar nomes de campos, seus tipos de dados ou formatos, e campos
mesmo remover completamente. o Selecione os valores passo permite a todas as três funções e esta receita irá mostrar como usá-lo. O
código para esta receita está disponível no site do livro.
1. Criar uma nova transformação. Adicionar um gerar linhas e um passo gerar aleatório
valor passo para a tela.
3. Abra o gerar linhas degrau. Criar um campo chamado row_test do tipo Corda e
com um valor padrão de teste. Clique em Está bem para fechar a passo.
4. Abra a Gerar valor aleatório degrau. Criar dois campos, um uma seqüência aleatória
(nomeado random_num) eo outro uma seqüência aleatória (chamado random_string).
Clique em Está bem para fechar a passo.
5. Leve ao longo de três Selecione os valores passos para a tela. Criar lúpulo do Gerar
valor aleatório passo a cada um dos Selecione os valores passos. Quando solicitado para especificar como lidar com o
fluxo de dados, selecione Cópia de.
6. Abra um dos Selecione os valores passos e renomeá-lo para Alterar. No Selecione & Alter
guia, clique em Obter campos para selecionar para trazer os campos do fluxo na etapa.
274
Capítulo 7
7. Para a linha com o campo random_num, mudar o nome para número aleatório por
preenchimento do renomear para coluna. Clique em Está bem para fechar a passo.
8. Abra o outro de Selecione os valores passos e renomeá-lo para Remover. Mudar para o
Remover guia e selecione o campo row_test. Clique em Está bem para fechar a passo.
9. Abrir a final Selecione os valores passo e renomeá-lo Metadados. Mudar para o Meta-dados
guia e alterar a random_num campo para digitar Integer. Clique em Está bem para fechar a passo.
10. Agora, pré-visualizar cada um dos três Selecione os valores passos para ver como cada função altera
o fluxo.
Como funciona...
o Selecione os valores passo é projetado com três tipos de funções: Selecionar e alterar, remover, e
Meta-dados. Todos os três lidam com fazer mudanças significativas para o fluxo de dados durante o processamento de dados. o Selecione &
Alter guia fornece renomeação básico e alterando comprimento / precisão. o
Remover separador limpa os campos de fluxo de dados. finalmente, o Meta-dados guia também permite a mudança de nome e
comprimento / precisão alterando mas também irá alterar os tipos de campo e formatação.
Mesmo que a Selecione os valores passo tem três abas, cada uma é independente
dos outros. Se você quiser usar mais de uma das funções, você tem que adicionar
adicional Selecione os valores
passos para seus fluxos.
Esta etapa é especialmente útil se os tipos de dados de campos de origem não coincidem com os campos de destino, o que causará
erros de incompatibilidade de tipo contrário. Se você estiver usando este passo para remover campos, por favor, note que é um
processo intensivo de recursos. Às vezes é melhor deixar apenas os campos no lugar para o desempenho ao invés de limpeza. É típico
para remover campos de um fluxo se eles já não será necessário eo conjunto de dados é grande o suficiente para que a memória pode
ser um problema.
Executar trabalhos ou transformações em série é bem inicialmente, mas como mais processos vêm online, a necessidade de
executar mais em menos tempo se torna muito evidente. Chaleira tem a capacidade de executar múltiplas tarefas e
transformações, ao mesmo tempo, e nesta receita, estaremos indo sobre como utilizar esta funcionalidade para ambos os
trabalhos e transformações. O código para esta receita está disponível no site do livro.
275
Entendendo e otimizando fluxos de dados
2. Adicione uma Começar passo para a tela. Além disso, adicionar três Transformação passos.
4. Clique com o botão direito do mouse sobre o primeiro Transformação passo e selecione o Lançar no próximo entradas
paralelo opção. Duas linhas paralelas agora deve aparecer ao longo dos saltos entre o primeiro
Transformação passo e os outros dois.
276
Capítulo 7
1. Abra uma nova transformação e trazer ao longo de um gerar linhas passo, bem como um
Adicionar seqüência degrau.
3. Adicione dois Manequim (não fazer nada) passos para a tela. Criar um hop do Adicionar
seqüência passo a um dos Manequim (não fazer nada) passos. Repetir o processo para a outra Manequim (não fazer
nada) degrau. Uma janela aparece perguntando como o fluxo de dados deve ser tratada. selecionar Cópia de.
4. Execute a transformação. Observe que os dois Manequim (não fazer nada) passos estão recebendo
o mesmo número de registros.
5. Dê um clique direito sobre o Adicionar seqüência passo e selecione Movimento de dados | distribuir dados
para os próximos passos.
6. Execute a transformação. Observe que os dois Manequim (não fazer nada) passos agora só
receber metade o número de registros que eles originalmente estavam recebendo.
Como funciona...
Processos em execução em paralelo permite o uso mais eficiente dos recursos de computação e de tempo. funcionalidade built-in
da chaleira permite empregos e transformações para tirar vantagem de executar múltiplos processos simultaneamente. Há
algumas ressalvas para abordar se tentar ajustar seus processos sejam executados em paralelo:
f Streams correndo em paralelo não pode modificar os mesmos objetos (isto é, tabelas de banco de dados)
sem correr para potenciais impasses.
f Processos atento para maior memória, CPUs, e assim por diante, irá realizar mais lento do que se
executá-los separadamente. Certifique-se de ajustar os processos para a nova execução paralela.
f Transformações que executam múltiplos fluxos paralelos que estão se unindo novamente juntos
exigem o mesmo layout. Os campos que estão fora de ordem ou removidos vai causar problemas ao mesclar
os fluxos de volta juntos.
f Para transformações, fluxos que são distribuídos em vez de copiados será aleatoriamente
divisão, sem nenhuma garantia que registra acabar em um determinado fluxo. Também é importante notar que os
processos em execução em paralelo geralmente utilizam mais memória e CPU. Além disso, os processos só pode ser ajustado até ao
montante máximo permitido pelo hardware que está sendo executado. Se você estiver usando um processador de 4 núcleos e
277
Entendendo e otimizando fluxos de dados
Veja também
278
8
Execução e
Re-usando Jobs e
Transformações
f Executar parte de um trabalho uma vez para cada linha no conjunto de dados
f Executar parte de um trabalho várias vezes até que uma condição é verdadeira
Introdução
A transformação por si só raramente cumpre todos os requisitos de um problema do mundo real. É comum para
enfrentar algumas das seguintes situações:
f Você precisa decidir em tempo de execução que trabalho para ser executado a partir de um grupo de empregos
f Você tem que voltar a usar parte de uma transformação em um cenário diferente Kettle é versátil o suficiente para atender
a essas situações. No entanto, é fácil ficar confuso tentando fazer alguns deles sem orientação.
Este capítulo contém receitas rápidas só queria te ensinar o básico. As transformações e postos de trabalho utilizados são simples o
suficiente para servir como modelos para você modificar para suas próprias necessidades. Antes de iniciar as receitas, vamos dar
transformações amostra
As receitas neste capítulo mostram-lhe diferentes formas de executar transformações chaleira e empregos. A fim de se
concentrar em efeitos específicos das receitas, em vez de transformações em desenvolvimento, criamos algumas
transformações amostras que serão utilizados durante todo o capítulo.
As transformações são descritos nas subsecções seguintes. Você pode baixá-los no site do livro.
Lembre-se que você tem várias maneiras de variáveis que definem: como um parâmetro nomeado no
arquivo de propriedades Chaleira, em um trabalho anterior, ou uma transformação (se essa
transformação vai ser chamado a partir de um trabalho), ou na variáveis seção do Executar uma
transformação window (janela que aparece quando você executar a transformação de Colher).
280
Capítulo 8
- 982437245
1169516784
318652071
- 576481306
1815968887
281
Execução e Re-usando Jobs e Transformações
atual em que a transformação está localizado. A transformação parecida com a retratada na imagem seguinte:
gen_random.ktr
gen_sequence.ktr
get_file_names.ktr hello.ktr
282
Capítulo 8
Como foi mencionado no Introdução seção, as receitas deste capítulo estão focados em diferentes formas de executar transformações
chaleira e empregos. Em última análise, você vai acabar com um trabalho principal. A fim de testar o seu trabalho com diferentes entradas
ou parâmetros, você pode usar Colher como de costume, mas pode ser útil ou mesmo mais simples de usar Cozinha -a linha de comando
programa destina-se a lançar trabalhos chaleira. Se você não estiver familiarizado com cozinha, esta receita dá-lhe uma visão geral rápida.
1. Abra uma janela do terminal, navegando para iniciar | Todos os programas | Acessórios |
Prompt de comando ( Windows) ou indo para o desktop Aplicação menu e digitação Terminal ( ambiente
Gnome para Linux).
Se você deseja fornecer parâmetros de linha de comando, basta digitar-los em ordem, como parte do comando. Se você
deseja fornecer um parâmetro nomeado, use a seguinte sintaxe:
Além disso, você pode especificar o nível de log adicionando a seguinte opção:
O nível de log pode ser um dos seguintes procedimentos: Erro, Nada, Minimal, Basic ( este é o nível padrão), Detalhado,
Debug, ou Rowlevel.
Se você pretende executar uma transformação em vez de um trabalho, o uso Pan. Basta substituir kitchen.bat / kitchen.sh com
pan.bat / pan.sh, e fornecer o nome do próprio. ktr Arquivo. Enquanto você usa Colher para o desenvolvimento, depuração e
testar transformações e empregos, Cozinha e Pan são mais comumente usados para a execução de trabalhos e
transformações em ambientes de produção. Para uma lista completa de opções disponíveis e mais informações sobre
estes comandos, visite a documentação Pan em http://wiki.pentaho.com/display/EAI/ Pan + Usuário + Documentação.
283
Execução e Re-usando Jobs e Transformações
Como funciona...
Chaleira tem várias ferramentas internas de executar tarefas e transformações em um ambiente de servidor. Servidores
normalmente não têm interfaces gráficas de usuário e são conectados através de túneis de outros computadores. Cozinha e Pan
são construídos para executar a partir da linha de comando por essa mesma razão. Existem outras ferramentas que fazem parte
do conjunto de Kettle. carte é um servidor leve que se conecta a um servidor Chaleira mestre para construir clusters de servidores
dinâmicos que podem lidar com distribuição de empregos e transformações. Para saber mais sobre Carte, veja o wiki comunidade
Pentaho em http://wiki.pentaho.com/display/EAI/Carte+User+Documentation. Outra ferramenta útil é ENCR, que criptografa banco
de dados e senhas carte. Seu uso é descrito na documentação do usuário Carte.
Ambos Carte (carte.bat / carte.sh) e ENCR (encr.bat / encr.sh) pode ser encontrado no diretório de instalação Chaleira.
f Segundo arquivo: números de 0 para 100, incrementando por 20, como em 0, 20, 40, ..., 100
f Terceiro arquivo: números de 100 para 500, incrementando por 100, como em 100, 200, .., 500
Você tem uma transformação que gera seqüências como essas. Você apenas tem que chamá-lo três vezes com os
argumentos e parâmetros adequados.
Preparando-se
É necessário o transformação amostra que gera um ficheiro com uma sequência descrita na introdução.
Certifique-se de ter definido a variável $ { PASTA DE SAÍDA} com o nome da pasta de destino. Além
disso, certifique-se que existe a pasta.
284
Capítulo 8
1. Criar um emprego.
2. Arraste um Começar entrada de trabalho e três Transformação trabalho entradas para a tela. Fazer a ligação tudo
12. Selecione a Argumento aba e preencher a grade com 100 na primeira linha e 500
no segundo.
13. Selecione o parâmetros aba. Na primeira linha da grelha, tipo INCREMENTO debaixo
Parâmetro e 100 debaixo Valor.
15. Verifique a pasta de saída. Você vai encontrar os seguintes três arquivos:
?? sequence_1_10_1.txt
?? sequence_0_100_20.txt
?? sequence_50_500_50.txt
16. Editar os arquivos. Você vai ver que eles contêm as sequências de números 0, 1, ..., 10
no primeiro arquivo, 0, 20, 40, ..., 100 na segunda, e 100, 200, .., 500 no terceiro, apenas como esperado.
285
Execução e Re-usando Jobs e Transformações
Como funciona...
Quando você executa uma transformação de um trabalho, você tem que especificar, pelo menos, o nome ea localização da
transformação. Há, no entanto, um par de definições adicionais que podem ser úteis. Nesta receita, você viu o uso do Argumento e a parâmetros
abas. o Argumento aba é usada para o envio de argumentos de linha de comando para a transformação. A grade na Argumento separador
é equivalente ao argumentos grade que você vê quando você executar uma transformação de Spoon. Cada linha pertence a um
argumento de linha de comando diferente.
Neste caso, sua transformação espera dois argumentos de linha de comando: os limites de e
para da sequência. Na receita, você define valores para esses argumentos na Argumento guia de cada Transformação entrada
janela de configuração. o parâmetros aba é usada para definir valores para os parâmetros nomeados definidos na
transformação. A grade sob a parâmetros separador é equivalente ao parâmetros grade que você vê quando você executar
uma transformação de Spoon. Cada linha pertence a uma diferente parâmetro nomeado. Você só tem que fornecer valores
se eles são diferentes para os valores padrão. Neste caso, sua transformação definido um parâmetro chamado INCREMENTO com
um valor padrão de 1. Portanto, você pulou a definição deste parâmetro no primeiro Transformação
Tem mais...
Tudo o que foi dito para a entrada de trabalho Transformação também é válido para entradas de trabalho. Ou seja, você pode usar o Argumento e parâmetros
separadores de um Trabalho entrada para enviar valores fixos de argumentos de linha de comando ou parâmetros nomeados para o trabalho.
Veja também
286
Capítulo 8
Para esta receita, suponha que você deseja criar um arquivo com uma sequência de números. Você tem uma
transformação que faz isso. O problema é que os limites DE e PARA e a INCREMENTO
valor são armazenados em um Propriedades Arquivo. Isto representa um obstáculo para chamar a transformação diretamente, mas pode ser feito
com chaleira de uma forma muito simples.
Preparando-se
É necessário um transformação amostra que gera um ficheiro com uma sequência como descrita na introdução.
Certifique-se de ter definido a variável $ { PASTA DE SAÍDA} com o nome da pasta de destino. Além disso, certifique-se que
existe a pasta. Você também precisa de um arquivo chamado sequence.properties com o seguinte conteúdo:
a partir de = 0 a = 90 =
30 incremento
Com estes valores a sua transformação deve gerar os valores 0, 30, 60, 90.
2. A partir do Entrada categoria, arraste um Input propriedade passo para a tela, e usá-lo para
Leia o Propriedades Arquivo. Debaixo de Arquivo guia, digite o nome ea localização do arquivo. Debaixo de Campos guia, clique
em obter Campos para preencher a grade com os campos Chave e Valor.
287
Execução e Re-usando Jobs e Transformações
4. Clique duas vezes no degrau. Para campo de chave, selecionar Chave. Encha o campos de destino: grade, como
5. Após esse passo, adicionar um linhas de cópia para resultar degrau. Você vai encontrá-lo sob o Trabalho categoria.
6. Faça uma pré-visualização na última etapa. Você deverá ver a seguinte tela:
8. arrastar um Começar entrada de trabalho e dois Transformação trabalho entradas para a tela. vincular o
entradas, um após o outro.
12. Selecione a avançado guia e verificar as três primeiras opções: Copiar os resultados anteriores para
args ?, Copiar os resultados anteriores aos parâmetros ?, e Executar para cada linha de entrada ?.
13. Selecione o parâmetros aba. Pela primeira linha na grade, tipo INCREMENTO debaixo
Parâmetro e increment_value debaixo nome da coluna Stream.
16. Como resultado, você terá um novo arquivo chamado sequence_0_90_30.txt. O arquivo será
conter a sequência de números 0, 30, 60, 90, apenas como esperado.
288
Capítulo 8
Como funciona...
A transformação que você correu na receita espera dois argumentos: DE e PARA. Ele também tem um parâmetro chamado
chamado INCREMENTO. Há um par de maneiras de passar esses valores para a transformação:
armazenados em outros meios de comunicação, por exemplo, uma mesa, uma folha de Excel, ou um Propriedades arquivo, você pode facilmente
lê-los e passar os valores para a transformação. Primeiro, você chamar uma transformação que cria um conjunto de dados com uma única linha
com todos os valores necessários. Então você passar os valores para a transformação através da configuração do avançado
Na receita, você criou uma transformação que gera uma única linha com os três valores necessários: from_value, dar
valor, e increment_value. Ao adicionar um linhas de cópia para resultar
etapa, essa linha tornou-se disponível para uso posterior. No trabalho principal, você fez o truque: verificando o Copiar os resultados
anteriores para args? e Executar para cada linha de entrada? opções, você tomar essa linha e passá-lo para a transformação como se
os campos foram argumentos de linha de comando. Ou seja, os valores dos campos from_value, to_value, e
increment_value -nomeadamente 0, 90, e 30 -são visto pela transformação como se fossem os argumentos de linha de comando 1, 2, e 3
respectivamente. Note-se que, neste caso, a transformação somente leitura dois desses argumentos, o terceiro foi ignorado. No
que diz respeito ao parâmetro nomeado, INCREMENTO, você passou para a transformação através da verificação da Copiar os
parâmetros grade de guia. Aqui você entrou no mapa entre o parâmetro nomeado INCREMENTO
e o campo de fluxo de entrada increment_value.
Tem mais...
Tudo o que foi dito para a entrada de trabalho Transformação também é válido para entradas de trabalho. Ou seja, você pode definir o avançado
separador numa Trabalho entrada para copiar os resultados anteriores como argumentos ou como parâmetros para o trabalho que vai ser
executado.
Veja também
f Executar parte de um trabalho uma vez para cada linha em um conjunto de dados
289
Execução e Re-usando Jobs e Transformações
Suponha que você tem um par de transformações, mas você não deseja executar todos eles. A transformação a ser executado
vai depender das condições conhecidos apenas no tempo de execução. Se você tem apenas duas transformações, você poderia
chamar explicitamente um ou o outro de uma forma simples. Por outro lado, se você tem várias transformações ou se você nem
sequer sabe os nomes das transformações disponíveis, você deve tomar uma outra abordagem. Esta receita mostra-lhe como.
Suponha que você deseja executar uma das três transformações de exemplo descritos na introdução. A transformação para
executar será diferente dependendo da hora do dia:
f De 20:00 PM à meia-noite, você vai chamar a transformação que lista os arquivos Veja como fazê-lo.
Preparando-se
Você vai precisar as transformações descritas na introdução. Certifique-se de ter definido a variável $ { PASTA DE
SAÍDA com o nome da pasta de destino. Além disso, certifique-se que existe a pasta.
Além disso, definir uma variável chamada $ { COMMON_DIR} com o caminho para a pasta onde você tem as transformações de
amostra, por exemplo, c: / my_kettle_work / comum.
1. Crie uma transformação que vai pegar a transformação para ser executado.
2. arrastar e largar um Obter Informações do Sistema passo e usá-lo para criar um campo chamado agora com
a data do sistema.
3. arrastar e largar um Selecionar Valores passo e usá-lo para obter a hora atual. Selecione os
meta aba; adicione o campo chamado agora, para Tipo selecionar Corda, e para Formato, tipo HH.
Mudar o nome do campo como hora.
4. Arraste outra Selecionar Valores passo e usá-lo para alterar o valor do campo hora
para Integer.
5. Após a última etapa, adicionar um intervalo de números degrau. Você vai encontrá-lo na
Transformação categoria.
290
Capítulo 8
6. Dê um clique duplo na etapa. Como Campo de entrada: selecione o campo hora e como campo de saída:
tipo ktr_name. Preencher a grade, como mostrado na imagem seguinte:
7. A partir da Trabalho categoria, adicione um definir variáveis passo e usá-lo para criar uma variável
nomeado KTR_NAME com o valor do campo ktr_name. Para Tipo âmbito variável,
deixe o padrão Válido no trabalho raiz.
8. Guardar a transformação e fazer uma pré-visualização na última etapa. Assumindo que é 03:00
PM, você deve ver algo como o seguinte:
10. Arraste um Começar entrada de trabalho e dois Transformação trabalho entradas para a tela. vincular o
itens um após o outro.
11. Configurar o primeiro Transformação entrada para executar a transformação acabou de criar.
14. Supondo que é 3:00 PM, o registro deverá ser parecido com o seguinte:
. . .
. . . - executar a transformação - Carregando transformação a partir do arquivo XML [C:
/my_kettle_work/common/gen_random.ktr]
. . .
2010/12/04 15:00:02 - Spoon - Job terminou.
291
Execução e Re-usando Jobs e Transformações
Como funciona...
Quando você executa uma transformação de um trabalho, você pode digitar o nome exato da transformação, ou usar
uma combinação de texto e variáveis em vez.
Nesta receita, você implementou a segunda opção. Como você não sabia qual das três transformações que você teve que correr,
você criou uma transformação que definir uma variável com o nome próprio. Em seguida, no trabalho, em vez de digitar o nome da
transformação, você usou essa variável em combinação com uma variável que representa o caminho para o. ktr Arquivo. Quando
você executou o trabalho, a primeira transformação definir o nome da transformação para executar, dependendo do tempo atual.
Finalmente, que a transformação foi executado.
Tem mais...
Na receita, você tinha certeza de que não importa o que o valor da variável $ { KTR_NAME} foi, a transformação existiria. Se você não tem
certeza, é recomendável que você inserir um existe arquivo entrada antes da segunda Transformação entrada. Esta etapa verifica se um
determinado arquivo existe, o que é uma ótima maneira de garantir que um arquivo está no lugar antes de executar um processo que
depende dele. Desta forma, você evita o seu trabalho deixar de funcionar.
Se, em vez de arquivos que você está trabalhando com um repositório, você também pode verificar a existência da transformação. Em
vez de verificar a existência de um arquivo, você tem que executar um SELECIONAR
declaração sobre o banco de dados repositório para ver se a transformação existe ou não. Se a sua transformação está no diretório
raiz do repositório, isto é bastante simples, mas pode tornar-se um pouco mais complicado se a sua transformação é profunda na
árvore de diretórios transformações. Finalmente, tudo dito até agora sobre transformações é válido para empregos também. A fim de
executar um trabalho, você pode digitar seu nome exato ou usar uma combinação de texto e variáveis, assim como você fez na receita
Veja também
292
Capítulo 8
Suponha que você tem uma lista de coisas ou entidades, como estudantes, arquivos, datas, produtos e assim por diante. Agora, suponha que
você deseja executar um grupo de entradas de trabalho uma vez para cada entidade nessa lista.
Suponha que você tem um arquivo com uma lista de nomes, por exemplo:
nomear Paul
Santiago
Lourdes Anna
f Espere 2 segundos
Para uma única pessoa, essas tarefas pode ser feito com um par de entradas. Se você tem uma pequena lista conhecida de
entidades (pessoas neste exemplo), você pode copiar e colar esse grupo de entradas, uma para cada. Por outro lado, se a
lista é longa, ou você não sabe os valores de antecedência, não há outra maneira de conseguir isso. Esta receita mostra-lhe
como.
Preparando-se
Para esta receita, vamos usar o Olá transformação descrito na introdução. A pasta de destino para o arquivo que é
Você também vai precisar de um arquivo de amostra, tais como o descrito. Tanto o arquivo de amostra ea transformação estão
disponíveis para download.
Esta receita é dividida em três partes. A primeira parte é o desenvolvimento de uma transformação que gera a lista de pessoas.
Para construir o primeiro componente, execute os seguintes passos:
1. Crie uma transformação. Esta transformação vai ler a lista de pessoas e enviar as linhas fora da
transformação para posterior processamento.
293
Execução e Re-usando Jobs e Transformações
3. Depois de ler o arquivo, adicione um linhas de cópia para resultar degrau. Você vai encontrá-lo sob o
Trabalho categoria.
4. Faça uma prévia sobre este passo. Você deverá ver a seguinte tela:
5. Salve a transformação.
Agora, você vai criar um trabalho que irá gerar um arquivo para cada pessoa na lista; então deliberadamente esperar por 2 segundos e
escrever uma mensagem para o log.
1. Criar um emprego. Adicione ao trabalho de um COMEÇAR, uma Transformação, uma Esperar por ( de
condições categoria), e um Gravar no log ( de utilidade categoria) entrada. Ligá-los um após o outro na
mesma ordem.
3. Dê um duplo clique sobre o Esperar por entrada e definir o tempo limite máximo para 2 segundos.
4. Dê um duplo clique sobre o Gravar no log entrada. Para Log assunto, tipo Em formação e para
Mensagem de log, tipo Um novo arquivo foi gerado.
6. Guarde o trabalho.
1. Crie um outro trabalho. Adicione ao trabalho de um COMEÇAR, uma Transformação, e uma Trabalho entrada.
Criar um hop do COMEÇAR ao Transformação entrada, e outro hop a partir desta entrada para o Trabalho entrada.
2. Use a primeira entrada para executar a transformação que lê o arquivo e copia as linhas de resultado.
3. Clique duas vezes na segunda entrada. Como filename Job, selecione o trabalho que gera um arquivo
para uma única pessoa, ou seja, o emprego criado anteriormente.
294
Capítulo 8
4. Selecione o avançado guia e verifique o Executar para cada linha de entrada? e cópia de
resultados anteriores para args? opções.
6. Execute o trabalho. Debaixo de métricas de emprego guia no resultados da execução janela, você vai
notar que o saying_hello_to_a_single_person transformação está disparando para cada nome.
7. Se você explorar o diretório de saída, você encontrará um arquivo para cada pessoa na lista. As datas dos
arquivos serão diferentes por 2 segundos um do outro.
Como funciona...
Você precisa executar um par de entradas para cada pessoa na lista. A primeira coisa que fiz foi criar um trabalho (vamos
chamá-lo o trabalho sub partir de agora), encapsulando as funcionalidades que você queria para cada pessoa; gerar o arquivo,
aguarde 2 segundos, e escrever uma mensagem para o log. A fim de iterar a execução do trabalho sub sobre a lista de
f Você criou uma transformação que construiu a lista de pessoas e copiado as linhas
resultar.
f Você criou um trabalho principal que chama essa transformação e, em seguida, executou o sub
emprego, uma vez para cada pessoa na lista. Você fez isso clicando no Executar para cada linha de entrada? opção no Trabalho
entrada. No Métricas de trabalho guia no resultados da execução
painel, você pode vê-lo; a execução da transformação, em primeiro lugar, seguido por quatro execuções do trabalho
sub. Quatro é o número de pessoas no nosso exemplo lista. finalmente, o Copiar os resultados anteriores para args? opção
que você verificou na Trabalho entrada causou as linhas copiadas para se tornar disponível (um de cada vez) para o sub
emprego e, em particular, à
Olá transformação no interior do trabalho sub sob a forma de linha de comando argumentos.
Tem mais...
Quando você tem um conjunto de entradas que você deseja executar uma vez para cada elemento em uma lista, você pode fazê-lo com as
três etapas seguintes:
1. Crie uma transformação que cria a lista que você precisa. A corrente deve terminar com um linhas de cópia para resultar degrau.
2. Crie um trabalho com o conjunto de entradas que você precisa executar para cada elemento da lista.
3. Criar um trabalho que primeiro chama a transformação e, em seguida, chama o trabalho criado acima. No Trabalho janela de
configurações de entrada, verifique a Executar para cada linha de entrada? opção.
295
Execução e Re-usando Jobs e Transformações
o linhas de cópia para resultar etapa faz com que as linhas da transformação a ser copiado para o lado de fora. o Executar para cada
linha de entrada? opção faz com que o trabalho sub a ser executado tantas vezes quanto o número de linhas copiadas, a menos que
ocorra um erro.
Se ocorrer um erro durante a execução do trabalho sub, a iteração é abortada eo trabalho principal falhar.
Se você quiser a iteração para continuar mesmo se o trabalho sub falhar por uma única linha,
modificar o trabalho sub por lidar com os erros adequadamente, a fim de evitá-lo falhar.
No que diz respeito às linhas copiadas, elas estarão disponíveis um de cada vez para o trabalho sub. A primeira execução do sub
trabalho vai ver a primeira linha copiado; a segunda execução vai ver a segunda linha, e assim por diante. Na receita, você acessou as
linhas copiadas, verificando a Copiar os resultados anteriores para args? opção, o que fez as linhas disponíveis como argumentos de
linha de comando para o sub emprego. Há outras opções disponíveis para acessar as linhas copiadas em entradas de trabalho
posteriores, como você verá na subsecção seguinte.
Depois disso, você vai ver determinados casos de uso para a execução de entradas para cada elemento em uma lista.
Quando você copia linhas usando o linhas de cópia para resultar passo, as linhas copiadas se tornar disponível para ser usado pelas
entradas que são executados depois.
Existem quatro métodos para acessar os campos da linha copiada em entradas posteriores:
Copiá-los para os argumentos verificar o Copiar os resultados anteriores Transformação, Job, copiar arquivos, mover
de uma entrada para args? opção arquivos, apagar arquivos, apagar pastas,
tabelas,
296
Capítulo 8
Na receita, você usou a primeira destas opções: você verificou o Copiar os resultados anteriores para args? opção e que
causou as linhas para se tornar disponível como os argumentos de linha de comando para o Olá transformação.
Neste exemplo particular, você também poderia ter usado o último método. No Olá
transformação, em vez de ler o nome como o parâmetro de linha de comando 1, você poderia ter usado um Obter linhas de resultado passo
a obtenção dos mesmos resultados. Como está implícito na tabela anterior, você não tem que verificar o Copiar os resultados
anteriores para args? opção neste caso.
Execução de uma transformação, uma vez para cada linha em um conjunto de dados
Se, em vez de um conjunto de entradas você só quer executar uma única transformação uma vez para cada linha em um conjunto de dados,
você não tem que movê-lo para um trabalho sub. Basta deixar a entrada de Transformação no trabalho principal. Dê um duplo clique sobre a
entrada, selecione o avançado guia, e verificar a Executar para cada linha de entrada? opção. Isso fará com que a transformação para ser
executado uma vez para cada linha vindo de um resultado anterior.
Execução de uma transformação ou parte de um trabalho uma vez para cada arquivo em uma lista de arquivos
Se você deseja executar parte de um trabalho (como um trabalho sub) ou uma transformação, uma vez para cada arquivo em uma lista
de arquivos, o procedimento é o mesmo. Na transformação que cria a lista, use um
Obter nomes de arquivos passo do Entrada categoria, a fim de criar a lista de arquivos. Depois de modificar o conjunto de dados com a lista de
arquivos, conforme necessário, adicione um linhas de cópia para resultar passo exatamente como você fez na receita. A lista de arquivos serão
enviados para fora para posterior processamento. Alguns usuários novatos são tentados a usar o Definir arquivos em resultado passo em seu lugar.
Não utilize o Definir arquivos em resultado passo para copiar a resultar uma linha com uma lista de
arquivos. o Definir arquivos em resultado passo tem uma finalidade completamente diferente em
comparação com o linhas de cópia para resultar passo adiciona arquivos para um filelist resultado. Verifique
o seguinte Veja também seção para obter mais informações sobre isso.
297
Execução e Re-usando Jobs e Transformações
Veja também
f Executar parte de um trabalho várias vezes até que uma condição é verdadeira
fo Copiar ou mover uma lista personalizada de arquivos receita em Capítulo 5, gestão de ficheiros
fo Envio de e-mails com arquivos anexados receita em Capítulo 10, Obtendo o máximo
de Kettle
Suponha que você tem uma lista de tarefas que têm de ser repetido quando ou até que uma condição é verdadeira (ou falsa). Se você sabe
sobre linguagens de programação, pense nisso como uma analogia de um enquanto
ou repetir até ciclo. Chaleira permite implementar esses tipos de iterações e esta receita explica como
fazê-lo.
Para a receita, você vai usar uma das transformações descritas na introdução deste capítulo, a transformação que
gera números aleatórios e escreve-los em um arquivo. Você vai executar a transformação repetidamente e manter
o controle do número de linhas escritas a esses arquivos. Você vai continuar a executar a transformação, desde
que o número total de linhas escritas é inferior a 25.
Preparando-se
Você terá a transformação que gera números aleatórios descritos na introdução. Se, em vez de baixar a
transformação que você criou-lo sozinho, você terá que fazer uma correção rápida, a fim de fazer Chaleira
salvar o número de linhas escritas no log (isso já foi feito na transformação disponíveis no site do livro):
1. Editar a transformação.
298
Capítulo 8
4. No Campos para login: grade, procure a entrada chamada LINES_OUTPUT. Debaixo nome passo, selecione o
nome da etapa que gera o arquivo de números aleatórios. O resultado é mostrado na imagem seguinte:
5. Salve a transformação.
1. Criar um emprego.
3. Dê um duplo clique sobre o variáveis definidas entrada. Adicionar uma linha, a fim de definir a variável
que vai manter o controle do número de linhas escritas. Debaixo Nome variável, tipo
total_lines, para Valor tipo 0, e para Tipo âmbito variável selecionar Válido no trabalho atual.
299
Execução e Re-usando Jobs e Transformações
8. Dê um duplo clique sobre o JavaScript entrada. No JavaScript: área, digite o seguinte código:
9. Dê um duplo clique sobre o Gravar no log entrada que é executado após o sucesso do
JavaScript entrada (a entrada na extremidade do lúpulo verde). Para Nível de log, selecionar
O registro mínimo. Para Log assunto, tipo linhas de escrita = $ {total_lines}.
Para mensagem de log tipo Pronto para correr novamente.
10. Dê um clique duplo no outro Gravar no log entrada, o que é executado após o fracasso
do JavaScript entrada (a entrada na extremidade do salto vermelho). Para Nível de log, selecionar
O registro mínimo. Para assunto log Tipo $ { total_lines} linhas foram escritas. Para Mensagem de log, tipo
A geração de números aleatórios foi bem sucedido.
12. Pressione F9 para executar o trabalho. Para Nível de log, selecionar O registro mínimo e clique em Lançamento.
13. No Exploração madeireira guia do resultados da execução painel, você verá o seguinte:
2011/01/11 22:43:50 - Spoon - trabalho Começando ... 2011/01/11 22:43:50 - principal - Início da execução do
trabalho 2011/01/11 22:43:50 - linhas de escrita = 10 - Pronto para correr novamente ... 2011/01/11 22:43:50 -
linhas de escrita = 20 - Pronto para correr novamente ... 2011/01/11 22:43:51 - 30 linhas foram escritas. - A
geração de números aleatórios tem sido bem sucedida. 2011/01/11 22:43:51 - principal - a execução do trabalho
terminado 2011/01/11 22:43:51 - Spoon - Job terminou.
14. A fim de confirmar que 30 linhas foram realmente escritas, abra os arquivos gerados.
300
Capítulo 8
Como funciona...
Para executar a transformação que gera um arquivo com números aleatórios até que o número de linhas escritas é
maior do que 25, você implementou um loop. O fluxograma a seguir mostra a lógica deste processo:
total_lines = 0
aleatório
transformação
Executar a
total_lines = total_lines +
number_of_written_lines
Escrever mensagem
SIM
de status para total_lines <25
registro
NÃO
conectar
Para controlar a execução da transformação, que criou uma variável chamada total_lines e inicializada esta variável com o valor 0.
Depois de executar a transformação, você incrementado o valor da variável usando o código JavaScript. Se o valor foi inferior a 25,
você escreveu uma mensagem para o log e reran a transformação. Se não, você escreveu uma mensagem final para o registro.
previous_result.getNrLinesOutput () é a função que devolve o número de linhas que foram escritos pela entrada de
trabalho anterior. Esse é o valor que você tem que adicionar à
total_lines variável, a fim de manter a variável atualizado. As funções parent_job.getVariable () e parent_job.setVariable
são destinadas a obter e definir o valor da variável Kettle chamada total_lines. Por padrão, o tipo das variáveis
Chaleira é Corda. Portanto, a fim de fazer a matemática, você tinha que usar o
301
Execução e Re-usando Jobs e Transformações
A quarta linha no código JavaScript avalia a Verdade ou Falso. Se for avaliado como Verdade, a
JavaScript entrada segue o caminho de sucesso (identificado com uma seta verde na transformação). Se for avaliado como Falso, a
JavaScript entrada segue o caminho falha (identificado com uma seta vermelha na transformação).
Tem mais...
Nesta receita, você construiu um loop e controlado a execução com a ajuda de um JavaScript entrada. As subseções a
seguir dar-lhe mais informações sobre esses tópicos.
fO trabalho está levando mais tempo do que o esperado, talvez devido a um serviço indisponível
fO número de registros inseridos em uma tabela excedeu o valor esperado e assim por diante Depois de entender
isso, você tem que implementar a lógica. Na receita, você implementou a lógica com um JavaScript entrada de trabalho.
Há outras entradas que você pode usar para decidir se sair de um loop ou não. Você vai encontrar entradas úteis para
Se o seu ciclo está causando problemas-por exemplo, você ficar sem memória de tentar repensar a solução. A seguir estão
algumas alternativas que você pode pensar:
f Resolver o mesmo problema com a criação de uma lista de elementos e interagindo sobre essa lista
f Na lógica que determina se deve sair do loop ou não, adicionar uma condição para
assegurando que o número de iterações permanece abaixo n
302
Capítulo 8
Usando o passo JavaScript para controlar a execução das entradas em seu trabalho
o JavaScript entrada é um passo útil para controlar se uma entrada de trabalho ou um grupo de entradas de trabalho deve ser
executado ou não. Em particular, você usou na receita para decidir se o loop deve terminar ou não.
Esta entrada funciona da seguinte maneira: em sua janela configuração, você deve digitar o código JavaScript que termina com uma expressão
que resulta em um Boleano. Como acontece com qualquer entrada de trabalho, a JavaScript
entrada de sucesso ou falha. Sucesso ou fracasso é decidido pelo resultado da avaliação dessa expressão. Então,
com base nesse valor, Chaleira sabe que a entrada para executar seguinte. Dentro do código, você é livre para usar o previous_result
elemento. o resultado previous_ elemento é a representação do objeto de resultado objeto -um que contém o resultado da
execução da entrada de trabalho anterior. Na receita, você usou o previous_result
elemento para pedir o número de linhas escritas, mas você pode pedir o número de linhas de leitura, o número de
erros, o número de entradas de trabalho executadas, e assim por diante. Você pode encontrar uma descrição completa
do disponível previous_result opções de http://wiki.pentaho.com/ display / EAI / Avaliação + condições + em + A + JavaScript +
trabalho + entrada.
Veja também
f Executar parte de um trabalho uma vez para cada linha em um conjunto de dados
Suponha que você tem um conjunto de dados com uma lista de entidades como pessoas, endereços, produtos ou nomes de arquivos, só para
dar alguns exemplos. Você precisa de tomar os dados e realizar algum processamento adicional, tais como a limpeza dos dados, descartando
as linhas inúteis, ou calcular alguns campos extras. Finalmente, você tem que inserir os dados em um banco de dados e construir uma folha de
Excel que contém estatísticas sobre a informação apenas processado. Tudo isso pode ser visto como um fluxo de tarefas simples ou um fluxo
de processo. Com Chaleira, você pode facilmente implementar um fluxo de processo como este. Suponha que você tem um arquivo com uma
303
Execução e Re-usando Jobs e Transformações
O arquivo pode ter algumas duplicatas (linhas consecutivas idênticas) e algumas datas de nascimento podem estar ausentes. Você deseja manter
apenas as linhas únicas e descartar as entradas de pessoas cuja data de nascimento está faltando. Finalmente, você quer gerar um arquivo com a
lista de pessoas que você mantidos, juntamente com a sua idade ordenadas por data de nascimento.
Preparando-se
Você vai precisar de um arquivo de amostra, como o mostrado anteriormente nesta receita.
Você vai implementar o fluxo de tarefas com duas transformações. O primeiro irá ler os dados e limpe-o de acordo
com os requisitos anteriores eo segundo irá calcular a idade e gerar o arquivo. Então, execute os seguintes
passos:
2. Com um entrada de arquivo de texto, ler o arquivo de amostra. Faça uma pré-visualização para se certificar de que você está
lê-lo corretamente.
3. Após essa etapa, adicionar um Filtrar linhas degrau ( Fluxo categoria) e entrar no estado
data de nascimento não é nulo.
5. Finalmente, adicione uma linhas de cópia para resultar degrau. Você vai encontrá-lo na Trabalho categoria. seu último
6. Faça uma pré-visualização na última etapa; você deve ver o seguinte resultado:
304
Capítulo 8
8. A partir da Trabalho categoria, adicione um Obter linhas de resultado degrau. Abra o Obter linhas de resultado passo e adicionar
dois campos: um campo chamado nome (String) e um campo chamado data de nascimento (Date). Os passos seguintes são destinadas a
calcular a idade de uma pessoa nos dias de hoje, dada a data de nascimento:
2. A partir do Scripting categoria, adicione um User Defined Expressão Java degrau ( UDJE para
baixo). Dê um duplo clique sobre ele e preencher a grade, como mostrado na imagem a seguir:
3. Adicione um quarto campo chamado calculated_age. Para Tipo de valor, selecionar Integer. Para Java
expressão digite o seguinte:
((B_month> t_month) ||
(B_month == t_month && b_day> t_day))? (T_year - b_year - 1) :(
t_year - b_year)
4. Esta expressão é escrita ao longo de três linhas para maior clareza. Você deve digitar a expressão inteira em uma única linha.
De Transformar categoria, adicione um Classificar linhas degrau. Use-o para classificar as linhas por data de nascimento.
305
Execução e Re-usando Jobs e Transformações
5. Finalmente, adicione uma saída de arquivo de texto passo e usá-lo para gerar o arquivo desejado. Providencie um
nome para o arquivo. Para Separador, deixe o padrão (;). Preencha o Campos grelha, como mostrado na imagem
seguinte:
6. Salve a transformação.
2. Configure as entradas para executar as transformações que você acabou de criar na mesma ordem. Primeiro a
transformação que obtém a lista de pessoas e limpa os dados, em seguida, a transformação que calcula a
idade e gera o arquivo.
4. Olhe para o arquivo de saída. Assumindo que hoje é 18 de janeiro de 2011, o arquivo deve se parecer com
o seguinte:
Como funciona...
Você necessário para realizar uma tarefa definida pelos dois sub-tarefas seguintes:
Você implementou a tarefa como um fluxo de processo de mini composta por duas transformações, um para cada sub-tarefa, e
então você incorporado as transformações em um trabalho que eles executados um após o outro. O fluxo de dados entre a
primeira e a segunda transformação foi determinada usando o cópia / get mecanismo de linhas. Com um linhas de cópia para
resultar etapa, você enviou o fluxo de dados fora a primeira transformação, e com um Obter linhas de resultado passo na
segunda transformação, você pegou esses dados para continuar o fluxo do processo.
306
Capítulo 8
Na receita, você fez uma pré-visualização na linhas de cópia para resultar passo e você foram capazes de ver os dados finais que seriam
enviados para fora a transformação. Normalmente não é possível visualizar a segunda transformação como é. o Obter linhas de resultado passo
é apenas uma definição dos dados que serão fornecidos; que não tem dados para visualização.
Enquanto você está projetando uma transformação começando com um Obter linhas de resultado etapa,
você pode provisoriamente substituir esse passo com um passo que fornece alguns dados fictícios,
por exemplo, um entrada de arquivo de texto, uma Gerar linhas, uma Obter informações do sistema, ou
um
Estes dados fictício tem que ter os mesmos metadados como definido no Obter linhas de resultado
degrau. Isto irá permitir que você visualizar e testar sua transformação antes de usá-lo como parte de seu fluxo de processo.
Note-se que as tarefas executadas nesta receita poderia facilmente ser feito em
uma única transformação. Nós dividi-lo em dois apenas para fins de
demonstração.
A próxima seção explica em detalhes quando e por que você deve considerar dividir um processo em várias
transformações.
Tem mais...
Não há limite para o número de transformações que podem ser encadeadas usando este mecanismo. Você pode ter uma
transformação que copia as linhas, seguido por outro que recebe as linhas e cópias novamente, seguido por uma terceira
transformação que recebe as linhas, e assim por diante. Na maioria dos casos, é possível colocá-los todos em uma única
transformação. Apesar disso, ainda existem algumas razões para dividir as tarefas para cima e criando um fluxo de processo. Veja
alguns exemplos:
307
Execução e Re-usando Jobs e Transformações
A cópia das linhas é feita na memória. Enquanto isto é útil quando você tem pequenos conjuntos de dados, para os maiores
você deve escolher uma das seguintes alternativas:
Para alterar o método de cópia / linhas para serializar / de-serialize, execute os seguintes passos:
1. Na primeira transformação, substitua o linhas de cópia para resultar passo com um Serializar para arquivo passo do Saída
categoria.
2. Dê um clique duplo na etapa e fornecer um nome para o arquivo no Nome do arquivo caixa de texto.
5. Executar a primeira transformação; um arquivo com o nome dado deveria ter sido gerado.
6. Faça uma pré-visualização na De-serialize de arquivo degrau; você vai ver os dados copiados
a partir da primeira transformação.
Se você executar o trabalho, você deve obter os mesmos resultados que você obteve usando a receita principal. Para grandes conjuntos
de dados este método é recomendado em relação à anterior. Este método também é prático para conjuntos de dados que têm muitas
colunas ou se o número ou ordem das colunas muda ao longo do tempo. Como os metadados são salvas no arquivo juntamente com os
dados, você não são obrigados a especificar os detalhes na segunda transformação.
Observe que o arquivo gerado com um Serializar para arquivo etapa tem um formato binário e
não pode ser lido com um editor de texto.
308
Capítulo 8
O método de banco de dados também é o método preferido no caso em que você está
lidando com grandes conjuntos de dados. Encenar grandes quantidades de dados em disco
deve ser evitado, se possível.
E se você notar que houve um erro na medida em que parte da transformação? Ou talvez você gostaria de otimizar
alguma coisa lá? Você precisaria fazer isso em três lugares diferentes! Este inconveniente é uma das razões pelas
quais você gostaria de mover os passos a um lugar comum-a subtransformation.
Nesta receita, você irá desenvolver uma subtransformation que recebe as duas datas seguintes:
fA data de nascimento
O subtransformation irá calcular a idade de uma pessoa foi (ou será) na data de referência, se a data de nascimento
fornecida era deles.
309
Execução e Re-usando Jobs e Transformações
Preparando-se
Você vai precisar de um arquivo contendo uma lista de nomes e datas de nascimento, por exemplo:
Esta receita é dividida em duas partes. Primeiro, você irá criar o subtransformation realizando os seguintes passos:
3. Além disso, adicionar um Junte-se a linhas (produto cartesiano) (Junte categoria), uma Calculadora (Transform
categoria), e um User Defined Expressão Java ou UDJE abreviado ( Scripting categoria) passo. A ligação das etapas
como mostrado na imagem seguinte:
4. Dê um duplo clique em um dos especificação de entrada mapeamento passos. Adicionar um campo chamado
nomeado reference_field. Para Tipo, selecionar Encontro. Nomeie o passo data de referencia.
6. Clique duas vezes no Junte-se degrau. Para passo principal para ler, selecionar datas de nascimento.
310
Capítulo 8
Observe que essas etapas são uma versão ligeiramente modificada dos passos
utilizados para calcular a idade na receita anterior.
1. Dê um duplo clique sobre o Calculadora passo e preencha a janela de configurações, como mostrado na
imagem seguinte:
2. Dê um duplo clique sobre o UDJE degrau. Adicionar um campo chamado calculated_age. Como Tipo de valor,
selecionar Integer. Para expressão Java tipo:
((B_month> t_month) ||
(B_month - t_month == 0 && b_day> t_day))? (T_year - b_year - 1) :(
t_year - b_year)
A expressão é escrito ao longo de três linhas para maior clareza. Você deve
digitar a expressão inteira em uma única linha.
3. Salve a transformação.
Agora você irá criar a transformação principal. Ele irá ler o arquivo de amostra e calcular a idade das pessoas no arquivo
como nos dias de hoje.
2. Use um entrada de arquivo de texto passo para ler o arquivo de amostra. Nomeie o passo pessoas.
3. Use um Obter Informações do Sistema passo para obter os dias de hoje e adicione um campo denominado hoje.
311
Execução e Re-usando Jobs e Transformações
5. Dê um duplo clique sobre o Mapeamento degrau. A seguir estão os passos mais importantes
nesta receita!
6. Na primeira caixa de texto, sob o texto Use um arquivo para a transformação de mapeamento,
selecione a transformação criou anteriormente.
7. Clique no Adicionar Input botão. Um novo Entrada guia irá ser adicionado à janela. Debaixo
Nessa guia, você vai definir uma correspondência entre o passo entrante pessoas e o passo
subtransformation datas de nascimento.
8. No nome da etapa fonte de entrada, tipo pessoas, o nome do passo que lê o arquivo.
11. De acordo com a mesma guia, preencher a grade do seguinte modo: sob Fieldname do passo fonte
tipo data de nascimento, o nome do campo que sai do pessoas passo que contém a data de nascimento. Debaixo FIELDNAME
a etapa de entrada de mapeamento, tipo birth_field nome -a do campo na etapa subtransformation birthdates que
conterá a data de nascimento necessária para o cálculo da idade.
12. Adicione outra Entrada aba. Sob este guia, você vai definir uma correspondência entre o
passo entrante hoje e o passo subtransformation data de referencia. Preencha a guia da seguinte forma:
312
Capítulo 8
13. Por fim, clique em Adicionar Output para adicionar um Saída aba. Sob essa guia, clique em É este o
caminho de dados principal?
14. De acordo com a mesma guia, preencher a grade do seguinte modo: sob Fieldname de mapeamento
degrau, tipo calculated_age. Debaixo Fieldname para segmentar passo, tipo era. Feche a janela de configurações de
mapeamento e salvar a transformação.
15. Fazer uma pré-visualização na última etapa; você deve ver a seguinte tela:
Como funciona...
O subtransformation (a primeira transformação que você criou) tem a finalidade de calcular a idade de uma pessoa em um
determinado data de referência. A fim de fazer isso, ele define dois pontos de entrada através do uso do especificação de entrada
mapeamento passos. Estes passos destinam-se a especificar os campos necessários pelo subtransformation. Neste caso, você
definiu a data de nascimento em um ponto de entrada e a data de referência no outro. Em seguida, ele calcula a idade da mesma
forma que você faria com qualquer transformação regular. Finalmente, ele define um ponto de saída através do
Note que nós desenvolvemos a subtransformation cegamente, sem ensaios ou visualização. Este foi porque não é possível visualizar
um subtransformation. o especificação de entrada mapeamento passos são apenas uma definição dos dados que serão fornecidos; eles
não têm dados para visualização.
Enquanto você está projetando um subtransformation, pode provisoriamente substituir cada especificação
de entrada mapeamento passo com um passo que fornece alguns dados fictícios, por exemplo, uma entrada
de arquivo de texto, uma
Gerar linhas, uma Obter informações do sistema, ou um Grade de dados degrau.
313
Execução e Re-usando Jobs e Transformações
Estes dados fictício para cada um desses passos tem que ter a mesma metadados como o correspondente especificação de
entrada mapeamento degrau. Isto irá permitir que você visualizar e testar o seu subtransformation antes de chamá-lo de outra
transformação.
Agora, vamos explicar a transformação principal, o que chama a subtransformation. Você adicionou quantas guias de entrada
como pontos de entrada para o subtransformation. As guias de entrada são destinadas a mapear os passos e campos em sua
transformação para as etapas correspondentes e campos na subtransformation. Por exemplo, o campo que você chamada hoje na
sua transformação principal tornou-se reference_field na subtransformation.
Por outro lado, na subtransformation, você definiu apenas um ponto de saída. Portanto, sob a Saída guia, você clicou É este o
principal caminho de dados ?. Selecionando isso significa que você não precisa especificar a correspondência entre as etapas. O
que você fez no âmbito deste guia foi preencher a grade para perguntar o campo calculated_age ser renomeado para era.
Na visualização final, você pode ver todos os campos que você tinha antes da subtransformation, mais os campos adicionados
por ele. Entre estes campos, há a era campo que foi o principal campo que deverá ser adicionado.
Como você pode ver no conjunto de dados final, o campo birthdates manteve o seu nome, enquanto o campo
hoje foi renomeado para reference_field. O campo birthdates manteve o seu nome porque você verificou o Pergunte a
esses valores a ser renomeado de volta na saída? opção no pessoas
guia de entrada. Por outro lado, o campo hoje foi rebatizado porque você não verificar essa opção sob o hoje guia de
entrada.
Tem mais...
Chaleira sub-transformações são uma maneira prática de centralizar algumas funcionalidades de modo que ele pode ser utilizado
em mais de um local. Outro uso de sub-transformações é isolar uma parte de uma transformação que atenda a algum propósito
específico, como um todo, a fim de manter a transformação principal simples, não importa se você vai voltar a usar ou não essa
parte. Vejamos alguns exemplos do que você gostaria de implementar através de um subtransformation:
f Tire algum texto livre representando um endereço, analisá-lo e retornar o nome da rua,
número da rua, cidade, CEP, e estado.
f Tire algum texto, validá-lo de acordo com um conjunto de regras, limpá-lo, por exemplo,
remoção de alguns caracteres indesejados e retornar o texto limpo validado junto com um sinalizador
que indica se o texto original era válido ou não.
f Tome um código de erro e escrever uma linha personalizada para o registo de Kettle.
f Tome a data de nascimento de uma pessoa e uma data de referência e calcular quantos anos que
pessoa era, à data de referência.
314
Capítulo 8
Se você, em seguida, deseja implementar qualquer um dos seguintes aprimoramentos, você precisa fazê-lo em um só lugar:
Do ponto de vista do desenvolvimento, uma subtransformation é apenas uma transformação regular com alguns passos de
entrada e saída ligando-o às transformações que o utilizam. Back in Capítulo 7, Entendimento e Dados Otimizando fluxos, foi
explicado que quando uma transformação é lançado, cada passo inicia um novo segmento, ou seja, todos os passos funcionam
simultaneamente. O fato de que nós estamos usando um subtransformation não muda isso. Quando você executa uma
transformação que chama um subtransformation, ambos os passos na transformação e os do início subtransformation, ao mesmo
tempo, e em paralelo. O subtransformation não é um processo isolado; os dados na transformação principal apenas flui através
do subtransformation. Imaginem este fluxo como se os passos no subtransformation eram parte da transformação principal. Neste
sentido, é interessante notar que uma causa comum de erros no desenvolvimento de subtransformations é o uso errado da Selecione
os valores degrau. Por exemplo, seleccionar alguns valores com um Selecione os valores etapa usando o Selecione & Alter guia em
uma subtransformation vai implicitamente remover não só o resto dos campos na subtransformation, mas também todos os
campos na transformação que o chama.
Se o que você precisa é remover alguns campos, não use o Selecione & Alter aba; use o
Remover guia em seu lugar. Se necessário, use outro Selecione os valores passo para reordenar ou renomear os campos depois.
315
Execução e Re-usando Jobs e Transformações
Preparando-se
Para esta receita, iremos reutilizar a book_news conjunto de dados usados em capítulos anteriores. Você pode encontrar os arquivos usados
para criar este conjunto de dados no site do livro.
Esta receita será utilizando duas transformações. Um irá fornecer os detalhes de metadados de um fluxo de dados, enquanto o
outro terá os metadados e injetá-lo em um processo para a saída dos dados do banco de dados do livro em um arquivo simples.
O primeiro arquivo vamos criar é a transformação que terá metadados injetado para funcionar.
2. Trazer ao longo de um CSV Input Arquivo o passo da palete. Não encha em qualquer um dos detalhes de
o passo que não seja mudar o delimitador para |. Os outros detalhes serão passados em pelo Injeção
de metadados passo da outra transformação.
3. Adicione uma Selecionar Valores passo do pallet e adicionar um hop do Arquivo CSV
Entrada passo para o Selecionar Valores degrau. Tal como acontece com o CSV Input Arquivo passo, não preencher qualquer um dos
detalhes da etapa.
4. Finalmente, adicione uma saída de mesa o passo da palete. Adicionar um salto a partir do selecionar
valores passo para o saída de mesa degrau. Selecione o seguinte para as opções do
saída de mesa degrau:
?? Conexão: livros
316
Capítulo 8
5. Precisamos ter certeza de que o book_stats existe tabela. Execute o seguinte script para
faça isso:
delimitador $$
Agora que estamos prontos para processar dados, vamos em frente e construir a transformação que vai injetar metadados para a
transformação que acabamos de criar.
6. Adicione uma segunda Grade de dados o passo da palete sobre a tela. Esta grade de dados
vai lidar com os nomes de campo e tipos de dados dos dados em nosso book_news.txt Arquivo.
317
Execução e Re-usando Jobs e Transformações
9. Adicionar uma terceira Grade de dados degrau. Isto irá listar os campos que deseja remover do fluxo.
12. Agora, adicione um Injeção ETL Metadados o passo da palete. Adicionar lúpulo dos três
grade de dados passos da Injeção ETL Metadados degrau.
13. Abrir o Injeção ETL Metadados degrau. Selecione a primeira transformação que criamos para
a receita como a entrada para o Use um arquivo para o modelo de transformação campo. Clique em Está bem para fechar a
passo.
14. Abra o Injeção ETL Metadados passo novamente. Os campos que podem interagir com o
Injeção ETL Metadados etapa estão agora preenchido e podemos preencher os detalhes do nosso
Grade de dados passos.
318
Capítulo 8
17. Clique em Está bem para sair do Injeção ETL Metadados degrau. Salvar e executar o
transformação. Ler os dados no book_stats mesa, vemos que a transformação vazio
carregado com êxito os dados do livro:
319
Execução e Re-usando Jobs e Transformações
Como funciona...
o Grade de dados passos desde um lugar estática para armazenar os metadados sobre o arquivo que queríamos para carregar
bem lista como a funcionalidade que queríamos executar nos dados no arquivo. Ao listar o que queríamos fazer com os dados,
fomos capazes de aplicar as várias correntes de diferentes partes de uma transformação genérica, construindo uma versão
personalizada da transformação na mosca.
Tem mais...
Enquanto usamos passos dados da grade para carregar metadados fluxo na etapa Injection ETL Metadados, também poderia ter
utilizado mais um passo da seção Utility da palete chamado a estrutura de metadados de fluxo, que vai ler o fluxo de dados ao vivo e
retornar os metadados para isto. Os metadados podem essencialmente vir de qualquer fonte. Enquanto que é alimentado no passo de
injecção de ETL de metadados, lógica de transformação que tem requisitos dinâmico, mas com uma funcionalidade semelhante pode
re-utilizar a mesma transformação e carregar os metadados adequada para as etapas que o suportam.
Metadados injeção é capaz de interagir com um número crescente de passos. O melhor lugar para ver que
medidas podem ser interagiu com (bem como a versão do Kettle eles foram capacitados) é na página wiki
Pentaho em http://wiki.pentaho.com/display/EAI/ ETL + metadados + Injecção.
320
9
Integrando Chaleira e
Suite Pentaho
Introdução
Chaleira, também conhecido como PDI, é principalmente utilizada como uma aplicação independente. No entanto, não é uma ferramenta
isolado, mas parte da Pentaho Business Suite Intelligence. Como tal, ele também pode interagir com outros componentes do conjunto, por
exemplo, ter Chaleira ato como fonte de dados para um relatório ou um painel, ou mesmo interface com o Pentaho usuário do console, de
modo que os usuários podem executar tarefas Chaleira que limpar seus dados, conforme necessário. Este capítulo mostra como executar
trabalhos chaleira e transformações nesse contexto. Este capítulo assume um conhecimento básico do Pentaho plataforma de Business
Intelligence
e as ferramentas que compõem o Pentaho Suite. Se você não estiver familiarizado com essas ferramentas, é
recomendável que você visitar a página wiki ( wiki.pentaho.com) ou o Pentaho BI Suite Community Edition (CE) local: http://community.pentaho.com/.
Integrando Chaleira e Suite Pentaho
Como outra opção, existe uma referência geral para a suíte chamado Pentaho Solutions (Wiley) por Roland Bouman e
Jos van Dongen que fornece uma boa introdução a todo o conjunto, bem como aos princípios de data warehousing e
business intelligence.
As receitas diferentes neste capítulo mostram como executar transformações e empregos Chaleira, integradas com vários
componentes da suite Pentaho BI. A fim de se concentrar na própria integração, em vez de sobre o desenvolvimento Chaleira,
criamos um arquivo de transformação de exemplo denominado weather.ktr que vai ser utilizado através das diferentes receitas. A
transformação recebe o nome de uma cidade como o primeiro parâmetro na linha de comando, por exemplo Madri e Espanha. Em
seguida, ele consome um serviço web para obter as condições climáticas atuais e a previsão para os próximos cinco dias para
aquela cidade. A transformação tem um par de parâmetros nomeados:
Ele recebe o argumento de linha de comando e os parâmetros nomeados, consome o serviço, e recupera as informações
nas escalas desejadas para temperatura e velocidade do vento.
322
Capítulo 9
Você pode baixar a transformação do site da Packt e testá-lo. Fazer uma previsão sobre o
próximos dias, condições atuais, e current_conditions_normalized passos para ver o que os resultados parecem. O
seguinte é uma prévia amostra do próximos dias degrau:
Para mais detalhes sobre o serviço web e compreender os resultados, você pode dar uma
olhada no Especificando campos usando a notação Path receita em Capítulo 4, Manipulação
de estruturas XML.
Há também um outro arquivo de transformação chamado weather_np.ktr. Essa transformação faz exatamente o mesmo,
mas ele lê a cidade como um parâmetro nomeado em vez de lê-lo a partir da linha de comando. o Preparando-se seções
de cada receita irá dizer-lhe qual destas transformações será usado.
323
Integrando Chaleira e Suite Pentaho
Se você é incapaz de consumir o serviço meteorológico web, pode acontecer que você não quer
consumir o serviço web (por exemplo, por motivos de atraso), ou você não pode fazê-lo (por
exemplo, se você não tiver acesso à Internet) . Além disso, se você chamar um serviço web
gratuito como este, muitas vezes, em seguida, seu IP pode ser banido do serviço. Não se
preocupe. Junto com as transformações da amostra no local de Packt, você vai encontrar uma
outra versão das transformações que, em vez de usar o serviço web, lê dados fictícios amostra
de um arquivo contendo a previsão para mais de 250 cidades. As transformações são tempo
(versão de arquivo) .ktr e weather_np (versão de arquivo) .ktr. Sinta-se livre para usar essas
transformações em seu lugar. Você não deve ter nenhum problema como os parâmetros e os
metadados dos dados recuperados são exatamente o mesmo que nas transformações explicado
anteriormente. Se você usar transformações que não chamar o serviço web, lembre-se que eles
contam com o arquivo com os dados fictícios ( weatheroffline. TXT). Onde quer que você copiar
as transformações de, não se esqueça de copiar esse arquivo também.
o Pentaho relatórios Motor permite projetar, criar e distribuir relatórios em vários formatos populares (HTML, PDF, e assim por
diante) a partir de diferentes tipos de fontes (JDBC, OLAP (On-Line bases de dados de processamento analítico), XML, e assim por
diante).
Há ocasiões em que você precisa outros tipos de fontes, como arquivos de texto ou arquivos do Excel, ou situações em que você
deve processar as informações antes de usá-lo em um relatório. Nesses casos, você pode usar a saída de uma transformação
Chaleira como a fonte de seu relatório. Esta receita mostra esta capacidade do mecanismo de relatórios Pentaho.
Para esta receita, você irá desenvolver um relatório muito simples. O relatório vai pedir uma cidade e uma escala de
temperatura e irá reportar as condições atuais em que cidade. A temperatura será expressa na escala seleccionado.
Preparando-se
Uma compreensão básica da ferramenta Report Designer de Pentaho é necessária, a fim de seguir esta receita. Você deve ser
capaz de criar um relatório, adicionar parâmetros, criar um relatório simples, e visualizar o resultado final.
Em relação ao software, você vai precisar do Pentaho Report Designer. Você pode baixar a versão mais
recente a partir do seguinte URL: http://sourceforge.net/projects/pentaho/ arquivos / Relatório% 20Designer /.
324
Capítulo 9
A transformação de amostra tem um par de UDJE passos. Estes passos dependem da Janino biblioteca. A fim de ser capaz
de executar a transformação do Report Designer, você terá que copiar o
janino.jar arquivo do Kettle libext diretório no Report Designer lib diretório. Se Pentaho Report Designer foi aberto
ao instalar a biblioteca Janino, ele precisará ser fechado e reaberto.
Na primeira parte da receita, você criará o relatório e definir os parâmetros para o relatório: a cidade ea
escala de temperatura.
4. No Dados de menu, selecione Adicionar fonte de dados e depois Integração de Dados Pentaho.
5. Clique no Adicionar uma nova consulta botão. Uma nova consulta nomeada consulta 1 será adicionado.
Dê a consulta um nome próprio, por exemplo, previsão.
325
Integrando Chaleira e Suite Pentaho
8. Clique em pré-visualização; você verá um conjunto de resultados vazio. O importante aqui é que
os cabeçalhos deve ser o mesmo que os campos da saída condições atuais degrau:
cidade, observation_time, weatherDesc, e assim por diante.
11. Feche a Pentaho Data Source Data Integration janela. Você deve ter a
imagem seguinte:
326
Capítulo 9
Os dados provenientes de Kettle está pronto para ser usado em seu relatório.
12. Construir o layout do relatório. Arraste e solte alguns campos na tela e organizá-los como quiser. Fornecer um
título tão bem. A imagem seguinte é um relatório de exemplo que você pode criar:
13. Agora, você seleciona Imprimir Preview. O relatório de exemplo acima será parecido com o mostrado
na imagem seguinte:
327
Integrando Chaleira e Suite Pentaho
Como funciona...
Usando a saída de uma transformação Chaleira como fonte de dados de um relatório é útil porque você pode tirar vantagem de
todas as funcionalidades da ferramenta PDI. Por exemplo, neste caso, você construiu um relatório com base no resultado de
consumir um serviço web. Você não poderia ter feito isso apenas com Pentaho Report Designer.
Para utilizar a saída de sua transformação Chaleira, você acabou de adicionar um Integração Pentaho Dados fonte de
dados. Você selecionou a transformação de correr e o passo que iria entregar seus dados.
Para ser executado, sua transformação precisa de um parâmetro de linha de comando: o nome da cidade. A transformação
também define dois parâmetros nomeados: a escala de temperatura ea escala de vento. A partir da Pentaho Report Designer que
forneceu tanto, um valor para a cidade e um valor para a escala de temperatura. Você fez isso através do preenchimento do Edit
Parameter janela de configurações dentro do Pentaho Data Source Data Integration janela.
Você não forneceu um valor para o RAPIDEZ parâmetro, mas isso não é
necessário porque Chaleira usa o valor padrão.
Como você pode ver na receita, a fonte de dados criado pelo mecanismo de relatório tem a mesma estrutura que os dados
provenientes da etapa selecionada: os mesmos campos com os mesmos nomes, tipos de dados mesmos, e na mesma ordem.
Uma vez que você configurou esta fonte de dados, você era capaz de projetar seu relatório como você teria feito com qualquer outro
tipo de fonte de dados.
Finalmente, quando você está feito e deseja publicar seu relatório no servidor, não se esqueça de corrigir o caminho,
como explicado na receita-o Arquivo menu deve ser especificado com um caminho relativo para a pasta de solução. Por
exemplo, suponha que seu relatório será publicado no my_solution / relatórios, e você colocar o arquivo de transformação my_solution
/ relatórios / recursos. Nesse caso, para Arquivo, você deve digitar Recursos/ mais o nome da transformação.
328
Capítulo 9
Tem mais...
Pentaho Relatórios é um conjunto de projetos Java construídos para a geração de relatórios. A suite é composta do mecanismo de
relatórios Pentaho e um conjunto de ferramentas, tais como o Report Designer (a ferramenta utilizada nesta receita), Relatório Design
Mágico, e hoc interface de usuário do Pentaho baseado na web ad Reporting.
A fim de ser capaz de executar transformações, o software Pentaho Relatórios inclui as bibliotecas chaleira. Para evitar
qualquer inconveniente, não se esqueça que as versões das bibliotecas incluídas são o mesmo ou mais recente do que a
versão de Kettle você está usando. Por exemplo, Pentaho Relatórios 3.8 inclui Kettle 4.1.2 bibliotecas. Se você estiver
usando uma versão diferente do Pentaho Reporting, então você pode verificar a versão Chaleira procurando no lib pasta dentro
da pasta de instalação de relatórios. Você deve procurar arquivos nomeados chaleira-core-<versão>. jar, chaleira-db- <version> .jar, e
chaleira-engine- <version> .jar. Além disso, se as transformações que pretende utilizar como fontes de dados dependem de
bibliotecas externas, você tem que copiar os arquivos jar apropriados do Kettle libext diretório no Report Designer lib pasta,
assim como você fez com o janino.jar arquivar na receita.
Para mais informações sobre Pentaho Reporting, apenas visite o seguinte site wiki:
http://wiki.pentaho.com/display/Reporting/Pentaho+Reporting+Community
+ Documentação.
Alternativamente, você pode obter o livro, Pentaho Relatórios 3.5 para desenvolvedores Java, Publicação Packt por Will
Gorman.
Preparando-se
Antes de continuar este exercício, você vai precisar do forecast.prpt relatório criado no último receita. Isso pode ser
obtida quer através do site da Packt ou criando o relatório de acordo com a receita anterior neste capítulo.
329
Integrando Chaleira e Suite Pentaho
4. Adicionar um Adicionar constantes passo para a tela. Haverá um campo nesta etapa:
?? Nome: report_file
?? Tipo: Corda
?? Valor: forecast.prpt
6. Adicione Modificada Java Script Valor para a tela. Digite o seguinte código (cortesia: o
amostra para Pentaho Report Generation):
// Apare o 'ficheiro: C ///' levando os caracteres a partir do caminho completo Report_Template = substr
(Report_Template, 6); Report_Output = substr (Report_Output, 6);
8. Finalmente, adicione uma Saída Pentaho Relatórios passo para a tela. sua transformação
agora deve ser semelhante à imagem seguinte:
330
Capítulo 9
10. Clique no ESTÁ BEM, salvar e executar a transformação. Um arquivo CSV para cada cidade entrou na
grade de dados agora deve ser gerado.
Como funciona...
A Pentaho relatando arquivo armazena todos os detalhes sobre o relatório (incluindo como obtê-lo é de dados) que o torna fácil
de usar com o saída do arquivo Pentaho Relatórios degrau. Na transformação, criamos uma lista de cidades, que escala
queríamos a temperatura para retornar como, se o arquivo de relatório vive, e como queríamos que o nome da saída a ser
formatado.
331
Integrando Chaleira e Suite Pentaho
Podemos passar praticamente todas as variáveis que queremos um relatório e obter o resultado desejado.
Tem mais...
Para fazer essa transformação ainda mais interessante, podemos realizar ações mais complicadas, como e-mail o relatório de
arquivos para destinatários desejados ou movê-los para outro servidor para processamento posterior. As capacidades flexíveis de
Pentaho permitir quase qualquer caso de uso.
Veja também
fo Envio de e-mails com arquivos anexados receita em Capítulo 10, Obtendo o máximo
Fora de Kettle
O Pentaho BI Server é uma coleção de componentes de software que fornecem a arquitetura e infra-estrutura necessária para
construir soluções de inteligência de negócios. Com o Pentaho BI Server, você é capaz de executar relatórios, visualizar dashboards,
agendar tarefas, e muito mais. Entre essas tarefas, não é a capacidade de executar tarefas chaleira e transformações. Esta receita
mostra os pequenas mudanças que você pode ter que fazer, a fim de ser capaz de executar trabalhos de chaleira e transformações.
Preparando-se
A fim de seguir esta receita, você vai precisar de alguma experiência com o Pentaho BI Server. Para configurar o
servidor Pentaho BI, você obviamente precisa do software. Você pode baixar a versão mais recente do Servidor
Pentaho BI a partir do seguinte URL: http://sourceforge.net/ projectos / Pentaho / arquivos / Negócios% 20Intelligence%
20Server /.
Se você pretende executar tarefas e transformações de um repositório Chaleira, verifique se você tem o nome do repositório
e credenciais adequadas (nome de usuário e senha).
332
Capítulo 9
3. No repository.type tag, substitua o valor padrão arquivos com RDBMS. Fornecer o nome do seu repositório
Chaleira e o nome de usuário e senha, como mostrado no exemplo a seguir:
<Chaleira-repositório>
<! - Os valores dentro <properties> são passadas diretamente para os componentes Chaleira Pentaho. ->
<! - Este é o local do arquivo repositories.xml Chaleira, deixe em branco se o padrão é usado: $ HOME /
.kettle / repositories.xml
- - >
<Repositories.xml.file> </ repositories.xml.file>
</ Chaleira-repositório>
4. Inicie o servidor. Ele estará pronto para executar tarefas e transformações de seu repositório Chaleira.
Como funciona...
Se você deseja executar transformações chaleira e empregos, então o servidor Pentaho BI já inclui as bibliotecas chaleira. O
servidor está pronto para executar as duas tarefas e transformações de arquivos. Se você pretende usar um repositório, você tem
que fornecer as configurações do repositório. A fim de fazer isso, você só tem que editar o settings.xml arquivo, como você fez na
receita.
333
Integrando Chaleira e Suite Pentaho
Tem mais...
Para evitar qualquer inconveniente, certifique-se de que a versão das bibliotecas incluídas são o mesmo ou mais recente do
que a versão de Kettle você está usando. Por exemplo, Pentaho BI Server 4.8 inclui Kettle 4.4 bibliotecas. Se você estiver
usando uma versão diferente do servidor, então você pode verificar a versão Chaleira procurando no seguinte pasta: \ biserver-ce
\ tomcat \ webapps \ pentaho \ WEB-INF \ lib.
Esta pasta está dentro da pasta de instalação do servidor. Você deve procurar arquivos nomeados kettlecore-
<version> .jar, chaleira-db- <version> .jar, e chaleira-motor <version> .jar. A versão será a versão real dos arquivos
(por exemplo, kettlecore-4.4.1-GA.jar).
Existe ainda uma maneira mais fácil: na Pentaho usuário Console (PUC), ir para o Exemplos BI Desenvolvedor pasta
sob o amostras pasta e procure o Integração de dados com Kettle pasta. Dentro do Integração de dados com Kettle pasta,
procure a opção 2,
Pegue Meio Ambiente Em formação. Executá-lo, e você obterá informações detalhadas sobre o ambiente Chaleira.
Veja também
Tudo na plataforma Pentaho é feito de sequências de ação. A sequência de acção é, como o próprio nome sugere, uma sequência de
acções atómicas que juntos realizar pequenos processos. Essas ações atômicas cobrem um amplo espectro de tarefas, por exemplo, a
obtenção de dados de uma tabela em um banco de dados, executando um pedaço de código JavaScript, o lançamento de um relatório,
o envio de e-mails, ou executando uma transformação Chaleira. Para esta receita, suponha que você deseja executar a transformação
de amostra para obter as condições meteorológicas atuais para algumas cidades. Em vez de executar este a partir da linha de comando,
você quer interagir com este serviço da PUC. Você vai fazê-lo com uma seqüência de ação.
334
Capítulo 9
Preparando-se
A fim de seguir esta receita, você vai precisar de um entendimento básico de sequências de ação e pelo menos alguma
experiência com o Servidor Pentaho BI e Pentaho Design Studio, o editor sequências de ação.
Antes de prosseguir, certifique-se de que você tem um servidor que executa Pentaho BI. Você também vai precisar Pentaho
Design Studio. Você pode baixar a versão mais recente a partir do seguinte URL:
http://sourceforge.net/projects/pentaho/files/Design%20Studio/.
Esta receita é dividida em duas partes: primeiro, você vai criar a seqüência de ação, e então você vai testá-lo a partir da PUC.
Então, execute os seguintes passos:
1. Inicie o Design Studio. Se esta é sua primeira utilização, em seguida, criar o projeto de solução, onde irá guardar o seu
trabalho.
3. Criar uma nova seqüência de ação e salve-o em seu projeto solução com o nome
weather.xaction.
4. Defina duas entradas que serão utilizados como parâmetros para a sua transformação:
Nome da Cidade e temperature_scale.
5. Adicione dois Prompt / Segura Filtro ações e configurá-los para solicitar o nome
da cidade e da escala de temperatura.
6. Adicione uma nova ação de processo, selecionando Obter Dados de | Integração de Dados Pentaho.
<Action-definition>
<Component-name> KettleComponent </ component-name>
<Action-type> olhando para o tempo atual </-tipo de ação>
335
Integrando Chaleira e Suite Pentaho
<action-inputs>
<NOME_CIDADE type = "string" /> <temperature_scale
type = "string" /> </ action-inputs> <action-recursos>
<Set-argumento>
<Name> 1 </ name>
<Mapping> NOME_CIDADE </ mapping> </
set-argumento>
Na verdade, você pode escrever isso em qualquer lugar entre < component-definition>
e </ component-definition>. A ordem das etiquetas internas não é importante.
14. Agora, preencha Seção de saída do Integração de Dados processo ação processo. Para
Linhas de saída Nome, tipo weather_result e para Linhas de saída Contagem Nome,
tipo numero de linhas.
15. Abaixo do Integração de Dados processo ação processo, adicione Se declaração. Enquanto o
condição, tipo number_of_rows == 0.
17. No Texto tipo de moldura Nenhum resultado para a cidade {NOME_CIDADE}. Para
Nome de saída, tipo weather_result.
18. Por fim, no Saídas de processo seção da seqüência de ação, adicione weather_result
como a única saída.
336
Capítulo 9
19. Sua seqüência de ação final deve ser como a mostrada na imagem seguinte:
1. Faça login na PUC e atualizar o repositório, para que weather.xaction que você acabou
criado aparece.
2. Percorrer as pastas de solução e procurar xaction e clique duas vezes sobre ele.
4. Clique em Corre; você verá uma página de gerar com os nomes e valores da
dados meteorológicos.
337
Integrando Chaleira e Suite Pentaho
5. Você pode dar uma olhada no console Pentaho para ver o log da transformação correndo nos
bastidores.
6. Execute a seqüência de ação novamente. Desta vez, digite o nome de uma cidade fictícia, por exemplo, my_invented_city.
Desta vez, você verá a seguinte mensagem:
Como funciona...
Você pode executar transformações Chaleira como parte de uma seqüência de ação, utilizando o
dados Pentaho ação processo de integração localizado dentro do Obter Dados de
categoria de acções de processo.
A principal tarefa de uma ação de processo PDI é executar uma transformação Chaleira. A fim de fazer isso, ele tem uma lista de
freios e caixas de texto onde você especificar tudo que você precisa para executar a transformação e tudo o que você deseja
receber de volta depois de ter executá-lo. A configuração mais importante na acção processo PDI é o nome ea localização da
transformação a ser executada. Neste exemplo, você tinha uma. ktr arquivo no mesmo local que a seqüência de ação, para que você
simplesmente digitado solução: seguido pelo nome do arquivo. Em seguida, no transformação Passo caixa de texto, você especificou
o nome da etapa na transformação que iria dar-lhe os resultados que você necessários. A acção processo PDI (assim como
qualquer acção processo regular) é capaz de receber entrada a partir da sequência de acção e retorno de dados a ser usado mais
tarde na sequência. Portanto, na lista suspensa na transformação Passo caixa de texto, você pode ver a lista de entradas seqüência
de ação disponíveis. Neste caso, você acabou de digitar o nome da etapa.
Se você não estiver familiarizado com seqüências de ação, note que a lista
suspensa na transformação Passo caixa de texto não é a lista de passos
disponíveis. É a lista de entradas seqüência de ação disponíveis.
Você tem a opção de especificar o nível de log Chaleira. Neste caso, você selecionou Basic.
Este foi o nível de log que Chaleira escreveu para o console Pentaho. Note-se que, neste caso, você também tem a
opção de selecionar uma entrada seqüência de ação em vez de um dos níveis de log na lista.
Como foi dito anteriormente, a acção processo pode usar quaisquer entradas a partir da sequência de acção. Neste caso, você usou
duas entradas: Nome da Cidade e temperature_scale. Então você passou por eles para a transformação no código XML:
f Colocando Nome da Cidade entre < definir parâmetros> </ set-parâmetro>, você
passou o Nome da Cidade input como o primeiro argumento de linha de comando.
338
Capítulo 9
Como mencionado, o processo pode retornar os dados a serem utilizados mais tarde na sequência. As caixas de texto no Seção de saída são
destinadas a fazer isso. Cada caixa de texto que você preenche será um novo campo de dados para ser enviado para a próxima ação
processo. Neste caso, você definiu duas saídas: weather_result e
numero de linhas. A primeira contém o conjunto de dados que sai do passo que você definido na
Passo transformação, nesse caso, current_conditions_normalized. O segundo tem o número de linhas em que conjunto
de dados.
Você usou essas saídas na próxima ação processo. E se numero de linhas foi igual a zero, então você iria substituir o weather_result
dados com uma mensagem a ser exibida para o usuário. Finalmente, você adicionou weather_result como a saída da
seqüência de ação, para que o usuário quer vê as condições atuais para a cidade necessário, ou a mensagem
personalizada indicando que a cidade não foi encontrado.
Tem mais...
A seguir estão algumas variantes no uso da ação processo Pentaho Data Integration.
Se em vez de ter a transformação em um arquivo, ele está localizado em um repositório, você deve verificar o Use Repository
Kettle opção. o arquivo de transformação caixa de texto será substituído por duas caixas de texto com o nome Diretório e Arquivo
transformação. Nessas caixas de texto, você deve digitar o nome da pasta e a transformação exatamente como elas são no
repositório. Alternativamente, você pode selecionar os nomes das listas suspensas disponíveis.
você pode passá-los a partir da sequência de ação por mapeamento KettleComponent insumos. Primeiro de tudo, você precisa
incluí-los no Entradas de transformação seção. Isto é equivalente a digitá-los dentro do elemento XML de ação e definição
KettleComponent.
339
Integrando Chaleira e Suite Pentaho
Então, dependendo do tipo de dados para passar, você tem que definir um elemento diferente:
parâmetro chamado <SetParameter> </ setParameter> Valores que são passados como parte
de um trabalho ou de transformação
Na receita você mapeou um argumento de linha de comando e um parâmetro nomeado. Com as seguintes linhas, você
<Set-parâmetro>
<Name> TEMP </ name>
<Mapping> temperature_scale </ mapping> </
set-parâmetro>
No caso de argumentos em vez de um nome, você tem que fornecer a posição do parâmetro: 1, 2, e assim por
diante.
Esta maneira de fornecer valores para parâmetros nomeados, variáveis e argumentos de linha de
comando também se aplica aos trabalhos executados a partir de uma sequência de ação.
340
Capítulo 9
em seu blog, Self Service Data Export utilizando Pentaho. O seguinte é o link para esse post, que também
inclui código de exemplo para download: http://www.nicholasgoodman.com/ bt / blog / 2009/02/09 /
self-service-data-usando-export-pentaho /.
Veja também
Pentaho usuário Console (PUC) é uma aplicação web incluído com o Pentaho Server, convenientemente construído para gerar
relatórios, procurar cubos, explorar dashboards, e muito mais. Entre a lista de tarefas, é a capacidade de executar tarefas chaleira.
Como mencionado na receita anterior, tudo na plataforma Pentaho é composta de seqüências de ação. Portanto, se você pretende
executar um trabalho da PUC, você tem que criar uma seqüência de ação que faz isso. Para esta receita, você vai usar um trabalho
que simplesmente exclui todos os arquivos com extensão. tmp encontrado em uma determinada pasta. O objetivo é executar o
trabalho pela PUC através de uma sequência de ação.
Preparando-se
A fim de seguir esta receita, você vai precisar de um entendimento básico de sequências de ação e pelo menos alguma
experiência com o Servidor Pentaho BI e Pentaho Design Studio, o editor sequências de ação.
Antes de prosseguir, verifique se você tem um servidor que executa Pentaho BI. Você também vai precisar Pentaho Design
Studio; você pode baixar a versão mais recente a partir do seguinte URL:
http://sourceforge.net/projects/pentaho/files/Design%20Studio/.
você também vai precisar de um trabalho como o descrito na introdução à receita. O trabalho deveria ter um parâmetro nomeado
chamado TMP_FOLDER; simplesmente apagar todos os arquivos com extensão. tmp encontrado nessa pasta. Você pode desenvolver o
trabalho antes de prosseguir (chamá-lo delete_files.kjb), ou baixá-lo do site da Packt. Finalmente, escolher um diretório no seu
computador (ou criar uma) com alguns. tmp arquivos para apagar.
341
Integrando Chaleira e Suite Pentaho
Esta receita é dividida em duas partes: Primeiro, você irá criar a seqüência de ação e, em seguida, você vai testar a seqüência
de ação da PUC.
1. Inicie o Design Studio. Se é a primeira vez que você lançou, crie o projeto de solução, onde irá guardar
o seu trabalho.
2. Copie o trabalho de exemplo para a pasta de solução.
3. Criar uma nova seqüência de ação e salve-o em seu projeto solução com o nome
delete_files.xaction.
4. Defina uma entrada que será usada como parâmetro para o seu trabalho: pasta. Como Padrão
Valor, digite o nome da pasta com o. tmp arquivos, por exemplo, c: \ myfolder.
5. Adicione uma ação de processo, selecionando executar | Job integração de dados Pentaho.
6. Agora, você irá preencher Seção de entrada da configuração do processo de acção. Dê o processo
ação um nome.
<Action-definition>
<Component-name> KettleComponent </ component-name> <action-type> Job integração de
dados Pentaho </ action-type> <action-inputs>
342
Capítulo 9
2. Percorrer as pastas de solução e olhar para o deletar arquivos acção que acabou
criado. Dê um duplo clique sobre ele.
3. Você deverá ver uma janela com a lenda Ação bem sucedida.
4. Você pode dar uma olhada no console Pentaho para ver o log do trabalho.
5. Dê uma olhada na pasta definida na entrada de sua seqüência de ação. Não deve haver nenhuma. tmp
arquivos.
Como funciona...
É possível executar tarefas Chaleira como parte de uma seqüência de ação usando ação processo de trabalho de integração de dados Pentaho localizado
dentro do Executar categoria de acções de processo. A principal tarefa de um Job PDI acção processo é para executar um trabalho Chaleira. A fim de
fazer isso, ele tem uma série de verificações e caixas de texto onde você especificar tudo que você precisa para executar o trabalho, e tudo o que
A configuração mais importante na acção processo PDI é o nome eo local do trabalho a ser executado. Neste exemplo, você
tinha uma. kjb arquivo no mesmo local que a seqüência de ação, para que você simplesmente digitado solução: seguido pelo
nome do arquivo.
Você pode especificar o nível de log Chaleira, mas não é obrigatório. Neste caso, você deixou o nível de log vazio. O nível de log
selecionado aqui ( Basic, por padrão) é o nível de log que Kettle escreve para o console Pentaho quando o trabalho é executado.
Além do nome e localização do trabalho, você teve que fornecer o nome da pasta necessária para o trabalho. A fim de
fazer isso, você criou uma entrada chamada pasta e então você passou para o trabalho. Você fez isso no código XML,
colocando o nome da entrada fechado entre
<Set-parâmetro> e </ set-parâmetro>.
Quando você executou a seqüência de ação, o trabalho foi executado exclusão de todos. tmp arquivos na pasta dada.
A sequência de acção nesta receita tem apenas uma acção processo (o PDI do
trabalho). Isto foi feito com o propósito de manter a receita simples, mas poderia ter
tido outras ações, bem como, como qualquer seqüência de ação.
343
Integrando Chaleira e Suite Pentaho
Tem mais...
A principal razão para a incorporação de um emprego em uma seqüência de ação é para agendar a sua execução com os serviços de
agendamento Pentaho. Esta é uma abordagem alternativa para a utilização de um utilitário do sistema, tais como cron em sistemas operacionais
baseados em Unix ou o Agendador de tarefas no Windows.
Veja também
Como você sabe, PDI permite gerar Excel, CSV e arquivos XML e, começando com a versão mais recente, também arquivos
JSON. Você fazê-lo com uma transformação que tem de ser executado a partir de colher ou a linha de comando. Existe uma
maneira mais rápida para gerar esses tipos de arquivos de forma interativa pela PUC. Esta receita ensina-lhe como fazê-lo
usando o Data Access Comunidade
( CDA) plugar.
Você vai experimentar com a editor do CDA e a CDA Previewer para consultar as condições atuais do tempo em uma determinada
cidade. Então, você vai aprender a exportar os resultados para diferentes formatos. Você vai fazer isso pela PUC.
Preparando-se
A fim de seguir esta receita, você vai precisar de alguma experiência com o Pentaho BI Server. Em relação ao
software, você precisará de um servidor executando o Pentaho BI. Você também vai precisar do plugin CDA. Você
pode baixar o instalador de http://cda.webdetails.org ou o código-fonte http://code.google.com/p/pentaho-cda/.
344
Capítulo 9
Esta receita é dividida em duas partes. Na primeira parte, você vai criar um arquivo de CDA para obter os dados que você precisa. Na
segunda parte, você vai exportar os resultados. Então, execute os seguintes passos a fim de completar a primeira parte:
2. Dentro da pasta do seu projeto, copie o weather_np.ktr transformação em seu diretório do projeto.
3. Também dentro dessa pasta, crie um arquivo vazio com um. cda extensão. Diga
weather.cda.
4. Efetue login no Pentaho Console do Usuário e atualizar o repositório. Você deverá ver a pasta de solução com o
arquivo que você acabou de criar.
5. Dê um clique direito sobre o arquivo e selecione Editar. Uma nova janela guia deve aparecer com o
CDA editor pronto para editar o arquivo CDA, como mostrado na imagem seguinte:
6. A área branca é onde você irá digitar o conteúdo do arquivo CDA. Digite o esqueleto do arquivo:
345
Integrando Chaleira e Suite Pentaho
8. Agora você vai definir um acesso de dados para essa fonte de dados. Na terminologia CDA, esta é uma consulta através
da ligação anterior. Abaixo da marca de fechamento </ fontes de dados>,
digite o seguinte:
<DataAccess access = "público"
cache = "true" CacheDuration =
"3600" connection = "Tempo" id =
tipo "corrente" = "chaleira">
<Colunas />
<Parâmetros>
<Parâmetro default = "Orlando, FL"
name = tipo "CIDADE" =
"String" />
<Parâmetro default = "C"
name = tipo "Scale" =
"String" />
</ Parâmetros>
<Índices de saída = "0.1" /> <Consulta> current_conditions_normalized </
consulta> </ DataAccess>
10. Clique no visualização e uma nova janela é exibida com o CDA Previewer.
11. Na lista suspensa, selecione o acesso a dados que você acabou de definir.
12. Dê uma olhada no console do servidor Pentaho. Você deve ver como o weather_np
transformação está sendo executado. O seguinte é um trecho do que log:
. . . - . . .
. . . - current_conditions_normalized - processamento de acabamento (I = 0, S = 0, R = 11, W = 11, L =
0, E = 0)
16. Agora que você tem um arquivo CDA com uma conexão e um acesso a dados, vamos exportar alguns resultados. csv formato.
346
Capítulo 9
17. Copie o URL do visualizador e colá-lo em uma nova janela da guia do navegador. Assumindo
que você está executando o servidor no localhost, e sua solução está na pasta pdi_cookbook /
CDA, a URL completa deve ser semelhante a seguinte URL: http: // localhost: 8080 / Pentaho /
content / cda / previewQuery path = pdi_cookbook / CDA / weather.cda.
Ao clicar duas vezes sobre o arquivo CDA, o editor abre em uma aba dentro da PUC. Isso
impede que você copiar a URL. A fim de ser capaz de copiar a URL, clique duas vezes na guia
que contém o Editor do CDA. Alternativamente, você pode botão direito do mouse sobre o
Estes parâmetros são escritos em quatro linhas de simplicidade. Você deve digitar tudo
em uma única linha de um lado para o outro.
20. Imprensa Entrar. UMA csv será gerada que deverá ser parecido com o seguinte:
RECURSO; VALOR
City; Buenos Aires, Argentina Tempo de
observação; 06: 25 PM
Descrição do tempo; chuva Moderado ou pesado na área de temperatura, a
velocidade do vento 91; 24 direcção do vento; W Precipitação; 0,2 Humidade; 53
Visibilidade; 3 Pressão; 9982 Cobertura de nuvens; 100
Como funciona...
Nesta receita, você exportou os resultados de uma transformação Kettle a um. csv arquivo da PUC. A fim de fazer isso, você
usou CDA.
347
Integrando Chaleira e Suite Pentaho
Primeiro, você criou um arquivo de CDA. Você editou com o Editor de CDA. O objetivo deste arquivo foi definir em primeiro lugar uma
conexão com a transformação Kettle e depois uma consulta sobre essa conexão. Vamos explicá-las em detalhe.
A conexão ou fonte de dados CDA é a definição da fonte de seus dados, neste caso, uma transformação
Chaleira. O seguinte é a definição de sua conexão:
porção identifica esta como uma ligação para uma transformação chaleira. Você fornece o nome da transformação
Chaleira dentro das tags < KtrFile> </ KtrFile>.
Então você tem as variáveis. As variáveis são os meios para passar parâmetros do CDA para Kettle; datarow-name é o
nome que você usa no arquivo CDA, enquanto nome variável é o nome da chaleira de parâmetro nomeado. Por
exemplo, a variável chamada TEMP definido na transformação é referida como Escala dentro do arquivo CDA.
Agora, vamos ter um olhar para a consulta CDA. A CDA Data de acesso é uma consulta sobre uma fonte de dados CDA. No caso de Kettle,
a CDA Data de acesso tem os detalhes de uma execução de transformação Chaleira. Uma consulta CDA é fechado dentro de uma tag com
o nome Data de acesso:
Aqui você define uma ID de acesso de dados único ( id = "current"), o tipo de acesso de dados ( type = "chaleira"), e
a ligação ( connection = "Tempo"). A ligação deve ser declarado anteriormente no mesmo arquivo. o < colunas> </
colunas> tag é útil se você quiser mudar o nome das colunas ou realizar operações entre eles, o que não era o
348
Capítulo 9
<Parâmetros>
<Parâmetro default = "Orlando, FL"
name = tipo "CIDADE" =
"String" />
<Parâmetro default = "C"
name = tipo "Scale" =
"String" />
</ Parâmetros>
Aqui você define um < parâmetro> tag para cada parâmetro que você deseja passar para a transformação. Os
parâmetros que você digita aqui estarão disponíveis no CDA Previewer para você mudar.
A fim de ser capaz de passar os parâmetros, eles têm que ser definidos na fonte de
dados, como explicado anteriormente.
Dentro do < Consulta> </ query> tag, você digita o nome da etapa de transformação que retorna os dados que você
precisa. A transformação de exemplo tem três etapas que retornam dados:
condições atuais, current_conditions_normalized, e previsão. Você digitou o segundo destes passos. Finalmente, o
< saída> tag pretende indicar quais colunas você quer e em que ordem. Os campos da saída current_conditions_normalized
etapa são CARACTERÍSTICA e
VALOR. Você queria que ambos os campos e na mesma ordem, portanto, você digitou índices = "0.1".
Você pode editar os arquivos CDA em qualquer editor de texto. Basta lembrar que se você não
usar o Editor do CDA, você deve atualizar periodicamente o repositório de soluções, a fim de
ser capaz de visualizá-las.
Depois de criado o conteúdo do arquivo, você salvou, e visualizado os resultados com o CDA Previewer. Este visualizador mostra
os resultados como uma mesa. Depois de visualizar os resultados, você experimentou com o doQuery característica do CDA API.
A documentação da API Comunidade Data Access fornece mais detalhes sobre todas as
funções do CDA e como ele pode interagir com outros componentes Pentaho. Ele está
disponível a partir de detalhes na Web em
http://www.webdetails.pt/ctools/cda.html.
349
Integrando Chaleira e Suite Pentaho
o doQuery função permite exportar os resultados de um acesso a dados para diferentes formatos. A fim de executar um doQuery, você
tem que fornecer os seguintes parâmetros:
param + <Nome do Um deste para cada parâmetro que você deseja paramCITY = 'Buenos Aires,
param.> passar para a transformação Argentina'
tipo de saída tipo de saída desejada. tipos de saída outputType = csv
disponíveis: JSON ( padrão se o parâmetro for
omitido), CSV, Excel, e XML
Os parâmetros fornecidos na receita (mostrado na tabela anterior) significava: executar o DataAccess com
ID atual, fornecendo o parâmetro CIDADE com valores Buenos Aires, Argentina e Escala com valor F, e me a dar. csv
arquivo com os resultados.
Tem mais...
CDA é um plugin para o Pentaho BI Suite desenvolvido pela Webdetails, um dos principais contribuintes Pentaho
comunitárias e agora um membro da família Pentaho.
CDA foi concebido como uma ferramenta de abstração entre fontes de informação, por exemplo, transformações Chaleira, bancos
de dados, ou Mondrian cubos, e do CDF. Como tal, ele é usado principalmente no contexto de Pentaho painéis.
No entanto, também serve para exportar dados a partir de diferentes formatos PUC. Isso foi exatamente o que fez na
receita.
Se você estiver interessado em saber mais sobre CDA, então você vai encontrar a documentação
completa no seguinte URL: http://cda.webdetails.org.
Nesta receita você vai criar um painel muito simples que mostra esta capacidade. Você irá digitar o nome de uma
cidade e o painel irá mostrar graficamente os 5 dias previstos para aquela cidade. A informação de previsão irá ser
obtida com a amostra de transformação explicado na introdução.
350
Capítulo 9
Preparando-se
A fim de seguir esta receita, você precisará de um mínimo de experiência com a Pentaho BI Server. Alguma experiência com
o CDE também é desejável.
Antes de prosseguir, verifique se você tem um servidor que executa Pentaho BI. Você também vai precisar do
CDE. Você pode baixá-lo http://cde.webdetails.org. Para instalá-lo, basta descompactar o material baixado e siga as
instruções no INSTALL.txt Arquivo. Alternativamente, você pode baixar CDE através do mercado encontrado em Ferramentas>
Marketplace.
4. A partir do Arquivo de menu, selecione nova | CDE Painel ou clique no ícone CDE em
a barra de ferramentas.
5. Salve o dashboard na pasta de solução que acabou de criar, feche a janela do painel de instrumentos, e atualizar o
repositório. Um novo arquivo com extensão wcdf aparecerão na pasta de solução.
6. Vá para a pasta de solução, clique direito sobre o arquivo painel e selecione Editar.
O editor painel irá aparecer. Maximizar a janela, para que você possa trabalhar mais
confortavelmente.
7. Defina o layout de painel, adicionando linhas e colunas na barra de ferramentas layout, até chegar a
seguinte tela:
351
Integrando Chaleira e Suite Pentaho
10. A partir da Selects categoria, adicione um TextInput Component. Diga caixa city_text.
Para Parâmetro, selecionar city_param e para HtmlObject, selecionar filter_panel.
12. Clique no pré-visualização; você verá o painel com uma caixa de texto alertando para o
Nome da Cidade parâmetro, mostrando o valor padrão Orlando, FL.
14. Agora, você irá adicionar o gráfico que irá exibir a previsão. De charts categoria,
adicionar Gráfico CCC Bar.
Finalmente, você tem que criar a fonte de dados para esse gráfico: previsão. Os passos seguintes irão fazê-lo:
352
Capítulo 9
7. Clique em Opções de saída e, na janela que aparece, clique em Adicionar três vezes. Para
Arg0, arg1, e arg2, tipo 1, 2, e 3 respectivamente e clique em Está bem. Clique em Configurações de coluna e, na janela
que é exibida, clique em Adicionar duas vezes. Na primeira linha, o tipo 2 para arg0 e MIN para Val0. Na segunda linha,
tipo 3 para arg1 e MAX para Val1.
Orlando, FL
5 dias previsão
30
25
20
15
10
0
2013/08/27 2013/08/28 2013/08/29 2013/08/30 2013/08/31
MÍNIMO MÁXIMO
10. Se você der uma olhada no console do Pentaho, então você vai ver o log da transformação
Kettle que é executado.
11. Tente alterar o valor para a cidade e pressione Entrar. O gráfico deve ser
actualizada em conformidade.
Como funciona...
Nesta receita, você criou um painel muito simples. O painel permite que você digite o nome de uma cidade e, em seguida, atualiza
um gráfico de barras mostrando os 5 dias previstos para aquela cidade. A característica especial deste painel é que ele recebe
dados de um serviço web através da execução de uma transformação Chaleira.
353
Integrando Chaleira e Suite Pentaho
Para utilizar a saída de sua transformação Chaleira o como fonte de dados, você só tem que adicionar uma nova fonte de dados
de CHALEIRA Consultas | Chaleira sobre kettleTransFromFile e configurá-lo corretamente. Esta configuração envolve fornecer as
seguintes propriedades:
Chaleira weather_np.ktr
arquivo de transformação Nome do arquivo de transformação.
parâmetros Nome, valor padrão e tipo para cada "Cidade", "Orlando, FL",
parâmetro a ser passado para a "String"
transformação.
Opções de saída (OPT) Índices das colunas para escolher entre os campos que 1,2,3
saem a partir da transformação.
Coluna 2 MINUTOS"
Coluna Calculando novas colunas com base em outras colunas. AVG, (MAX + MIN) / 2
Configurações II (opt)
Uma vez que você configurou sua transformação Chaleira como uma fonte de dados, ele estava pronto para ser utilizado nos
componentes de seu painel.
Tem mais...
CDF é um projeto da comunidade cujo objetivo é principalmente para integrar painéis na estrutura repositório solução
do Pentaho. Na receita, você usou o CDE, que é um editor gráfico que complementa a potência do motor CDF. Com
CDE, você pode criar dashboards sem ter que se envolver nos detalhes de baixo nível dos arquivos CDF, incidindo
assim sobre os requisitos de negócio.
354
Capítulo 9
Chaleira é apenas um dos vários tipos de fontes de dados aceites pela CDF. Nos bastidores, a maioria das definições fontes de dados
são salvos em um arquivo de CDA.
Se você já tem um arquivo CDA que tem um acesso de dados para a sua transformação, você
pode evitar a configuração da fonte de dados duas vezes e usar o Dados comunidade Acesso |
fonte de dados CDA em vez de.
CDF é fornecido com o Pentaho BI Suite, mas mantido por Webdetails com a ajuda da comunidade. Para
mais informações sobre CDF, consulte a documentação completa no seguinte site: http://cdf.webdetails.org. Para
mais informações sobre CDE visita
http://cde.webdetails.org.
355
10
Obtendo o máximo
Fora de Kettle
Introdução
As receitas neste capítulo cobrem uma variedade de tópicos que não se encaixam em nenhuma das categorias anteriores. Os temas
variam de personalizar um log Chaleira para entender a estrutura de um repositório de dados Chaleira. Sinta-se livre para navegar as
páginas e ver se há uma receita que satisfaça suas necessidades.
Obtendo o máximo de Kettle
Preparando-se
Você precisa de um diretório chamado filesToAttach contendo arquivos de amostra. Você também vai precisar de acesso a um servidor
SMTP. Você pode usar o smtp.gmail.com servidor. Você também precisa de pelo menos uma conta válida para jogar.
3. De acordo com o Arquivo guia, digite ou navegue para o filesToAttach pasta na arquivo ou
diretório caixa de texto. Digite. * Na Expressão regular caixa de texto e clique no Adicionar
botão para preencher o arquivos selecionados grade.
4. Sob o Filtro guia, desmarque a Adicionar nome do arquivo para resultar checkbox.
5. Adicione uma Filtrar linhas passo do Fluxo categoria. Aqui, adicionar uma nova condição, selecione
o campo lastModifiedTime, o operador', e inserir uma data valor constante para comparar com, por exemplo, 2010/11/01.
Não se esqueça de selecionar o formato de conversão expressão para coincidir com o formato de data.
7. Criar um hop do Filtrar linhas passo para esta etapa. Quando perguntado sobre o tipo
do lúpulo, selecione saída principal da etapa. A transformação será semelhante ao mostrado na
imagem seguinte:
8. Dê um duplo clique sobre o Definir arquivo no resultado degrau. selecionar nome do arquivo no Nome do arquivo campo, e
358
Capítulo 10
11. Dê um duplo clique sobre esta entrada trabalho e digite o caminho completo da transformação criado anteriormente
(ou procurá-lo) na filename transformação caixa de texto.
12. Adicionar uma validador correio entrada de trabalho do o email categoria. Neste passo, o tipo
conta de destino no Endereço de e-mail caixa de texto.
14. Sob a endereços guia, preencha o endereço de destino caixa de texto eo Remetente
endereço caixa de texto com dois endereços de e-mail válidos (que pode ser o mesmo se você tiver apenas uma conta
para jogar). Além disso, você precisa para completar a Nome do remetente
caixa de texto. Por exemplo, você pode digitar seu nome.
Você pode especificar mais de uma conta, utilizando um espaço como um separador
no endereço de destino do o email e validador correio entradas de trabalho.
você usar uma conexão segura através de TLS, então o padrão é 587.
359
Obtendo o máximo de Kettle
16. Sob a Mensagem de email guia, preencha o Sujeito caixa de texto eo Comente área
com texto da amostra. Além disso, verifique o Apenas envie comentários no corpo da mensagem? checkbox.
17. Selecione o Arquivos anexados guia e marque a opção Anexar arquivo (s) a mensagem ?.
19. Verifique o arquivos Zip para único arquivo? checkbox. Digite um nome de arquivo no Nome de zip
arquivo caixa de texto (por exemplo, files.zip).
20. A execução do trabalho, um e-mail será enviado para o endereço de destino (se ele é válido). Ele irá incluir um
arquivo zip anexado com todos os arquivos do filesToAttach pasta que cumprir a condição de data.
Como funciona...
A primeira tarefa no exemplo foi a criação de uma transformação que recebe os arquivos que serão enviados como um anexo com
o e-mail. Para isso, você usou o Obter nomes de arquivos passo para obter os arquivos dentro do filesToAttach pasta, e então o Filtrar
linhas passo para filtrar os arquivos com
lastModifiedTime maior do que uma data específica, neste caso, 2010/11/01. Apenas os arquivos que passam esta condição será definida no
resultado. Lembre-se de desmarcar a Adicionar nome do arquivo para resultar caixa de seleção na Obter nomes de arquivos passo, porque
você não quer que todos os arquivos, apenas o resultado após a filtragem de linha.
O trabalho é executado esta transformação, e, em seguida, executa o O email entrada de trabalho. Este trabalho é bastante
auto-explicativo. Debaixo de endereços guia, você deve completar o destino e remetentes de e-mails endereços e conteúdo de e-mail sob
o Mensagem de email aba. O exemplo usa o servidor SMTP do Gmail ( smtp.gmail.com), mas você pode usar qualquer servidor de e-mail,
desde que você tenha acesso às informações necessárias na Servidor aba. Dê uma olhada na configuração de firewall se você tiver
problemas para alcançar o endereço especificado. Debaixo de Arquivos anexados guia, você selecionou a opção de tipo de arquivo
chamado Geral; isso indica que todos os arquivos incluídos na lista de resultados será anexado ao e-mail. Além disso, você configurou a
entrada para fechar todos os arquivos em um único arquivo.
Se os trabalhos anteriores ou transformações também acrescentou arquivos para resultados, em seguida, os arquivos serão anexados
também. Portanto, um Excluir nomes de arquivo de resultado entrada de trabalho pode ser necessária no início deste trabalho. Você usou o validador
correio entrada de trabalho para verificar a estrutura endereço de e-mail. Se a estrutura não estiver correta, então o O email entrada de
trabalho não será executado. Você pode usar o verificação SMTP? checkbox aqui, se você deseja validar a existência das contas.
Tem mais...
Você vai encontrar mais recursos sobre o envio de e-mails nas seguintes subseções:
360
Capítulo 10
Você pode especificar um nível mais detalhado de log no loglevel listbox, se quiser. Então, você precisa incluir o arquivo como um arquivo
anexado. Dê um duplo clique sobre o o email entrada de trabalho, selecione o Arquivos anexados guia e selecione a Registro item no Escolha
um tipo de arquivo caixa de lista. Como você precisa selecionar tanto Geral e Registro itens, você tem que fazê-lo pressionando o Ctrl chave:
Depois de executar o trabalho, um e-mail ainda será enviado, mas desta vez, o arquivo zip anexado também conterá um novo arquivo
chamado LOGFILE.LOG com as informações de log.
361
Obtendo o máximo de Kettle
listboxes em vez de caixas de texto para se referir a diferentes configurações (endereços, configuração do servidor, assunto, corpo, e assim
por diante). Aqui você deve referir-se a campos existente em vez de digitá-los.
Em alguns casos, você pode usar o passo ou a entrada de trabalho com resultados semelhantes, mas há situações particulares
em que uma abordagem é melhor que o outro. Por exemplo:
f Se você precisar enviar um e-mail com algumas informações sobre o processo-for executado
exemplo, o tempo que levou para executá-lo, você deve usar o Enviar entrada de trabalho.
f Se você precisa enviar apenas um e-mail com arquivos anexados provenientes de diferentes empregos ou
f Para um exemplo avançado de usar o Enviar passo para a discussão, você pode seguir o dado
ligação: http://kjube.blogspot.com/2011/01/mailing-new-years-cards. html. O post no blog de KJube explica uma
transformação que envia os melhores desejos para o Ano Novo com uma lista de pessoas. As duas
considerações seguintes surgem sobre o exemplo fornecido: a transformação utiliza o Escritor Excel passo de
encaixe. Se você está trabalhando com Kettle 4.1, você deve instalar o plugin, a fim de abrir a transformação.
Isso não é o caso para Kettle 4.2, em que o plugin já está incluído como um Experimental degrau.
Quando você executa uma transformação ou um trabalho, tudo o que está acontecendo no processo é mostrado na resultados da
execução janela, que tem uma guia chamada Exploração madeireira onde você pode verificar a execução de sua etapa de
transformação a passo. Por padrão, o nível de detalhes de log é
Basic, mas você pode mudá-lo para mostrar diferentes níveis de detalhe. Debaixo de Exploração madeireira guia, você pode ver
informações sobre como o passo está realizando, por exemplo, o número de linhas vindo de etapas anteriores, o número de linhas
lidas, o número de linhas escritas, erros na execução, e assim por diante. Todos esses dados são fornecidos pelas etapas
automaticamente, mas que se você quer escrever suas mensagens personalizadas para o Exploração madeireira
em formação? Para fazer isso, há um passo e uma entrada chamada Escrever para registrar, no utilidade pasta.
362
Capítulo 10
Para colocá-los em prática, vamos dar uma transformação simples que lê um arquivo de texto com novidades livro e divide-os em
dois arquivos do Excel, dependendo do seu preço. O objetivo aqui é para incluir, no Exploração madeireira janela, mensagens
personalizadas sobre o número de entrada de livros e também como muitos desses livros são barato ou caro.
Preparando-se
Para verificar esta receita, você vai precisar de um arquivo de texto que inclui informações sobre novidades do título do livro. Por exemplo:
título; author_id; preço; title_id; gênero Bag of Bones; A00002; 51,99; Basket
Case Fiction;; 123-353 A00003; 31,00; 123-506; Fiction Carrie; A00002; 41,00;
123-346; Fiction Cashflow Quadrant; A00007; 55,00; 323-604; Negócios
Harry Potter eo Enigma do Príncipe; A00008; 61,00; 423-005; Childrens Harry Potter eo Prisioneiro de Azkaban;
A00008; 29,00; 423003; Childrens
Poder para o povo; A00005; 33,00; 223-302; Não-ficção Quem tomou meu dinheiro;
A00007; 21,00; 323-603; Negócios
2. Gota um entrada de arquivo de texto passo para a tela. Defina o arquivo a ser lido sob a Arquivo separador, e
tipo ; como o personagem Separador debaixo de Conteúdo aba. Finalmente, use o obter Campos
botão sob a Campos guia para preencher a grade automaticamente. Visualizando Nesta etapa, você irá obter os
dados dos livros do arquivo de texto. Agora, vamos adicionar os passos para contar os livros e escrever a
informação.
3. Adicione uma grupo de passo do Estatisticas pasta. Criar um hop a partir do arquivo de texto para
este passo. No agregados grade na parte inferior, adicionar um novo campo chamado Quant, escolher um campo
(por exemplo, title_id) no Sujeito coluna, e seleccionar o Número de valores (N) opção no Tipo coluna.
363
Obtendo o máximo de Kettle
5. A partir do utilidade pasta, adicionar um Escrever para log passo e criar um hop do anterior
passo no sentido de este; diga Escrever livros de contagem. Adicione o linha campo para o
Campos grade. Escolher log básico no nível de log listbox.
6. Execute a transformação usando log básico e verificar a Exploração madeireira guia para os resultados.
7. Você pode verificar as informações básicas de registro onde você deve ver a seguinte linha:
Agora, você vai gerar dois arquivos do Excel e escreva as informações sobre livros baratos e caros para o log:
1. Elimine um Filtrar linhas, dois saída de Excel, dois Agrupar por, dois UDJE, dois Bloquear este passo
até terminar passos ( de Fluxo categoria), e dois Escrever para log passos para a tela. A ligação das etapas,
como mostra a imagem a seguir:
2. Criar uma hop do entrada de arquivo de texto passo para o Filtrar linhas degrau. Aqui, definir o
condição Preço <= 50. Usaremos um preço arbitrário de US $ 50 para determinar se um livro é barato ou
caro.
3. Ponto um saída Excel passo nome de ficheiro para cheapBooks.xls, e usar o obter Campos
botão para preencher a grade sob a Campos aba.
4. No grupo de etapa, adicionar um novo campo chamado qty no agregados grade, escolha o campo title_id no Sujeito
coluna, e seleccionar o Número de valores (N) opção no Tipo coluna.
5. Adicionar um campo chamado linha do Corda Tipo no UDJE o passo com a seguinte
expressão Java:
6. No Bloquear este passo até que passos terminar etapas, selecione a etapa chamada livros de escrita contagem no nome
da etapa coluna da grade.
364
Capítulo 10
7. Finalmente, no Escrever para log etapa, adicione o linha campo para o Campos grade e escolha básico
exploração madeireira no nível de log listbox.
8. Agora, repita os últimos cinco etapas, a fim de configurar o fluxo menor. Desta vez, use o
saída Excel passo (chamado saída Excel 2) para gerar o expensiveBooks.xls
arquivo e substituir o texto Barato para Caro no outro UDJE degrau. Executando a transformação usando logging
Basic, você pode verificar se as mensagens personalizadas foram escritos no log sob o Exploração madeireira aba. Aqui está
um exemplo:
Como funciona...
O objetivo principal nesta receita é explicar como você pode escrever mensagens personalizadas para as janelas de registro.
A tarefa da transformação é simples-lê um arquivo de texto no início, utiliza uma Filtrar linhas passo para dividir a lista de livros
em mais baratos e caros, e, em seguida, escreve duas planilhas do Excel com esses detalhes.
Agora, vamos analisar a tarefa de personalizar o log. Na primeira parte da receita que você escreveu para o registro do número de
livros:
f finalmente, o Escrever para log passo escreve esta cadeia para o log
365
Obtendo o máximo de Kettle
Depois de cada um dos saída de Excel passos, não é a mesma sequência de passos ( por grupo, UDJE,
e Escrever para log), a fim de escrever uma mensagem com o número de livros baratos e o número de livros caros para o log. Há
também um Bloquear este passo até que passos terminar passo nesta sequência antes da Escrever para log degrau; isso é porque
você quer ter certeza de que o número total de livros serão escritos em primeiro lugar.
Tem mais...
Esta receita mostrou-lhe o caminho clássico para adicionar mensagens para o log. As subseções a seguir mostrar-lhe
algumas variantes ou abordagens alternativas.
Em vez de adicionar texto para o log, você pode querer filtrar texto no log existente. Se você selecionar a Exploração madeireira guia no resultados
da execução janela, você verá uma barra de ferramentas. Sob essa barra de ferramentas, existe um botão chamado definições do registo que
permite que você aplique um filtro. Se você digitar algum texto no Escolha um filtro caixa de texto, o log das execuções posteriores da
transformação só irá mostrar as linhas que contêm esse texto. Por exemplo, você poderia usar o mesmo prefixo texto em todas as suas
mensagens personalizadas e, em seguida, aplicar um filtro usando este texto fixo para ver apenas essas mensagens.
Isso também funciona se você executar a transformação de um emprego, e mesmo se você reiniciar colher porque o filtro é salvo
em um arquivo de configuração Chaleira.
Isso é válido apenas em colher. Se você pretende executar um trabalho ou uma transformação com Pan ou da cozinha e você precisa
filtrar um log, por exemplo, mantendo apenas as linhas que contêm certas palavras, então você tem que tomar uma outra abordagem.
Uma maneira para realizar isso seria para salvar o emprego ou log transformação em um arquivo e, em seguida, executar outra
transformação que analisa e filtros que LOGFile.
o Exploração madeireira janela mostra não só as suas mensagens, mas também todas as informações processadas pelos passos. Às vezes você
precisa de um arquivo de log limpo mostrando apenas suas mensagens personalizadas e descartando o resto.
Há um outro problema relacionado a isso, quando você configurar o Escrever para log etapa, você precisa especificar um nível para o seu
log. (Na receita, você usou logging Basic.) Se você executar sua transformação usando um nível de log diferente, você não vai ver nenhuma
de suas mensagens personalizadas. Uma alternativa seria utilizar um saída de arquivo de texto ao invés de Escrever para log degrau. Com
isso, você vai produzir um novo arquivo de texto com apenas as mensagens desejadas. Certifique-se de apontar toda a
saída de arquivo de texto passos para o mesmo nome de ficheiro sob o Arquivo guia, e usar o Acrescentar sob a caixa Conteúdo guia, a
fim de evitar substituindo o arquivo com cada execução.
366
Capítulo 10
É possível que você quiser ver diferentes níveis de log, dependendo do trabalho ou transformação, ou que simplesmente querem isolar o log
para um trabalho ou transformação particular. Esta é uma tarefa simples de realizar. No trabalho principal, clique com o botão direito sobre o Trabalho
ou Transformação entrada de interesse; debaixo de configurações de log guia verificar o Especificar arquivo de log? opção e você será capaz de
especificar um nome para o arquivo de log, bem como o nível de log desejado. Desta forma, você pode criar diferentes arquivos de log com
diferentes níveis de log para cada um dos empregos e transformações que fazem parte de seu trabalho principal.
Veja também
Para esta receita, vamos executar alguns comandos básicos do shell em outro servidor e retornar os resultados. Há duas
formas de executar comandos, um via o trabalho e outro através da transformação. Esta receita vai mostrar um exemplo
de ambos.
Preparando-se
Enquanto nós estamos mostrando passos que podem se conectar a outros servidores com esta receita, estaremos
executando comandos localmente. O processo é praticamente idêntico, com a excepção de que os parâmetros de ligação irá
ser diferente. Contanto que você pode conectar-se a caixa e tem permissões para executar o script escrito no passo, o
processo deve ser executado.
367
Obtendo o máximo de Kettle
7. Salvar e executar o trabalho. Verificando a saída de log, você deve ver a saída do eco, o que deve ser
semelhante ao seguinte:
Agora vamos utilizar a etapa de transformação para executar um script via SSH:
3. Criar uma hop do comandos SSH executados passo para o Escrever para log degrau.
2. Porta do servidor: 22
3. Tempo esgotado: 0
368
Capítulo 10
6. Mude para o Definições aba. Digite os seguintes comandos para o comandos caixa de texto:
7. Clique em ESTÁ BEM. Abra o Escrever para log passo e adicione o stdOut campo para o Campos grade.
8. Clique em ESTÁ BEM. Salvar e executar a sua transformação. Seu log deve saída o valor
do TEST_VAR parâmetro:
Como funciona...
Enquanto os executar scripts para esta receita são bastante simples, não há nada impedindo scripts ou programas mais complicados
que está sendo executado por estas etapas. A corrida transformação comandos SSH etapa também permite parâmetros ou um
script criado dentro do fluxo a ser executada. Isto irá permitir a shell scripts dinâmicos para ser executado com base nos dados estão
a ser enviados através do processo de integração de dados normal.
Veja também
Em Chaleira, você tem um monte de funcionalidade fornecida pelos passos internos, mas se isso não for suficiente para você, há um
passo chamado Definido pelo usuário Java Class onde você pode programar funcionalidade personalizada com código Java. Desta
forma, você pode realizar tarefas complexas, bibliotecas Java de acesso, e até mesmo acessar a API Chaleira. O código que você digita
para este passo é compilada uma vez e executado em tempo de execução para cada linha que passa. Vamos criar um exemplo simples
do uso do UDJC degrau. Suponha que você tenha um arquivo de texto contendo frases; você deseja contar as palavras em cada linha e
dividir o fluxo de dados em dois fluxos, dependendo do número de palavras por frase.
369
Obtendo o máximo de Kettle
Note-se que, a fim de desenvolver um exercício mais interessante, nós adicionamos algumas considerações extras, como
segue:
Preparando-se
2. Gota um entrada de arquivo de texto passo do Entrada categoria. Navegue até o arquivo sob o arquivos
guia, e clique no Adicionar botão para preencher a grade de arquivos selecionado. Por exemplo:
$ {Internal.Transformation.Filename.Directory} \ samplefile.txt
5. Adicione uma UDJC passo do Scripting categoria. Além disso, soltar dois Manequim passos da
Fluxo categoria e nomeá-los: frases curtas passo e penas de longa duração degrau.
370
Capítulo 10
8. Sob o Campos guia da grade inferior, adicionar um novo campo chamado Quant. selecionar número inteiro em
a Tipo listbox.
if (primeiro) {
primeiro = false;
shortSentences = findTargetRowSet ( "shortOnes"); longSentences =
findTargetRowSet ( "longOnes"); }
LineIn = get (Fields.In, "linha") getString (r.); longo len = linein.length ();
longo Quant = 0;
371
Obtendo o máximo de Kettle
return true; }
O fragmento de código adicionado com o a Principal artigo gera uma linha com esta linha:
r = createOutputRow (r, outputRowSize); Esta linha deve ser substituído com o código
12. Este código adiciona a funcionalidade desejada. Se você visualizar esta etapa, você irá obter um novo campo chamado qty com
o número de palavras em cada frase. Os resultados para o arquivo usado como um exemplo seria:
372
Capítulo 10
13. Este UDJC etapa também redireciona as linhas para o frases curtas o passo ou o longo
frases passo dependendo do campo Quant. Você pode visualizar as duas etapas e verifique se as frases com
exatamente sete ou mais de sete palavras fluirão para a penas de longa duração a etapa, e aqueles com menos
palavras fluir para o frases curtas degrau.
Como funciona...
O primeiro passo para a receita tem a tarefa de ler o arquivo de texto. Você usou ##### como caracteres de separação,
porque essa seqüência não está presente no arquivo. Isso garante que o campo linha irá conter toda a linha de seu arquivo.
Agora, você precisa desenvolver um código personalizado que conta as palavras no linha campo. Esta tarefa não pode ser realizada
utilizando passos Chaleira padrão, para que você tenha programado a funcionalidade necessária em código Java dentro de um UDJC degrau.
Vamos explorar o diálogo para a UDJC
passo, o qual é mostrado na imagem seguinte:
A maior parte da janela é ocupado por área de edição. Aqui você escrever o código Java usando a sintaxe padrão de que a
linguagem. No lado esquerdo, há um painel com muitos fragmentos de código prontos a usar ( Partes de codigo), e uma seção com
jogos e fica para os campos de entrada e saída. Para adicionar um fragmento de código ao seu script de um duplo-clique nele,
arraste-o para o local em seu script onde você deseja usá-lo, ou simplesmente digitá-lo na área de edição. o Entrada e saídas campos
aparecem automaticamente na árvore quando o código Java compila corretamente; você pode usar o classe de teste botão para
verificar se o código está escrito corretamente. Se ocorrer um erro, você verá uma janela de erro; caso contrário, você será capaz de
visualizar os resultados da etapa de transformação.
373
Obtendo o máximo de Kettle
o Campos guia na parte inferior é declarar os novos campos adicionados pelo passo. Neste caso, você declarou o campo qty do
número inteiro tipo. Este campo será a variável de saída que irá retornar a contagem de palavras. Debaixo de etapas alvo guia,
você pode declarar os passos onde as linhas serão redirecionadas. Na receita, você apontou para os dois alvo Manequim passos;
um para as frases curtas, e outro para os longos. Vamos ver o código Java em detalhe.
Estas variáveis irão representar as duas possíveis etapas alvo. Eles são declarados no início, porque, desta
forma, eles mantêm seus valores entre o processamento de linha. Então, você tem a função principal:
o processRow () função processa uma nova linha. o getRow () função obtém a próxima linha a partir dos passos de entrada.
Devolve uma matriz objecto com a linha de entrada. UMA nulo valor significa que não há mais linhas para processamento. O
if (primeiro) {
primeiro = false;
shortSentences = findTargetRowSet ( "shortOnes"); longSentences =
findTargetRowSet ( "longOnes"); }
Você pode usar o sinalizador primeiro para preparar um ambiente adequado antes de processar as linhas. Neste caso,
você define os passos alvo em duas variáveis para uso posterior. O próximo código usa a pegue() método para definir a
374
Capítulo 10
Ele analisa a frase inteira procurando caracteres utilizados como separadores. Se um desses separadores é encontrado,
então ele vai incrementar o qty variável por um e definir o sinalizador
currentSpecialChar para verdade, a fim de não aumentar o valor se o próximo personagem é também um separador.
A próxima linha é contar a última palavra da frase somente se ele não foi contado no ciclo principal:
se qty ++ (currentSpecialChar!);
Aqui nós definir o novo campo chamado qty com o valor da variável interna Quant, que tem a contagem de palavras:
Finalmente, se a contagem de palavras é inferior 7 ( um valor arbitrário), em seguida, a linha será passada para o
frases curtas degrau; caso contrário, o alvo será o penas de longa duração degrau:
if (qty <7) {
putRowTo (data.outputRowMeta, R, shortSentences); } outro {
return true; }
375
Obtendo o máximo de Kettle
Se você tiver apenas um passo alvo, então você pode usar o mais simples putRow
() método.
Tem mais...
Para saber mais sobre a sintaxe da linguagem Java, visite o seguinte URL:
http://download.oracle.com/javase/tutorial/.
Como mencionado anteriormente, você pode acessar a API Chaleira de dentro do código UDJC. Para saber os
detalhes da API, você deve verificar a fonte. Para obter instruções sobre como obter o código, siga o link: http://community.pentaho.com/getthecode/.
Para saber mais sobre o passo UDJC, visite o Wiki Pentaho Comunidade em
http://wiki.pentaho.com/display/EAI/User+Defined+Java+Class.
Vamos ver mais algumas informações para aproveitar este passo muito útil.
O oposto ocorre quando você cria um objeto dentro do código Java e quero expô-la como um novo campo para a sua
transformação. Por exemplo, no código Java, você definiu a variável qty
Como longo mas sob a Campos guia, você definiu o novo campo de saída como Integer.
grade localizada sob o parâmetros aba na parte inferior do UDJC janela. Em nosso exemplo, você poderia ter definido um
376
Capítulo 10
Em nossa receita, suponha que você tem a lista de separadores definidos em um Grade de dados degrau. A fim de escolher
os separadores de lista, você tem que criar um hop do Grade de dados
em direção ao UDJC passo e preencha o etapa informações grade. Você deve fornecer um etiqueta nome (por exemplo,
charsList) e selecione o nome da etapa de entrada. Em seguida, no código Java, você pode usar o findInfoRowSet () método
para fazer referência a informação passo, eo getRowFrom () método para ler as linhas em um ciclo. Verifique o código:
Personalizando registros
Você pode adicionar suas mensagens personalizadas para diferentes níveis de log muito facilmente. Você pode selecionar o
fragmento de código necessário a partir do log passo nó na Partes de codigo pasta, ou apenas digitar o método na área de edição.
Por exemplo:
Para exemplos de como usar este passo, procurar as diferentes receitas do livro.
Há vários exemplos que utilizam o UDJE degrau.
Se você está mais familiarizado com a linguagem JavaScript, em vez de UDJC você poderia usar o Modificada Java Script Valor
(MJSV) degrau. Leve em conta que o código no JavaScript passo é interpretada, de encontro UDJC que é compilado; isto significa
que uma transformação que utiliza o
UDJC etapa terá um desempenho muito melhor. A interface do usuário para o MJSV passo é muito semelhante à interface do usuário
para o UDJC degrau; há uma área principal para escrever o código JavaScript, um painel da esquerda com muitas funções como
fragmentos, os campos de entrada provenientes da etapa anterior, e os campos de saída. Você pode aprender mais sobre
JavaScript no seguinte link: http://www.w3schools.com/ js. Como um recurso adicional, é possível obter 3,2 Pentaho Data Integration:
Guia do Iniciante, Publishing Packt por María Carina Roldán. Existe um capítulo completo dedicado ao uso da Modificada Java Script
Valor degrau.
377
Obtendo o máximo de Kettle
Finalmente, se você preferir scripting para a programação Java, existe um plugin chamado Kettle rubi Scripting desenvolvido
por Slawomir Chodnicki, um dos colaboradores mais ativos Chaleira. Como o nome sugere, o passo permite-lhe
desenvolver funcionalidades customizadas por scripts de código Ruby. A UI para o plugin Ruby é muito semelhante à
interface do usuário para o UDJC degrau. Neste caso, você não tem trechos, mas você tem muitas transformações de
exemplo que demonstram as capacidades do plugin. Junto com as amostras, você tem um par de links para recursos de
Ruby na web. O plugin está disponível no seguinte URL: https://github.com/type-exit/RubyScripting-for-Kettle.
Tomar um subconjunto a partir de um grande volume de dados. Nesta receita, você vai aprender como gerar um conjunto de dados com 100
linhas aleatórias em diferentes formatos (integer, string e datas). Em seguida, no
Tem mais seção, você vai encontrar soluções alternativas para a geração de dados para teste.
2. Gota um gerar linhas passo do Entrada categoria. Aqui, definir o Limite caixa de texto
para 100.
3. Adicione uma Gerar valor aleatório passo do Entrada categoria. Adicionar dois elementos para a
grade: randomInteger do inteiro aleatório tipo, e randomString do seqüência aleatória tipo.
4. Fazer uma prévia desta última etapa, você obterá uma lista de 100 seqüências aleatórias e inteiros. Um
exemplo destes valores seriam: 1925608989 ( número inteiro) e
1jhn0udelvmpe ( corda)
378
Capítulo 10
Todos os valores inteiros têm um grande número de dígitos. E se, por algum motivo particular, você quer um inteiro com poucos dígitos ou
um número inteiro em um intervalo específico de valores? Vamos criar um número inteiro aleatório de outra maneira:
1. Elimine a User Defined Expressão Java de Scripting categoria. Adicionar um novo campo
nomeado Inteiro curto e digite o seguinte texto no expressão Java coluna:
(Int) Math.floor (Math.random () * 3650). Além disso, selecione número inteiro no tipo de valor coluna.
2. Faça uma pré-visualização e verificar o novo Inteiro curto campo; ele terá valores entre
0 e 3649.
Agora, vamos fazer um truque simples para criar uma data aleatória:
1. Na sua Campo' s grade do gerar linhas passo, criar um novo campo chamado um encontro, selecionar
Encontro no Tipo listbox, uso MM / dd / aaaa Enquanto o Formato, e tipo 01/01/2000 no Valor coluna.
2. Adicione uma Calculadora passo do Transformar categoria e completar a grade, como mostrado
na imagem seguinte:
3. Finalmente, se você executar uma previsão sobre esta última etapa, você terá seus valores aleatórios desejados em diferentes
formatos. Veja a imagem seguinte, como exemplo:
379
Obtendo o máximo de Kettle
Como funciona...
Nesta receita você aprendeu o uso da Gerar valor aleatório passo, a fim de gerar valores inteiros e cadeia
aleatória. o gerar linhas passo no início tem a finalidade de gerar 100 linhas em branco, que serão preenchidas
mais tarde com valores aleatórios. Você pode variar o
Limite caixa de texto se você desejar um número diferente de linhas.
Além disso, você usou a função aleatória dentro de uma expressão Java, a fim de gerar um inteiro curto, tirando partido da User
Defined Expressão Java degrau. Desta forma, você também pode definir o intervalo para os seus números aleatórios. Observe
que, na gerar linhas etapa, você declarou um novo campo chamado um encontro com o valor 01/01/2000. Esta data será então
utilizada na Calculadora degrau. Você gerou uma data aleatória usando um cálculo que adiciona um número inteiro aleatório
para a data original 01/01/2000.
O número inteiro tem um valor entre 0 e 3649, o que representa cerca de 10 anos, por isso a data
aleatória será entre 01/01/2000 e 28/12/2010.
Tem mais...
Nas subseções seguintes você vai encontrar mais maneiras de gerar dados para testar em outros cenários.
f meta: Sob este guia, você adicionar os campos e definir o seu tipo e formato. Você pode
definir campos usando qualquer um dos tipos de dados chaleira.
f Dados: Sob este guia, você pode inserir os valores para os campos definidos anteriormente. Este passo é muito útil quando você
precisa para preencher uma lista curta de linhas com campos particulares e / ou valores, evitando assim a criação de um arquivo de
380
Capítulo 10
Vejamos um exemplo prático do uso de Grade de dados. Suponha que você tenha criado uma expressão regular e quer ter certeza
de que está escrito corretamente, você pode preencher uma grade de dados com um único Corda campo. Como valores, pode
escrever a lista de valores contra os quais você quer testar a expressão regular, incluindo valores que deve coincidir com a
expressão e valores que não deveria. Depois de Grade de dados, basta adicionar um Avaliação regexp passo, digite a expressão
regular, e fazer uma prévia sobre este passo. Essa é uma maneira muito fácil e rápido de testes com a ajuda de um Grade de dados.
Em muitas ocasiões, você tem que desenvolver transformações que irá processar grandes volumes de informações. No entanto,
trabalhar com esse volume durante o processo de desenvolvimento não é uma boa idéia, ele retarda o seu processo de
desenvolvimento, e faz testes que você está fazendo difícil. É melhor trabalhar com uma pequena amostra do que a informação.
Há uma etapa chamada amostragem Reservoir no Estatística pasta que lhe permite devolver um subconjunto do seu fluxo de
entrada. Nesta etapa, você deve definir o número de linhas para entrar no
O tamanho da amostra caixa de texto, e também definir o semente aleatória, usado internamente no passo de produzir uma amostra
aleatória de seus dados. Na mesma categoria, você pode encontrar o linhas de amostra degrau. Esta etapa também gera um subconjunto
do seu fluxo de entrada, mas, neste caso, as linhas não são escolhidos de forma aleatória, você deve especificar o intervalo como
Veja também
JavaScript Object Notation (JSON) é um formato de intercâmbio de dados independente de linguagem leve. Ele usa
convenções semelhantes às linguagens C ou JavaScript, com algumas regras para a representação de dados estruturados. O
objecto é representado como uma colecção da
name_of_field: value_of_field pares e você pode ter uma matriz desses elementos usando os caracteres [].
PDI permite ler e escrever esses tipos de arquivos usando o input JSON e saída JSON
passos da Entrada categoria. Vamos ver um exemplo de leitura de um arquivo JSON. Vamos supor que você tenha um arquivo
chamado museums.js que você quer ler para posterior processamento. O arquivo tem as seguintes informações:
{ "dados": {
"Museu": [{
381
Obtendo o máximo de Kettle
Preparando-se
Para executar esta receita, você precisa do museums.js arquivo com as informações museu mostrado anteriormente. Você também pode
baixar o arquivo do site da Packt.
3. Digite o nome do arquivo com seu caminho completo no Arquivo ou diretório caixa de texto
localizado sob o Arquivo guia, por exemplo, $ { Internal.Transformation. Filename.Directory} \
museums.js. Clique no Adicionar botão.
382
Capítulo 10
5. Pré-visualizar a transformação, você vai obter um conjunto de dados com as informações museu do museums.js arquivo
de origem JSON.
Como funciona...
o input JSON etapa lê e interpreta o museum.js JSON dados usando o Caminho coluna sob o arquivos aba. Aqui, você deve usar
uma expressão JSONPath, de uma forma semelhante à forma como as expressões XPath são usados em arquivos XML. Uma
visão geral dos elementos de sintaxe JSONPath é mostrada na tabela seguinte:
JSONPath Descrição
$ objeto raiz
. operador de criança
[] operador de matriz
O operador criança é usado para aceder a diferentes níveis no interior da estrutura JSON, por exemplo,
$ ... cidade significa que o cidade no interior do elemento museu no interior do elemento dados elemento a partir da raiz.
Se você quiser acessar um elemento particular, você deve usar $. data.museum [1] .city, significa que o cidade do
segundo museu no interior do elemento dados elemento a partir da raiz.
Tem mais...
Você pode encontrar mais informações sobre a linguagem JSON no seguinte URL:
http://www.json.org/.
Nas subseções seguintes você vai encontrar algumas considerações sobre a leitura e escrita de arquivos JSON.
383
Obtendo o máximo de Kettle
Outra opção é quando o nome do arquivo JSON é em um campo. Neste caso, em vez de digitar o nome do arquivo,
você deve verificar tanto o Fonte é definido em um campo? e Fonte é um nome de arquivo? caixas e selecione o campo
que contém o nome do arquivo JSON na Obter fonte do campo listbox.
Se você precisa criar um arquivo ou um campo em formato JSON, você pode usar o saída JSON passo do Saída categoria. Debaixo
de Geral guia desta etapa, há uma caixa de listagem com o nome Operação
onde você pode escolher um arquivo ou destino campo. Se você escolher um destino de arquivo, você precisa preencher o Arquivo
de saída seção com informações sobre o arquivo a ser gerado. Se você escolher o valor de saída operação, você deve digitar o
nome do novo campo no Valor de saída caixa de texto. Então, sob a Campos guia, você precisa preencher a grade com os campos
de origem provenientes da fonte de dados e o nome do elemento para a estrutura JSON. Por exemplo, suponha que você está
usando uma fonte de dados com informações dos autores como o seguinte:
"Riordan", "Rick", "American", de 1964. Se você adicionar um saída JSON e um passo valor de saída
operação, você vai obter um novo campo com cada linha em formato JSON, com um valor, como segue:
384
Capítulo 10
As transformações e empregos são arquivos com. ktr e. kjb extensões, mas são, na verdade, bem formado documentos XML. Você
pode abrir esses arquivos com um editor de texto para ver as suas estruturas. Você poderia tirar proveito desse recurso para
processar algumas informações dentro desses arquivos. Vejamos um exemplo: suponha que você deseja procurar o Modificada
Java Script Valor passos. Você quer saber onde e como muitos desses passos estão lá porque você quer substituí-los com um definida
pelo usuário Java Class passo, o que proporciona um melhor desempenho.
Preparando-se
Para utilizar esta receita, você precisa de um diretório com um conjunto de transformações, algumas delas incluindo o Modificada
Java Script Valor passos. O exemplo aponta para o diretório transformação amostra Chaleira.
385
Obtendo o máximo de Kettle
6. Sob o campos de saída adicionais guia, tipo nome do arquivo no filename curta campo.
7. Se você visualizar esta etapa, você irá obter uma lista de todas as etapas do diretório de origem transformações,
incluindo informações sobre o tipo de passo é ele. Aqui está um exemplo:
8. Adicionar uma Filtrar linhas passo de Fluxo categoria. Adicionar a seguinte condição:
type = ScriptValueMod.
386
Capítulo 10
9. Agora, visualizar o passo, você irá obter apenas o nome do Java Script modificado
Valor passos incluídos nas transformações, bem como os nomes dos ficheiros de transformação em que estas etapas foram
encontrados.
Como funciona...
Nesta receita, você usou o Obter dados de XML passo para ler os arquivos de transformação localizadas no diretório C: \
Pentaho \ PDI-ce-4.1 \ \ amostras transformações. Ao utilizar o / transformação / etapa nó XPath, você está recebendo uma nova
linha para cada passo nas transformações. Como campos, você colhidos a partir desse nó o nome do passo e seu tipo.
Em seguida, você usou um Filtrar linhas passo para manter apenas as linhas onde o tipo de passo foi igual a ScriptValueMod.
Isso significa que, a Modificada Java Script Valor passos. No Obter dados de XML etapa, você também incluiu o nome de
arquivo curto da transformação porque você quis identificar o arquivo de origem das transformações que tiveram esses
passos.
387
Obtendo o máximo de Kettle
Tem mais...
A seguir estão alguns dos nós mais importantes nos arquivos XML de transformação e de emprego. Com esses nós, você pode
percorrer os postos de trabalho e transformações que você criou para obter detalhes específicos sobre todo o repositório de
processos (como o que fontes de dados são usados, que medidas são usadas em que processa, e assim por diante) .Os tabela a
seguir lista os nós XML comuns para transformações.
LoopXPath Em formação
/ Transformação / info Um nó para cada arquivo de transformação. Aqui, você tem o nome
ea descrição da transformação, seus parâmetros, ea criação data
entre outros.
/ transformação / blocos A partir daqui você pode obter os cadernos.
/ Transformação / info / log Você pode obter informações sobre a configuração de log
transformação.
/ Transformação / conexão Um nó para cada conexão de banco de dados usado na
transformação (ou um para cada conexão de banco de dados definido, se
você não verificar o salvar apenas conexões usadas para XML? opção)
/ Transformação / step / arquivo Um nó para cada arquivo ou pasta apontada a partir de uma etapa. Ele inclui
dados sobre o nome do arquivo ou pasta, a máscara digitado, subpastas, e
assim por diante.
/ Transformação / ordem / hop Um nó para cada hop. Aqui você tem as ligações entre as
etapas.
388
Capítulo 10
LoopXPath Em formação
/trabalho Um nó para cada trabalho. A partir daqui, você pode obter o nome do trabalho e
os parâmetros entre outras coisas.
/ Trabalho / conexão Um nó para cada conexão de banco de dados usado no trabalho (ou um para cada
conexão de banco de dados definido se você não verificar o salvar apenas
conexões usadas para XML? opção)
entrada Um nó para cada entrada de trabalho. Você pode olhar aqui para o
nome das entradas, o seu tipo e todo os campos de configuração para
as entradas.
/ Trabalho / lúpulo / hop Uma entrada para cada ligação entre entradas de trabalho.
389
Obtendo o máximo de Kettle
o identidade coluna representa a identificação de passos, o Nome coluna é como ele aparece em
Colher, e a Descrição coluna é a dica. Você também pode ver a categoria da etapa na coluna categoria. Na receita, você
comparou a tipo campo na transformação contra o identidade coluna na lista. o Trabalho Informações para a entrada ... opção
Veja também
Preparando-se
Para executar esta receita, você deve ter um repositório Chaleira e um conjunto de transformações armazenados nele. Se você não
tem uma lista de transformações de exemplo para brincar, então você pode se conectar ao repositório e importá-los a partir do
diretório amostras PDI.
390
Capítulo 10
5. Pré-visualizar esta etapa, você irá obter um conjunto de dados com uma linha para cada Java modificado
Valor Script degrau. Neste conjunto de dados, você tem o nome da transformação (no
transformation_name campo) e o nome da etapa de Java script (no STEP_NAME
campo). Esta lista irá variar de acordo com as transformações armazenados no repositório.
Como funciona...
Esta receita mostra como ler as tabelas de transformação quando você está trabalhando com uma configuração baseada em
repositório.
A única coisa a fazer aqui é criar uma conexão com o banco de dados onde você tem o repositório e escrever a
instrução SQL correta. Neste caso, você deve ler a tabela que contém os passos ( R_STEP) e filtrar aqueles que
combinam um Modificada Java Script Valor degrau ( R_STEP_TYPE.CODE = 'ScriptValueMod'). Se você abrir o R_STEP_TYPE
tabela, então você pode ver a lista de passos e verifique se o ScriptValueMod código corresponde a um
A instrução SQL também inclui uma junção com a R_TRANSFORMATION mesa, a fim de obter o nome da
transformação.
Tem mais...
Um repositório Kettle é composta de várias mesas onde as lojas Chaleira todas as informações relacionadas com as transformações e
empregos. As próximas subseções explicar as mesas mais significativos foram encontrados em um repositório.
391
Obtendo o máximo de Kettle
tabelas de transformação
Estas tabelas armazenar as informações sobre arquivos de transformação chaleira da passos e saltos que fazem a transformação para
cima, para as notas que os desenvolvedores foram adicionados para referência futura.
R_STEP_ATTRIBUTE
ID_STEP_ATTRIBUTE: BIGINT [PK]
VALUE_STR: LONGVARCHAR
VARCHAR (255) [AK] VALUE_NUM: BIGINT
INTEGER [FAK] NR: INTEGER [AK] CÓDIGO:
ID_TRANSFORMATION: INTEGER [FK] ID_STEP:
(255) R_STEP_TYPE
VARCHAR
VARCHAR (255) HelpText:
(255) BIGINT
ID_STEP_TYPE: DESCRIÇÃO:VARCHAR
[PK] CÓDIGO:
[PK] R_TRANSFORMATION
TIMESTAMP
VARCHAR : INTEGER
(255)
CREATED_DATE: ID_TRANSFORIvIATION:
MODIFIED_DATE:
TIMESTAMP SIZE_ROWSET
MODIFIED_USER: BIGINT
CREATED_USER
OFFSET_MAXDATE: DUPLO:
FIELD_NAME_IvIAXDATE: VARCHAR
DIFF_MAXDATE (255)
DUPLO: (255)
INTEGER
USE_LOGFIELD: CHAR
VARCHARID_STEP_UPDATE: (1)VARCHAR
TABLE_NAME_MAXDATE:
(255) USE_BATCHID:
ID_DATABASE_LOG:
INTEGER INTEGER CHAR(255)
VARCHAR
ID_DATABASE_MAXDATE:
(1)
TABLE_NAME_LOG:
INTEGER
INTEGER ID_STEP_INPUT:
ID_STEP_READ:
TRANS_VERSION: VARCHAR
EXTENDED_DESCRIPTION: INTEGER
INTEGER ID_STEP_OUTPUT:
ID_STEP_WRITE:
(255)VARCHAR
TRANS_STATUS:
LONGVARCHAR
(1 )CÓPIAS:
R_STEP Integer INTEGER DESCRIÇÃO:
ID_DIRECTORY:LONGVARCHAR
INTEGER NOME: (255)
GUI_LOCATION_Y:
(1)
ID_STEP: AIPT: [FK]GUI_DRAVV:
GUI_LOCATION_X: CHAR
INTEGER
VARCHAR (255)INTEGER
TRANSFORMAÇÃO:
ID_STEP_TYPE: DESCRIÇÃO: DISTRIBUIR:
[FK] NOME: CHAR
[PK] IDLONGVARCHAR
INTEGER
BIGINT
CHAR (1) ID_NOTE: BIGINT [PK] INTEGER
FONT_BORDER_COLOR_BLUE:
FONT_BORDER_COLOR_GREEN: R_NOTE
INTEGERDRAW_SHADOW:
FONT_BORDER_COLOR_RED:
FONT_BACK_GROUND_COLOR_BLUE:
FONT_BACK_GROUND_COLOR_GREEN: INTEGERINTEIRO
INTEGER
INTEGER FONT_BACK_GROUND_COLOR_RED:
FONT_COLOR_GREEN:
FONT_ITALIC: CHAR (1) INTEGER INTEGER
FONT_COLOR_BLUE:
FONT_COLOR_RED: INTEGER
LONGVARCHAR FONT_SIZE:
GUI_LOCATION_HEIGHT:
GUI_LOCATION_Y: INTEGER INTEGER
INTEGER FONT_BOLD:
FONT_NAME:
GUI_LOCATION_WIDTH: CHAR (1)
INTEGER
VALUE_STR: LONGVARCHAR GUI_LOCATION_X: INTEGER
Mesa Em formação
R_ Aqui temos a informação básica para a transformação, tal como o nome de transformação
TRANSFORMAÇÃO ou sua data de criação.
R_STEP Um registro para cada etapa. Você pode obter o nome da etapa e da identificação do
seu tipo.
R_STEP_TYPE A lista de tipos de etapa. Aqui você pode obter o nome, a descrição, e a dica de ferramenta para
cada tipo de passo
R_TRANS_HOP Um registro para cada hop. Ele fornece a informação relacionada com a ligação entre as etapas.
R_STEP_ Configurações para a etapa. Cada característica que você definir em uma etapa é salvo nas
ATRIBUÍDO colunas CÓDIGO e VALUE_NUM Se o recurso é um número, ou
CÓDIGO e VALUE_STR de outra forma. Por exemplo, se o passo representa o nome de um arquivo,
então você terá CÓDIGO = nome de ficheiro e
VALUE_STR = c: /files/sample.xls
R_TRANS_NOTE Aqui estão as notas da transformação. Há um campo de identificação nota ligada à
mesa R_NOTE, onde você tem a descrição da nota.
392
Capítulo 10
mesas de trabalho
Tal como acontece com as tabelas de transformação listadas na seção anterior, as mesas de trabalho listar os detalhes dos empregos criados
dentro de Kettle.
LONGVARCHAR
VALUE_NUM: R_IOBENTRY_ATTRIBUTE
DUPLA VALUE_STR:
INTEGER
INTEGER [AK] CÓDIGO: VARCHAR
[FK] ID_IOBEBTRY: (255)[FK]
INTEGER [AK]NR: R_JOB_NOTE
ID_IOBENTRY_ATTRIBUTE: BIGINT [PK] ID_IOB:
ID_NOTE: INTEIRO [FK]
ID_JOB: INTEIRO [FK]
SHARED_FILE:
PASS_BATCH_ID:
TIMESTAMP
MODIFIED_USER:
VARCHAR (255)VARCHAR
CHAR
USE_BATCH_ID:
VARCHAR(1)(255)
CREATED_DATE: R_JOB
USE_LOGFIELD:
CHAR
(255 (1)
)TIMESTAMPCHAR (1)
MODIFIED_DATE:
ID_DATABASE_LOG:
JOB_VERSION:
VARCHAR
ID_JOB: (255)VARCHAR
EXTENDED_DESCRIPTION:
BIGINT VARCHAR
DESCRIÇÃO:
[PK] (255) (255) CREATED_USER:
JOBSTATUS:
LONGVARCHAR
LONGVARCHAR
ID_DIRECTORY: INTEGERINTEGER
NOME:
LONGVARCHAR
NOME: VARCHARR_JOBENTRY
(255) DESCRIÇÃO:[FK]
[FK] ID_JOBEBTRY_TYPE:
ID_JOBENTRY: BIGNT [PK]INTEGER
ID_JOB: INTEGER
(255) R_JOBENTRY_TYPE
VARCHAR (255) DESCRIÇÃO: VARCHAR
ID_JOBENTRY_TYPE: BIGINT [PK] CÓDIGO:
(1)
CHARR_JOB_HOP
(1) Avaliação: CHAR (1) UNCONDITIONAL: CHAR
ID_JOBENTRY_COPY_TO:
ID_JOBENTRY_COPY_FROM: INTEGER [FK][FK]
INTEGER activada:
ID_JOB_HOP: BIGINT [PK] ID_JOB: INTEGER [FK]
Mesa Em formação
R_JOB Informações básicas sobre o trabalho. Por exemplo, o seu nome ou data de criação.
R_JOBENTRY Um registro para cada entrada de trabalho. Aqui você tem o nome e o tipo das entradas de
trabalho.
R_JOBENTRY_ATTRIBUTE Configurações para a etapa. Cada característica que você definir em uma etapa é
393
Obtendo o máximo de Kettle
R_DATABASE_CONTYPE
VARCHAR (255) DESCRIÇÃO: VARCHAR (255)
ID_DATABASE_CONTYPE: BIGINT [PK] CÓDIGO:
R_JOBENTRY_DATABASE
ID_DATABASE: INTEGER [FK]
INTEGER ID_JOBENTRY: INTEGER [FK]
LONGVARCHAR R_JOBENTRY ID_JOB:
R_DATABASE
VARCHAR
VARCHAR (255)
ServerName: INDEX_TBS:
VARCHAR
(255) SENHA: (255) VARCHAR
DATA_TBS:
VARCHAR (255 (255) NOME: VARCHAR (255) DESCRIÇÃO:
HOST_NAME: PORT: INTEGER
VARCHAR
ID_DATABASE_CONTYPE:
ID_DATABASE_TYPE:
ID_DATABASE: (255)
[PK]INTEGER
BIGINTINTEGER [FK]
NOME: [FK])
usuário:
DATABASE_NAME:
VARCHAR (255)
INTEGER ID_JOBENTRY_TYPE: INTEGER
ID_JOBENTRY: BIGINT [PK] ID_JOB:
R_DATABASE_TYPE
DESCRIÇÃO: VARCHAR (255)
BIGINT [PK] CÓDIGO : VARCHAR (255)
CHAR (1) R_STEP ID_DATABASE_TYPE:
GUI_LOCATION_Y: INTEGER GUI_DRAW:
GUI_LOCATION_X: INTEGER
DISTRIBUIR: CHAR (1) CÓPIAS: Integer
LONGVARCHAR ID_STEP_TYPE: INTEGER
VARCHAR (255) DESCRIÇÃO:
INTEIRO [FK] R_STEP_DATABASE ID_TRANSFORMATION: INTEGER NOME:
ID_STEP: INTEIRO [FK] ID_DATABASE: ID_STEP: BIGINT [PK]
R_DATABASE_ATTRIBUTE ID_TRANSFORMATOIN: INTEGER
(255) [AK] VALUE_STR:
ID_DATABASE: INTEGERLONGVARCHAR
[FAK] CÓDIGO:
ID_DATABASE_ATTRIBUTE: BIGINT [PK] VARCHAR
Mesa Em formação
R_DATABASE Aqui temos as configurações para as conexões de banco de dados usados nos
passos ou entradas
R_STEP_DATABASE Um registro para cada etapa que usa uma conexão de banco de dados. Ela liga o passo
com a identificação de banco de dados.
R_JOBENTRY_DATABASE Um registro para cada trabalho de entrada que usa uma conexão de banco de dados.
R_DATABASE_TYPE Lista de motores de banco de dados. Por exemplo, MySQL, Oracle, DB2,
MSSQL, entre outras.
R_DATABASE_CONTYPE Tipo de acesso ao banco de dados: Nativa, ODBC, OCI, Plugin, e JNDI.
394
Capítulo 10
Mesa Em formação
R_DATABASE_ATTRIBUTE Aqui, você tem as configurações para cada conexão de banco de dados. No CÓDIGO
coluna, você tem o nome da variável enquanto que no VALUE_STR coluna,
você tem o valor.
Colher ser caixa de ferramentas do desenvolvedor, muitas das ferramentas utilizadas para afinar e optimizar transformações e trabalhos
podem ser encontrados dentro da interface. Os desenvolvedores devem se esforçar para ajustar seus processos para coincidir com a
carga que será processamento. Desempenho é normalmente medido em algumas maneiras: CPU, RAM e uso de banda, bem como o
número de registros que podem ser processados dentro de um determinado prazo. Com esta receita, vamos mergulhar nas diferentes
ferramentas e algumas das técnicas comuns que podem ser usados para melhorar o desempenho.
Preparando-se
A transformação e trabalho utilizado nesta receita estão disponíveis através do site da Packt. O trabalho exemplo executa a
transformação, que por sua vez processa alguns valores gerados aleatoriamente e os insere numa tabela da base de dados. A
transformação é construído para não funcionar adequadamente e têm problemas na execução. A receita irá percorrer como identificar
esses problemas usando a colher é construído em ferramentas.
2. Execute o trabalho. Observe que o resultados da execução painel abre e começa mostrando estatísticas
no trabalho.
395
Obtendo o máximo de Kettle
4. Enquanto a transformação está sendo executado, ele virá para o ponto onde ele não pode mais dados do processo e
falhar. Tal como mostrado na imagem anterior, a falha ocorreu no Insert / Update passo (ele será destacado em
vermelho na Métricas passo aba). Precisamos identificar ainda mais porque a transformação falhou. Clique no Exploração
madeireira tab sob
resultados da execução e clique no ícone de erro vermelho para mostrar as linhas do arquivo de registro que estão associadas
com o erro.
5. As linhas de erro que surgem mostram que a questão é um tempo limite de espera de bloqueio. Olhe para os três Insert
/ Update passos na transformação. Parece que estamos a tentar inserir dados na mesma tabela, o que
explicaria o tempo limite. Remova os dois
Insert / Update passos da 100K grupo sobre Adicionar Constantes passo eo Grupo Sobre 10M Adicionar
Constantes o passo como mostrado na imagem seguinte:
396
Capítulo 10
6. Conecte o Grupo 100K Over and Over Grupo 10M Adicionar Constantes passos para a
restante Insert / Update o passo como mostrado na imagem seguinte.
7. Execute a transformação novamente para verificar se o bloqueio tempo limite de espera foi resolvido.
Bloquear este passo até que passos terminar etapas que esperam na Insert / Update passos para
terminar antes que ele executa. Uma palavra de advertência, se utilizando os passos de bloqueio,
estar ciente de que um impasse pode ser criado se múltiplos são utilizados e são dependentes uns
dos outros.
397
Obtendo o máximo de Kettle
Outro problema comum é em torno de fluxos de dados. Validação de metadados de fluxo, assegurando que os campos
estão no fluxo, e colocações de campo são todos os problemas comuns que podem afetar não apenas se um processo
será executado com sucesso, mas também o desempenho. A parte seguinte da fórmula irá mostrar como exibir
metadados fluxo de dados, ambos durante o desenvolvimento e durante o teste do processo.
8. Dê um clique direito sobre o Gerar valor aleatório passo e selecione o Mostrar Campos de entrada
opção. O fluxo naquele ponto com seus metadados dadas irá aparecer:
9. Feche a janela e, em seguida, clique com o botão direito sobre o Gerar valor aleatório passo novamente, desta
tempo selecionando o Mostrar campos de saída opção. Uma janela semelhante irá aparecer com o campo adicionada a
partir da Gerar valor aleatório passo aparecendo agora na corrente.
10. Feche a janela e, em seguida, executar a transformação novamente. Botão direito do mouse sobre o Gerar
valor aleatório passo mais uma vez e selecione Mostrar sniff teste durante a execução para entrada ou saída. Aparece
uma janela mostrando o fluxo de dados em tempo de execução.
Como funciona...
Colher preciso muito do que se passa durante o processamento de transformações e empregos e expõe a desenvolvedores para que eles
possam solucionar problemas e construir melhores processos. Metadados e análise de fluxo de dados ao vivo pode ajudar a corrigir
problemas com processos de quebra. Enquanto as técnicas mostradas nesta receita não vai fazer processos funcionar perfeitamente durante
a noite, eles podem ajudar a guiá-lo para as melhores práticas para identificar gargalos que normalmente não seriam descobertos até que o
processo está mais perto de produção.
398
Capítulo 10
Tem mais...
Existem outras ferramentas disponíveis para monitorar o desempenho. No resultados da execução painel, há uma Gráfico
desempenho que pode ser activado e mostra várias estatísticas para um dado processo. Enquanto o encontro métricas não é CPU
funcionamento intensivo na cozinha ou panela, existem alguns recursos utilizados para atualizar a imagem:
As métricas são coletadas de cada passo, combinando as categorias que são encontrados no Métricas passo aba. Esses
dados também podem ser armazenados dentro de um banco de dados para trending longo prazo. Mais detalhes podem ser
encontrados no wiki Pentaho: Passo http://wiki.pentaho.com/display/EAI/ + + desempenho monitorização.
O wiki também tem um ótimo artigo sobre algumas dicas de ajuste de desempenho comuns que podem aumentar
significativamente o rendimento. Confira em http://wiki.pentaho.com/display/COM/ PDI + Performance + ajuste + check-list.
399
11
utilizando Visualization
Ferramentas em Kettle
Introdução
Como vimos em capítulos anteriores, Chaleira fornece um monte de funcionalidade fora da caixa, mas há uma série de mecanismos de
feedback grandes que foram adicionados que podem ajudar a tornar o desenvolvimento e trabalhar com dados ainda mais fácil. Ser capaz
de perfil e visualizar fluxos de dados permite aos programadores para recolher feedback dos clientes para determinar se eles têm cumprido
os requisitos dos clientes. Algumas destas características não são fornecidos diretamente na ferramenta, mas estão disponíveis como
plug-ins. Uma das características mais distintivas da chaleira é a capacidade de criar e adicionar plugins diretamente na ferramenta.
Utilizando ferramentas de visualização em Kettle
Neste capítulo, você irá aprender a trabalhar com plugins, bem como trabalhar com alguns dos recursos avançados que eles
fornecem.
Para seguir estas receitas, você precisa ter uma conexão de Internet que lhe permitirá acessar recursos da web do
Pentaho. O wiki Pentaho tem uma página dedicada a todos os plugins disponíveis publicamente conhecidos, que podem
ser encontradas em http://wiki.pentaho.com/ display / EAI / Lista + de + Disponível + Pentaho + dados + Integração + Plug-Ins. Muitos
dos plugins listados fizeram seu caminho para as versões mais recentes de Kettle. Outra maneira de acessar plugins é
através do novo recurso de mercado, que fornece uma maneira mais simples de gerenciar plugins que o manual de
processos versões mais antigas usadas.
Preparando-se
Para esta receita vamos exigir uma ligação à Internet para que Chaleira pode conectar-se ao mercado e
recuperar o plugin que está instalando.
402
Capítulo 11
2. O menu de mercado será aberto. Selecione os DataCleaner Profiling de Dados para Kettle
versão 5 ou superior plugar.
3. Leia os detalhes do pacote. Cada plugin deve fornecer detalhes do autor, a localização do plug-in, e
assim por diante.
4. Clique no Instalar este Plugin botão para instalar DataCleaner. Os arquivos serão
baixado e, em seguida, uma caixa de diálogo irá aparecer pedindo-lhe para reiniciar Spoon.
2. Na seção de detalhes do pacote, você vai notar a Instalar este plugin botão mudou para um Desinstalar
este plugin botão.
403
Utilizando ferramentas de visualização em Kettle
Como funciona...
O mercado utiliza um repositório Git para gerenciar o que plugins estão disponíveis para download. Desta forma,
desenvolvedores de plugins têm uma maneira fácil de gerenciar seus plugins e fornecer Pentaho com os detalhes
necessários para agilizar o processo de gestão do plugin. Mais detalhes podem ser encontrados no wiki Pentaho em http://wiki.pentaho.com/display/EAI/Marketpla
Tem mais...
Enquanto o mercado não oferece uma interface mais limpa para trabalhar, ainda é possível instalar plugins manualmente. Todos
os plugins instalados pode ser encontrado no diretório de plugins, onde Chaleira está instalado. Os plugins deve fornecer detalhes
sobre onde eles devem ser colocados dentro deste diretório.
Se você estiver usando o ramo 4.x do Kettle, detalhes sobre como instalar o plugin DataCleaner são
fornecidos no wiki Pentaho em http://wiki.pentaho.com/display/EAI/ Humana + Inference.
Veja também
DataCleaner é uma ferramenta de análise de dados de código aberto que integra com chaleira e pode perfil de dados enquanto o código está
em vias de ser desenvolvido. Além disso, os trabalhos de DataCleaner podem ser integrados em postos de trabalho Chaleira e executar como
Profiling de dados mostra a meta-informação sobre os dados que estão sendo processados a partir de quantos valores se encaixam em
intervalos para quantos valores caber um determinado formato. Isto pode ajudar os desenvolvedores a integração de dados escrever
processos mais otimizados e determinar se a qualidade da fonte é capaz de atender aos requisitos do projeto que está sendo usado. Para
esta receita nós estaremos trabalhando com DataCleaner de duas maneiras. A primeira será profiling dados enquanto dentro Spoon. O outro
404
Capítulo 11
Preparando-se
Esta receita assume que o plugin DataCleaner foi instalado em Spoon. O processo de instalação do plug-in é
discutido no início Gerenciando plugins com o mercado
receita. Enquanto a receita não exige qualquer experiência anterior com DataCleaner, pode ser benéfico para trabalhar com a
ferramenta antes de mergulhar para trabalhar com ele dentro de Kettle. O site DataCleaner fornece alguns realmente boa
documentação e pode ser acessado a partir de
http://datacleaner.org/.
Nós estaremos usando o livros base de dados. Os scripts para criar o banco de dados podem ser encontrados no site da Packt.
Esta base de dados tem sido utilizado em outros capítulos, por isso é provável que você já tenha criado e preenchido o banco de
dados. Além disso, o código do site da Packt também inclui um trabalho DataCleaner simples para a segunda parte da receita. Se
você já sabe como criar dados de perfis de emprego, fique à vontade para substituir um que você já construiu com a amostra de
um.
Esta parte da receita vai mostrar-lhe como ao perfil de dados durante o desenvolvimento de uma transformação:
2. A partir das paletes de Entrada pasta, trazer um A introdução da tabela passo para a tela.
`lastname`
, `firstname`
, `nationality`
, `birthyear`
, `` Id_author` DE
authors`
405
Utilizando ferramentas de visualização em Kettle
8. DataCleaner será aberto e ler as informações de metadados sobre o fluxo de dados em Kettle. Observe
que alguns padrões analisador já foram selecionados com base nos tipos de dados dos dados.
9. Clique no Executar botão no canto superior direito. Os dados serão processados no
transformação e perfilado por DataCleaner. Os resultados serão retornados como na imagem
seguinte:
406
Capítulo 11
10. Nós também pode personalizar o trabalho de perfis com outros analisadores. Vamos adicionar um analisador de distribuição de
valor, clicando no Analisar Menu e selecionando Distribuição valor.
11. Execute novamente o trabalho de perfis selecionando o Executar botão. A saída terá agora
entradas de distribuição de valor:
Agora que vimos como executar DataCleaner ao perfil de dados durante o desenvolvimento, vamos agora executar um trabalho DataCleaner em
tempo de execução:
3. De acordo com o utilidade pasta na palete, selecione o executar DataCleaner intensificar e trazer
-lo para a tela. Criar um hop entre a Começar e executar DataCleaner passos.
4. Abra a executar DataCleaner degrau. Esta etapa vai exigir alguma configuração para
trabalhar apropriadamente. Especificamente, devemos identificar o seguinte:
?? Local do arquivo de trabalho: Este é o caminho para o arquivo do conjunto de códigos do livro, ou
407
Utilizando ferramentas de visualização em Kettle
?? Tipo de saída: Para este exemplo, estaremos utilizando o formato de saída HTML.
6. Guardar e executar o trabalho. O arquivo de saída deve ser criado e pode ser aberta com qualquer navegador. Observe que se
recebe saída semelhante quando executar o trabalho de perfil diretamente de dentro DataCleaner anteriormente.
Como funciona...
DataCleaner e chaleira são ambos aplicativos Java que fornecem interfaces que permitem a integração das duas ferramentas. Ao alavancar
uma tecnologia existente, Chaleira recebe o benefício de uma ferramenta de análise de dados de pleno direito e DataCleaner recebe o
benefício de interface com uma ferramenta de integração de dados muito flexível. Em qualquer caso, os desenvolvedores usando o benefício
da ferramenta.
Tem mais...
Enquanto esta receita só cobria os conceitos básicos do uso DataCleaner como parte de um processo de chaleira ou
durante o desenvolvimento de um código novo, o plugin na verdade fornece acesso a recursos mais avançados da API
DataCleaner. Por exemplo, com a Trabalho etapa, há a opção de adicionar argumentos adicionais para o trabalho
DataCleaner que pode mudar a forma como DataCleaner se comporta durante a execução e construção do perfil de saída.
Para saber mais sobre essas opções, consulte a documentação DataCleaner em http://datacleaner.org/resources/ docs / 3.5.3 /
html / pt07.html.
408
Capítulo 11
Veja também
No mundo de hoje, onde os clientes exigem respostas mais rápidas e a quantidade de dados necessários para serem
processados aumentou dramaticamente, lojas tradicionais de Business Intelligence experimentaram dores devido à cadência em
que eles podem entregar valor. Um dos maiores desafios está tomando esses requisitos, por vezes vagos ou enganosas em torno
da transformação de dados de origem e, em seguida, em conformidade com o novo ou alterar a lógica de negócios. Chaleira tem
algumas ferramentas embutidas que permitem aos programadores a trabalhar com seus clientes para trabalhar com a limpeza de
dados e processo de transformação para determinar se eles estão no caminho certo. Nesta receita vamos percorrer como usar o Visualizar
perspectiva.
Preparando-se
Para esta receita nós estaremos usando o livros base de dados. Os scripts para construir esta base de dados estão disponíveis no site da
Packt.
3. Abra o A introdução da tabela degrau. Ligue o passo para o livros base de dados. Para o SQL
declaração, digite o seguinte:
SELECIONAR
primeiro nome
, último nome
, nacionalidade
, Ano de Nascimento
, título
Preço desde autores de
uma
409
Utilizando ferramentas de visualização em Kettle
4. A partir da palete de Saída pasta, trazer ao longo de um saída da tabela passo para a tela.
Criar um hop entre a A introdução da tabela e saída da tabela passos.
5. Abra a saída da tabela degrau. Ligue o passo para o livros base de dados.
9. Executar a transformação. Botão direito do mouse sobre o saída da tabela passo e selecione o
Visualize | analista opção. Observe que os campos da tabela estão à esquerda em dois grupos: a
medida e nível.
12. Agora adicione o Último nome nível para o linhas campo no traçado seção. Podemos agora
veja a soma dos preços pelo sobrenome do autor, que não é necessariamente útil. Vamos supor que
nos foi dada a necessidade de encontrar o preço médio de livros por autor.
410
Capítulo 11
13. Dê um clique direito em preço medida e selecione o subtotais opção. desmarque a Soma
caixa de seleção e selecionar o Média checkbox. Clique em ESTÁ BEM.
14. Dê um clique direito sobre o preço medida novamente e selecione a Nome da coluna e Format
opção. Alterar o formato para Moeda e a Casas decimais para 2.
15. Clique no Mais ações e opções botão (parece uma engrenagem) e selecione
Relatório opções:
16. Verifique as opções para Mostrar totais gerais para linhas e Mostrar totais gerais para
Colunas. Clique em ESTÁ BEM.
17. Agora você deve ter uma visão que mostra o preço médio por nacionalidade, bem como por autor, semelhante
ao seguinte:
411
Utilizando ferramentas de visualização em Kettle
18. No lado superior direito do Analyzer são o Vista como: opções. Clique no pequeno bar
ícone gráfico para ver os diferentes tipos de visualizações disponíveis. Tente alguns deles para fora para ter uma noção dos
diferentes tipos de visualização:
Como funciona...
o Visualizar perspectiva tira proveito de algumas das outras ferramentas da suíte Pentaho para permitir que desenvolvedores para mostrar seus
dados mais rapidamente e ter uma noção de haver ou não eles estão reunidos os requisitos que estão desenvolvendo para. A ferramenta de
visualização é na verdade uma ferramenta de edição Enterprise chamado Analyzer, que é uma ferramenta de front-end para o código aberto ROLAP
(OLAP) banco de dados de Mondrian. A versão embutida do Analyzer requer um conjunto de dados fornecido pelo Chaleira através Mondrian.
Mondrian é capaz de trabalhar com a maioria dos bancos de dados relacionais para construir fontes de dados OLAP. Enquanto mantivemos as
coisas simples e criou uma tabela dentro do livros
banco de dados, que poderia ter apenas como facilmente utilizado um banco de dados in-memory como MonetDB ou qualquer outra fonte de dados
relacional.
Tem mais...
Enquanto o conjunto de dados utilizado nesta receita foi extremamente simplista, Mondrian e Analyzer pode facilmente escalar para os dados
maiores e mais complexas. Tal como acontece com outras ferramentas, como DataCleaner, os relatórios e visualizações criadas nesta
ferramenta pode ser utilizada fora do Kettle como parte do maior conjunto de ferramentas Pentaho.
412
Capítulo 11
Para saber mais sobre Mondrian, veja Mondrian em ação, Manning Publications por William Back, Nick
Goodman, e Julian Hyde. O site Mondrian também fornece uma boa documentação e pode ser encontrada em http://mondrian.pentaho.com/docum
Veja também
fo Obtendo dados de um banco de dados receita em Capítulo 1, Trabalhando com bancos de dados
de forma eficaz qualquer tipo de fonte de dados podem ser consultados e visualizados.
Instaview é atualmente uma edição Enterprise exclusivo. Se você não tiver uma licença da
empresa, mas que desejam acompanhar, fazer download de um teste de 30 dias a partir http://www.pentaho.com/download.
Preparando-se
Para ser capaz de seguir a receita, o acesso à edição Enterprise do Pentaho Data Integration é necessária. Para os dados,
iremos utilizar detalhes do salário do jogador de beisebol que foram criados em
Capítulo 2, Leitura e Escrita de Arquivos. Estes dados são fornecidos no código para este capítulo no site da Packt.
Para Instaview para trabalhar de forma adequada, o banco de dados MonetDB interno deve ser ligado. Isso
pode ser feito indo para o diretório de instalação do PDI e ir para o / plugins / colher / / Plataforma /
pentaho-soluções / sistema / instaview / scripts ágeis-bi diretório. O comando padrão para ativar MonetDB no Linux é
a seguinte:
Para outros sistemas operacionais, verifique a página de documentação sobre a Pentaho Infocenter:
http://infocenter.pentaho.com/help/topic/troubleshooting_guide/
concept_troubleshooting_monetdb_instaview_config.html.
Siga os passos indicados para executar os detalhes jogador de beisebol salariais através Instaview.
2. Clique no Crie um novo botão para criar uma nova visualização / análise.
413
Utilizando ferramentas de visualização em Kettle
3. Selecione o Arquivo local opção no Nova Fonte de Dados diálogo que aparece, selecione a opção
a CSV tipo de dados. Clique em Está bem para inserir os detalhes do arquivo CSV.
?? Nome do arquivo: Isto dá a localização para o arquivo que está sendo analisado
5. Clique no obter Campos botão. A etapa irá consultar o arquivo e fazer um melhor palpite
no formato dos campos. Clique em Perto sobre os resultados da análise e clique em Está bem para fechar a passo.
Instaview tentará configurar o arquivo de análise através da construção de uma transformação para carregar os dados no banco de
dados AgileBI MonetDB, construir um modelo de Mondrian, e armazenar em cache os dados em MonetDB para trabalhar com os dados
em Pentaho Analyzer. Se tudo funcionar, Instaview mudará para o Visão aba, que é Pentaho Analyzer. Vamos brincar com algumas das
capacidades de obter uma melhor idéia de como Analyzer pode trabalhar com dados:
Como funciona...
Instaview automatiza o máximo de integração de dados e construção do modelo possível, permitindo que os usuários
começar a jogar com os dados e potencialmente ganhar novos conhecimentos que normalmente teriam tomado muito
mais tempo e envolvem mais desenvolvedores. Para ver o que Instaview fez nos bastidores, vamos voltar para o configurar
guia e ver o código criado por cada um dos subprocessos. Deve haver uma seção sobre o configurar guia que mostra o
estado de cada processo, como mostrado na imagem seguinte:
414
Capítulo 11
Clique no Editar ligação para a seção de integração de dados. Um aviso sobre a necessidade de compreender a
exigência do código de integração de dados irá aparecer. Clique em OK e a transformação criado por Instaview
abre:
É possível modificar essa transformação de limpar e estar de acordo com os dados. Observe que o
Entrada passo é o mesmo que aquele que abriu no momento da criação do CSV Instaview. o Saída
passo automaticamente está configurado para mover os dados para o MonetDB base de dados. Feche a transformação
e voltar para Instaview.
O processo Modelo construiu um modelo de Mondrian para Analyzer para trabalhar. Clicando no Editar
link irá causar um outro pop alertando-se; desta vez a necessidade compreensão de conceitos de modelagem. Clique em Está bem para
visualizar o modelo criado.
Essa perspectiva permite a edição de modelos, dando aos desenvolvedores avançados a flexibilidade necessária para
construir cubos personalizado Mondrian. Fechar o modelo e voltar para Instaview. O processo de cache de dados permite o
cache em memória que será apagado, o que pode ser feito clicando no Claro ligação.
415
Utilizando ferramentas de visualização em Kettle
Pentaho Analyzer permite uma grande quantidade de diferentes tipos de visualizações, de simples barras e de linhas gráficos para dispersar
parcelas, mapas de calor, e diagramas de geolocalização. Embora os dados utilizados para a receita é simplista, somos capazes de recolher algumas
dicas através de formatação condicional. As opções de visualização também pode fornecer um monte de insight, dependendo do tipo de dados que
Tem mais...
Também é possível construir transformações mais complicadas e os dados purê juntos, mesmo para um maior conhecimento, bem como
adicionar recursos mais poderosos para os modelos Mondrian construídos automaticamente por Instaview. Considere o código
desenvolvido por Instaview para ser o ponto de partida. Conhecimento de trabalhar com os vários componentes é essencial para obter o
máximo de Instaview.
Veja também
416
12
Análise de dados
Introdução
Dados Analytics é a arte de obtenção de dados e obtenção de informações a partir dele, a fim de tomar decisões informadas. Uma
grande parte do edifício e conjuntos de dados de validação para o processo de tomada de decisão é a integração-os dados em
movimento, limpeza e transformação de dados da origem para um alvo. Este capítulo se concentrará em algumas das ferramentas que
levam Chaleira além das capacidades normais de processamento de dados e integrar processos em ferramentas analíticas.
Existem duas principais razões para querer ler um arquivo SAS como parte de um processo de Kettle. A primeira é que um conjunto de
dados criado por um programa SAS já está em vigor, mas a saída desse processo é usado em outros lugares em outras soluções de
Business Intelligence (por exemplo, usando a saída para a integração em relatórios, visualizações, ou outras ferramentas analíticas). A
segunda é quando já existe uma biblioteca padrão de lógica de negócios e regras construído em Kettle que o conjunto de dados precisa ser
executado através antes que ele possa ser usado.
Preparando-se
Para ser capaz de usar a etapa de entrada SAS, sas7bdat arquivo será necessário. Os Centros para Controle e Prevenção de
Doenças tem alguns conjuntos de dados de amostra como parte do
NHANES Dietary dataset. Seus conjuntos de dados tutorial pode ser encontrada em seu Web site em
http://www.cdc.gov/nchs/tutorials/dietary/downloads/downloads.htm.
Nós estaremos usando o calcmilk.sas7bdat conjunto de dados para esta receita.
2. A partir da pasta de entrada do desenhar palete, trazer ao longo de um Obter nomes de arquivos degrau.
3. Abra o Obter nomes de arquivos degrau. Clique no Squeaky toy botão e encontrar o calcmilk.
sas7bd arquivo baixado para a receita e clique em ESTÁ BEM.
4. A partir da pasta de entrada do desenhar palete, trazer ao longo de um SAS Input degrau. Criar um hop
de Obter nomes de arquivos passo para o SAS Input degrau.
5. Abra a SAS Input degrau. Para o O campo na entrada para usar como nome de arquivo campo, selecione
a Nome do arquivo campo no menu suspenso.
418
Capítulo 12
7. Para limpar a corrente para cima e só tem a calcmilk dados, adicione um Selecionar Valores degrau
e adicionar um hop entre a SAS Input passo para o Selecionar Valores degrau. Abra o
Selecionar Valores passo e mudar para o Remover aba. Selecione os campos gerados a partir da Obter nomes de arquivos degrau
( nome do arquivo, short_filename, caminho, e assim por diante). Clique em
Está bem para fechar a passo.
8. Pré-visualização do Selecionar Valores degrau. Os dados do SAS Input etapa deve aparecer na
uma rede de dados, como mostrado na imagem seguinte:
Como funciona...
o SAS Input etapa aproveita projeto Sassy Leitor de Kasper Sørensen ( http://sassyreader.eobjects.org). Atrevido é uma biblioteca
Java usado para ler conjuntos de dados no sas7bdat formatar e é derivada a partir do pacote de R criada por Matt Shotwell ( https://github.com/BioStatMatt/sas7bdat).
Antes desses projetos, não foi possível ler o formato de arquivo proprietário fora da próprias ferramentas SAS. o SAS Input passo
exige que os nomes de ficheiros processados para serem fornecidos a partir de outro passo (como o Obter nomes de
arquivos degrau). Também digno de nota, enquanto o sas7bdat formato só tem dois tipos de formato (strings e números), PDI
é capaz de converter campos para qualquer um dos formatos embutidos (datas, números inteiros, e assim por diante).
Veja também
419
Análise de dados
Preparando-se
Esta receita não será um processo único grande, mas composta de receitas menores em torno do mesmo assunto. Nós
estaremos usando o conjunto de dados salário de beisebol que podem ser encontradas no site do livro ou do site Baseball
Arquivo de Lahman, encontrada em http://www.seanlahman.com/ baseball-archive / estatísticas /. O código para esta receita também
pode ser encontrada no site do livro.
A receita será dividido em receitas menores, que se concentrará em três etapas: Analytic Query, Agrupar por, e Estatísticas univariada. Estas
medidas irão permitir-nos ganhar alguma introspecção em salários do jogador de beisebol, tais como a mudança de salário de um
contrato para a próxima, a frequência de ser negociado, e assim por diante.
1. Criar uma nova transformação e adicionar um entrada de arquivo de texto o passo da palete para
a tela.
2. Ter a entrada de arquivo de texto ponto passo para o Salaries.csv Arquivo. No Conteúdo aba,
certifique-se de mudar o Separador de ; para ,. No Campos guia, use o obter Campos
botão para obter os campos do arquivo.
4. Adicionar um Classificar linhas etapa da paleta para a tela. Criar um hop do Arquivo de texto
entrada ao Classificar linhas degrau.
5. Os dados precisa ser resolvido por playerid na ordem ascendente, com yearID em
a ordem descendente. Seu Classificar linhas passo deve ser semelhante ao seguinte:
420
Capítulo 12
6. A partir do Estatisticas pasta, selecione a Analytic consulta passo e adicioná-lo para a tela.
Criar um hop do Classificar linhas passo para o Analytic consulta degrau.
7. Para o Grupo campo, selecione playerid. Preencha o Funções analíticas grade da seguinte forma:
8. Adicionar uma Calculadora passo e criar um hop do Analytic consulta passo para o
Calculadora degrau.
10. Finalmente, visualize a Calculadora degrau. Você deve receber uma saída semelhante ao
Os seguintes:
Agora, a informação do salário fornece um pouco mais detalhadamente e pode mostrar o quanto um jogador ganhou (ou perdeu) ao
longo de sua carreira. Agora, vamos olhar para um outro passo que pode ajudar a mostrar ainda mais detalhes em torno da dataset-
salário jogador de beisebol Estatísticas univariada.
421
Análise de dados
1. Criar uma nova transformação e adicionar um entrada de arquivo de texto passo para a tela.
2. Ter a entrada de arquivo de texto ponto passo para o Salaries.csv Arquivo. No Conteúdo aba,
certifique-se de mudar o Separador de ; para ,. No Campos guia, use o obter Campos
botão para obter os campos do arquivo. Clique em Está bem para fechar a entrada de arquivo de texto degrau.
3. Trazer uma univariadas Estatísticas etapa da paleta para a tela e criar um hop
de entrada de arquivo de texto passo para o univariadas Estatísticas degrau.
4. Abra a univariadas Estatísticas degrau. Para o Entrada campo, selecione salário. Defina o valor
do N, média, Desvio padrão, Min, Max, e Mediana para verdade.
5. Clique em Está bem para fechar a univariadas Estatísticas passo e, em seguida, visualizar o passo.
A linha que mostra as várias estatísticas de todo o salário será exibido na visualização:
O fluxo de dados é processado, retornando as estatísticas de salário para todo o conjunto de dados. Agora, como a última parte
desta receita, vamos explorar a grupo de degrau. Execute os seguintes passos para aprender a usar o grupo de degrau:
1. Criar uma nova transformação e adicionar um entrada de arquivo de texto passo para a tela.
2. Ter a entrada de arquivo de texto ponto passo para o Salaries.csv Arquivo. No Conteúdo aba,
certifique-se de mudar o Separador de ; para ,. No Campos guia, use o obter Campos
botão para obter os campos do arquivo. Clique em Está bem para fechar a entrada de arquivo de texto degrau.
3. Adicione uma Classificar linhas passo para a tela e criar um hop do entrada de arquivo de texto passo para
a Classificar linhas degrau.
5. Adicione uma grupo de passo para a tela e criar um hop do Classificar linhas passo para o
grupo de degrau.
6. Abra o grupo de degrau. Para o Grupo campo, selecione playerid. Preencha o agregados
grade de dados, como mostrado na imagem seguinte:
422
Capítulo 12
7. Clique em Está bem para fechar a grupo de passo e visualizar os dados. A corrente de dados será
agrupadas pelos jogadores individuais e as estatísticas mostram salariais por jogador:
Como funciona...
Esta receita abrangeu três maneiras diferentes para descobrir mais informações sobre os dados que estão sendo processados, cada
um coletando estatísticas sobre os dados de maneiras que são relatados, mas não têm necessariamente de ser recalculado cada
vez que um relatório ou análise é feita. Para cada uma das etapas, há duas coisas a considerar:
f Os dados originais não vai continuar através da corrente depois de ser processado por
estes passos As Analytic consulta etapa fornece a capacidade de comparar vários registros através de um fluxo de dados
que tem sido historicamente uma coisa complicada de fazer com apenas SQL. Muitas vezes, as comparações devem ser feitas dentro
de um grupo de dados, geralmente sob a forma de mudanças de rastreamento de um registro / período para o outro. Para o nosso
conjunto de dados salário de beisebol, olhamos um para o jogador como eles mudaram de estação para estação e como seus salários
alterados. o univariadas Estatísticas passo fornece estatísticas comuns para o fluxo de dados a ser analisado. Tendo estes valores
podem ser usados para validação de dados, comparações entre cargas de dados e para relatar. No conjunto de dados salário baseball,
passo para ver as métricas de cerca de salário (especificamente a média, min, e números de salário max para todos os
resultados). o grupo de passo não só fornece os mesmos tipos de estatísticas como o univariadas Estatísticas
passo, mas também permite agrupar os dados em conjunto. Para o conjunto de dados de beisebol, foi utilizado o grupo de passo para ver as
métricas em torno da média, min, e números de salário max para cada jogador.
423
Análise de dados
Veja também
Weka é outra ferramenta de código aberto que é oficialmente suportado pelo Pentaho, que incide sobre a mineração de dados. Como se fosse
primos R e RapidMiner, Weka fornece uma biblioteca de ferramentas de análise estatística que podem ser integrados em sistemas de tomada de
decisões complexas. Para esta receita, vamos falar sobre como construir um conjunto de dados aleatórios para Weka usando Chaleira.
Preparando-se
Nós estaremos usando os dados salários dos jogadores de beisebol que podem ser encontradas no site do livro ou do
site Baseball Arquivo de Lahman, encontrada em http://www.seanlahman.com/ baseball-archive / estatísticas /. O código para
esta receita também pode ser encontrada no site do livro.
Esta receita também aproveita a saída ARFF plugar. Isto está disponível, quer através da
mercado ( para Kettle 5 e superior) ou a partir do wiki em http://wiki.pentaho.com/ display / EAI / Lista + de +
Disponível + Pentaho + dados + Integração + Plug-Ins.
Execute os seguintes passos para construir uma amostra de dados aleatórios para Weka:
1. Criar uma nova transformação e adicionar um entrada de arquivo de texto passo para a tela.
2. Ter a entrada de arquivo de texto ponto passo para o Salaries.csv Arquivo. No Conteúdo aba,
certifique-se de mudar o Separador de ; para ,. No Campos guia, use o obter Campos
botão para obter os campos do arquivo. Clique em Está bem para fechar a entrada de arquivo de texto degrau.
3. Adicione uma amostragem Reservoir passo do Estatisticas pasta na palete para a tela.
Criar um hop do entrada de arquivo de texto passo para o amostragem Reservoir degrau.
4. Abra a amostragem Reservoir degrau. Alterar o valor do O tamanho da amostra (linhas) campo
para 1000. Clique em Está bem para fechar a passo.
5. Adicione uma saída ARFF passo para a tela. Criar um hop do amostragem Reservoir
passo para o saída ARFF degrau.
6. Abra o saída ARFF degrau. Para o Nome do arquivo campo, chamar o arquivo
baseball_salaries.
424
Capítulo 12
7. Mude para o Conteúdo aba. Garantir a Formato corresponde ao ambiente que você está
trabalhando em (DOS para o Windows, Unix para * nix).
8. Interruptor para o Campos aba. Use o obter Campos botão para obter os campos de fluxo de dados em
a Campos grade de dados. O passo será fazer um melhor palpite no tipo ARFF para cada elemento de dados. Clique em Está bem para
fechar a passo.
9. Executar a transformação. Um arquivo ARFF será gerado e pode ser usado para trabalhar com os dados dentro Weka.
Como funciona...
Esta receita utiliza duas etapas, a primeira ( Reservoir Sampling) de que pode ser usado por qualquer coisa que só precisa de uma
amostra aleatória de dados para processar. O segundo transforma o conjunto de dados para o formato padrão para Weka.
amostragem Reservoir leva grandes conjuntos de dados e aleatoriamente selecciona registos para criar uma amostra
representativa menor dos dados. As duas opções no passo, tamanho da amostra e semente aleatória, controlar quão grande é o
conjunto de amostras deve começar e como os registros são selecionados aleatoriamente. Para mais detalhes sobre o passo,
veja o wiki Pentaho em http://wiki.pentaho.com/ visor / DataMining / Usando o + + + Reservatório Amostragem + encaixe.
o saída ARFF etapa leva o fluxo de dados e armazena os dados no formato padrão que Weka usa para processar dados. A
primeira parte do arquivo é o cabeçalho, que fornece os detalhes de campo (nome, tipo, e assim por diante) e também pode
armazenar os detalhes da origem de dados (que o criou, quando o conjunto de dados foi criado, e assim por diante). A segunda
parte se encaixa o formato típico de valores separados por vírgulas, com campos de cada ficha separadas por uma vírgula. Para
saber mais sobre o formato, consulte a wiki Weka em http://weka.wikispaces.com/ARFF+(stable+version).
Tem mais...
Há um outro plugin Kettle que vai realmente tirar proveito de um modelo construído em Weka e devolver os resultados de volta
para posterior processamento dentro Chaleira. O passo é chamado Weka Scoring
e é um ótimo lugar para começar a integrar a aprendizagem de máquina em processos normais de integração de
dados. Para saber mais sobre o plugin, visite a wiki em http: //wiki.pentaho. com / display / datamining / Usando + a +
Weka + Pontuação + Plugin.
Existe um fórum sub dedicado a trabalhar com Pentaho e Weka nos fóruns: http: //
forums.pentaho.com/forumdisplay.php?81-Pentaho-Data-Mining-WEKA.
Para saber mais sobre Weka, confira o site Weka para tutoriais e outras referências
http://www.cs.waikato.ac.nz/ml/weka.
425
Análise de dados
Veja também
426
UMA
Estruturas de dados
Este apêndice descreve algumas estruturas usadas em várias receitas ao longo do livro. Há dois objetivos em descrevê-los aqui
(além de manter a explicação em um único lugar), um é que você entenda a estrutura dos dados a ser utilizado. O segundo, é o que
lhe permite criar os seus próprios dados no formato de sua escolha, banco de dados, arquivo de Excel, e assim por diante, exceto,
claro, quando os dados são usados em uma receita que descreve os passos de banco de dados, caso em que os dados devem ser
em um banco de dados.
livros
autores
428
Apêndice A
museus cidades
museus
cidades
429
Estruturas de dados
o exterior banco de dados contém detalhes sobre equipamentos ao ar livre e as categorias que fazem parte. As receitas que
usam o conjunto de dados ao ar livre são baseados em você que é parte de uma loja de equipamentos ao ar livre. O diagrama
a seguir mostra a relação entre os muitos produtos ao ar livre para sua categoria dada:
produtos Categorias
id_product categoria
desc_product id_category
id_category preço
produtos
categorias
430
Apêndice A
OrderDetails
ORDERNUMBER
ORDERNUMBER
CUSTOMERNUMBER
COMENTÁRIOS
DataDeEnvio ordens productCode
ORDERDATESTATUS
RequiredDate
QUANTITYORDERD
PRICEEACH
ORDERLINENUMBER
OrderNumber productCode
BUYPRICE MSRP
QUANTITYINSTOCK
ProductDescription
ProductVendor
PRODUCTSCALE
PRODUCTNAME productline
postalCode OFFICECODE
AddressLine2 Estado País
TERRITÓRIO AddressLine1
CUSTOMERNAME
EmployeeNumber
funcionários produtos escritórios
offices_OFFICECODE
Supervisor jobTitle
CONTACTLASTNAME EMAIL
ApelidoOFFICECODE
Nome EXTENSÃO CIDADE TELEFONE
CONTACTFIRSTNAME
TELEFONE AddressLine1
AddressLine2
clientes CIDADE
CUSTOMERNUMBER
ESTADO postalCode PAÍS
CREDITLIMIT EmployeeNumber
SALESREPEMPLOYEENUM
431
Estruturas de dados
O banco de dados Lahman Baseball é uma das estatísticas do beisebol mais completos conjuntos de dados disponíveis.
Enquanto os dados que trabalhar com nas receitas é com o csv arquivo de formato conjunto de dados, é dados relacionais, e
que vêm em formatos de SQL e de acesso também. Os dados são fornecidos por Sean Lahman através de um Atribuição
ShareAlike- 3,0 Unported. O diagrama a seguir mostra as tabelas com as quais trabalhamos no livro:
mestre
VARCHAR (9) bbrefID: V4RCH4R
(9) retrolD:
VARCHAR
estreia:
VARCHAR
altura VARCHAR
(50)
(10)
VARCHAR
(1)
INTEGER:
nameNick:
nameGiven:
nameNote:
(50)
lahman4
VARCHAR
nameLast:
VARCHAR VARCHAR
(50) bastões
VARCHAR
VARCHAR
(9)
lahman40ID:
da
gera: faculdade:
(10) (255)
nameFirst: (1)(9)
holtzID:
5ID: VARCHAR
finalGame:
VARCHAR DUPLOS:
( 255)
(255) de
(50) peso:
VARCHAR
deathState:
deathCountry:
INTEGER
deathYear:
(2) birthCity:
VARCHAR
aniversário: VARCHAR
VARCHAR
Deathday:
INTEGER
VARCHAR
(50) (2)
INTEGER deathCity:
(50)
deathMonth:
birthState:
INTEGER (50 )VARCHAR
VARCHAR
birthCountry:
INTEGER
(10) hofID:birthmonth:
VARCHAR
lahmanID: VARCHAR
(10)
INTEGER INTEGER
(10)
managerlD:
[PK] Birthyear:
playerlD:
yearMax: schoolsplayers INTEGER
VARCHAR (15) [PFK] yearMin: INTEGER
playerlD: VARCHAR (9) [PFK] schoollD:
G_old:
INTEGER
IBB:
RBI: rebatidas
SF:
INTEGER
INTEGER BB: INTEIRO
INTEGER
HBP:
INTEGER GIDP:
INTEGER
SO: INTEGER
SH:
INTEGER
L:INTEGER
INTEIRO
INTEGER
(2)
teamId:
INTEGER
playerlD:
3B:
R:
INTEGER
VARCHAR
[PK]
VARCHAR
SB:
INTEGER
INTEGERINTEGER
G_batting:
(3) RH:
H:
(9)IgID:
restrição:
CS:
INTEGER
INTEGER
INTEGER
VARCHAR
INTEGER
[PFK] 2B:
AB:
[PK]
yearlD:
schoolNick:
schoolState:VARCHAR (55)
(55)escolas
VARCHAR(55)
schoolCity:
SchoolName: VARCHAR
VARCHAR
schoolID: VARCHAR (15)(255)
[PK]
salariais:
(2) salários VARCHAR
[PK] playerid: DUPLOS (9) [PFK]
VARCHAR (3) [PK]
yearID: Integer [PK] lgID: VARCHAR
teamId:
Note-se que nas receitas que envolvam a mestre mesa nos referimos a ele como Jogador, uma vez que é os dados dessa
fonte.
432
B
Referências
Este apêndice apresenta algumas referências recomendados para outros livros e recursos para aprofundar os temas
abordados neste livro de receitas. Ambos Pentaho ea comunidade reunimos uma grande coleção de recursos que
auxiliam na mergulhar na pilha Pentaho. Enquanto algumas das referências se referem a versões mais antigas do seu
software particular, eles ainda são muito relevantes nas áreas que cobrem.
livros
f William D. Back, Nicholas Goodman, e Julian Hyde. Mondrian in Action. Tripulação
Publicações ( Shelter Island) de 2014.
f Matt rodízios, Roland Bouman, e Jos Van. Dongen. Pentaho Kettle Solutions.
Wiley (Publicações Indianapolis, IN) de 2010.
f Will Gorman. Pentaho Relatórios 3.5 para desenvolvedores Java. Packt Publicações
(Birmingham), 2009.
f Ian H. Witten, Eibe Frank, e Mark A. Hall. Mineração de dados. Morgan Kaufmann
Publicações ( Burlington, MA), 2011.
Referências
Conectados
434
Índice
símbolos Anexar fluxos passo 88, 89 ARFF plug-in de saída 424
ARFF guia passo de saída 425 Argumento 286 anexada a
$ {Internal.Transformation.Filename.Directory} tabela guia Arquivos 360 autores, os dados de livros
variável 71 estrutura 428 arquivo authors.txt 66 AWS Console
$ {OUTPUT_FOLDER variável 280 @
caráter 135 / job 389
propriedade nível de acesso 354 mesa de livros, estrutura de dados livros 428 BSON
seqüência de ação passo 334 Add (binário JSON) 129
seqüência
cerca de 270 C
evitando o uso, para enumerar linhas 271
guia Avançado 289 cache de duração propriedade 354
para o separador 68
passo de consulta analítico 98, 423 URL 350
CDA API 349 CDA a partir da tabela, a exclusão de 35-40 obter, a partir de caminho
usado, para criar arquivos pela PUC 344-350 carregamento, no MongoDB 129, 130 de carregamento, em
Configurações II (opt) Propriedade 354 Configurações de consulta utilizado 21, 22 recuperação, a partir de
coluna (opt) Propriedade 354 pesquisa Combinação / Hadoop 119-121 recuperação, a partir de HBase 127-129
atualização passo 31 comandos recuperação, a partir de MongoDB 130, 131 recuperação, a
partir do Salesforce.com 114, 115 estudar, através de
execução, em outro servidor 367-369 estatísticas de transmissão 420-423 validar, em tempo de
Valores Separados Por Virgula. Vejo CSV Comunidade execução 227, 229 visualização, InstaView utilizado 413-415
sigla Generator (CAG) 255 Comunidade Gráfico visualização, com 409-412 AgileBI
CDA condição
plug-in baseado cerca de 7 a conexão com 9-11 conectando, não suportada por
fluxo, dividindo-se em múltiplos Kettle 14 ligação, mudando a ligação 51-53 tempo de execução, a
Copiar arquivos entrada de trabalho 172, 173 Copiar resultados avançada 13 de dados, recuperar 14-16 recuperar dados de,
anteriores para args? opção 296 Copie os resultados anteriores aos parâmetros usados 16-19 a recuperação de dados a partir de, tempo
opção 296
linhas de cópia para resultar passo 188, cartão
validador 306 Crédito 229 CSV 70, funcionalidade 86
personalizado consulta utilizado 21, 22 bases de dados da
436
valores que procuram, condições complexas Document Type Definition. Vejo recurso DTD
usado 204-207 doQuery 349 Duplo Metaphone 221 DTD
valores que procuram, consultas dinâmicas
usado 207-210
tarefas de design de banco de dados cerca de 146-148
tarefas de design de banco de dados repetitivos, realizando limitações 148 URL
de PDI 62, 64 148
Banco de dados juntar etapa 206, 207 Banco de Dados de definições DTD
pesquisa passo 201-203, 207 metadados de banco de dados arquivos XML, validar contra 146-148
entrada de trabalho DTD Validador
consultas SQL, construção de via 57-62 arquivos XML, validar contra 148
tabela de banco passos manequim
conjuntos de dados
e-mails
conjuntos de dados 255, 256 Verificar, checksums transformação 362 envio, com arquivos anexados
dados estrutura de dados 429 dados ao ar ETL Metadados Injection passo 320 arquivo
subconjuntos de dados
97-100 etiquetas. disposta horizontalmente 100 de
tipos de dados 69
escrita, com folhas dinâmicas 105-107 escrita, com
campos de data
várias folhas 101-104
URL 87
entrada trabalho Excluir arquivo 176
operação DELETE 39 etapa Excluir Excel passo saída 366 Excel escritor plug-in passo 362
desc_product nomedocampo 86 Detectar Language. Vejo Extrato de XML, Transform, and Load (ETL)
URL 112
armazenamento de documentos 129
437
F transferido, recuperação de informações 181 com
campos que ocupam várias linhas,
Feedly ler 82-84 com um campo por linha,
URL 167 lendo 79-82
Campos File Transfer Protocol (FTP) 178 File Transfer Protocol
criando, com estrutura XML 154, 155 nome do arquivo, Secure. Vejo Filtrar linhas FTPS passo 233
usando como 93-95 campos de largura fixa, leitura de findInfoRowSet () método 377 fixos campos de largura
arquivos com 70 especificando, notação caminho usado
137-140 dados XML 136, 137
transferir 180 entrada de trabalho 179, 180 Obter dados a partir da etapa
XML 137, 146 Obter Campos botão 70, 91, 137 obter
arquivos de etapa resultado 146 getRowFrom () método
377 Obter linhas da etapa resultado 296
438
Obter Informações do Sistema etapa
J
cerca de 92, 176
URL 92 biblioteca Janino 325
Obter etapa dados XML 136 Gnu Jaro 220 Jaro-Winkler
Privacy Guard (GnuPG) 220 linguagem Java
cerca de 195
URL 196 sintaxe, URL 376
Grupo a passo 423 Java Script Object Notation (JSON) 129 JavaScript
etapa
H utilizando, para controlar a execução entradas em trabalhos 303
439
eu várias folhas
arquivo Excel, escrevendo com 101-104
Banco de Dados Lahman Baseball 432 website estrutura de dados museus
Baseball Arquivo de Lahman cerca de 429 cidades mesa
URL 420, 424 429 museus de mesa 429
Junção externa esquerda 261
comandos Levenshtein 220 museus de mesa, de estrutura de dados museus 429 bases de dados
Linux de amostra MySQL
URL 367 URL 8
Localização campo 84
logfile N
cerca de 78, 79
logfile limpo, criando 366 arquivo de log nome
personalizado, criando 362-366 filtragem 366 proporcionando, aos arquivos 91
isolar, para diferentes postos de trabalho 367 de isolamento, por de nome de 354 Needleman-Wunsch
toras
o envio, através de e-mail 361 uso, evitando 237, 238
NewsBlur
M URL 167
campos numéricos
trabalho de correio entrada entrada 195 Correio URL 87
validador 229 Correio trabalho validador 359
O
Mapeamento de passo especificação de entrada 313, 314
mapeamento especificação saída passo 273 de mapeamento OLAP (On-Line Analytical Processing
(sub-transformação) passo 272 de mercado bancos de dados) 324 arquivos calc
OpenOffice 96 Abrir Pretty Good Privacy (OpenPGP)
Modificada Java Script Valor (MJSV) distribuição passo de 430 produtos de mesa 430
377 Mondrian
URL 8 Junção externa? opção 206 campos
dados, o carregamento em 129, 130 de saída (opt) Propriedade 354 parâmetro outputType
440
panela Pentaho BI Server
URL 283 configurando, para executar trabalhos PDI 332-334
441
Q de duas correntes, fundindo-se com diferentes
estruturar 240-244 de duas correntes, que se fundem com a
propriedade de consulta 354 mesma estrutura
240-244 processamento diferente, número
R de linha
baseados 268-270 linhas
R_DATABASE 394
específicas, identificando 271 atualização,
R_DATABASE_ATTRIBUTE 395
alternativa 26, 27
R_DATABASE_CONTYPE 394 R_DATABASE_TYPE
pacote de R
394 Really Simple Syndication. Vejo registros feed RSS
por Matt Shotwell, URL 419
feed RSS
criar 167, 168 ler 165,
inserir, alternativa 26 166 URL 165
corrente de referência 251
Soundex refinado 221
RSS saída passo 169 R_STEP 392
Expressões regulares (RegExp) sintaxe 173 bancos de dados
R_STEP_ATTRIBUTE 392
relacionais (RDBMS). Vejo servidor remoto de banco de dados
R_STEP_DATABASE 394
R_STEP_TYPE 392
arquivos, colocando 181-183 arquivos,
R_TRANSFORMATION 392
recuperando a partir de 178, 179
R_TRANS_HOP 392
Remover guia 275 Reservoir R_TRANS_NOTE 392 Rubi
Amostragem 425 resultado objeto Scripting 378 runtime
303 junção externa direita 261
R_JOB 393 R_JOBENTRY 393
R_JOBENTRY_ATTRIBUTE 393
S
R_JOBENTRY_DATABASE 394
R__JOBENTRY_TYPE 393 R_JOB_HOP S3 CSV passo de entrada 109
393 R_JOB_NOTE 393 Salesforce.com
dados, o carregamento em 112-114 de dados,
ROLAP (OLAP) 412 fileira recuperar a partir de 114, 115, documentos URL
amostra
enumerando, Adicionar uso passo sequência criar, para fins de teste 378-380
evitando 271 de inserção, 27 de sas7bdat 417 SAS
442
instrução SELECT Filtrar linhas aninhados passos uso,
execução múltipla 20 evitando 237, 238 número de linhas de saída,
Selecione os valores etapa limitando 257, 258 linhas, fundindo 245 dividindo-se
cerca de 275 a em vários fluxos, condição
adição de 69
utilizado, para alterar a sequência de dados 274, 275 com base 233-236 passos, executando em fluxo
arquivos semi-estruturadas vazio 265-267
lendo 72-78 escrita etapa fluxo Lookup
87-89 cerca de 214, 215
separador alternativas 215
notação alternativa 68 estatísticas de fluxo
serializar / de-serializar mecanismo 308 arquivos definido usado, para estudar os dados 420-423
na etapa resultado 297 SFTP subtransformation
parte transformação, movendo-se para 309-315
cerca de 181 Sincronizar após a etapa merge 49, 50
URL 181
calços T
cerca de 116
para sandbox, URL 116 criação em mesa
Simple Object Access Protocol (SOAP) blog de 222 45-50 inserção de 45-50 linhas,
443
múltiplas transformações, executando valores, procurando
em paralelo 275-277 na base de dados, as condições de complexos
reutilização, a injeção de metadados usado 316-320 execução, usado 204-207 no banco de dados, consultas dinâmicas
definindo argumentos estáticos 284-286 execução, definindo usadas 207-210
estática variáveis propriedade 354
parâmetros 284-286
amostra 280, 322-324 W
weather_np.ktr arquivo 323
transformações (baseado em arquivo)
recomendação W3C
393
URL 349
ficheiros 282 281 Olá Web Service Definition Language (WSDL) 223 Weka
você
444
estrutura de raiz XML Z
156 criando
XML Schema Definition. Vejo estrutura XML esquema arquivos ZIP
estruturas XML complexos, criando 155-161 criando trabalhar com 191-195 arquivos fechando,
445
Obrigado por comprar Pentaho
Integration Cookbook Dados
Segunda edição
Nossos livros e publicações compartilhar as experiências de seus colegas profissionais de TI na adaptação e personalização de
sistemas, aplicativos e estruturas de hoje. Nossos livros solução baseada dar-lhe o conhecimento e poder de personalizar o software e
tecnologias que você está usando para fazer o trabalho. livros Packt são mais específicos e menos geral do que os livros de TI que
você já viu no passado. Nosso modelo de negócios exclusivo permite-nos trazer-lhe informações mais focada, dando-lhe mais do que
você precisa saber, e menos sobre o que você não.
Packt é uma companhia publicando moderna, mas único, que se concentra na produção de qualidade, livros de ponta para as
comunidades de desenvolvedores, administradores e os novatos igualmente. Para mais informações, por favor visite nosso website: www.packtpub.com.
author@packtpub.com. Se sua idéia do livro ainda está em um estágio inicial e que você gostaria de discuti-lo primeiro antes de escrever uma proposta formal
livro, entre em contato conosco; um dos nossos editores de comissionamento irá entrar em contato com você.
Nós não estamos apenas à procura de autores publicados; Se você tem fortes habilidades técnicas, mas nenhuma experiência de escrita, os nossos
editores experientes podem ajudá-lo a desenvolver uma carreira de escritor, ou simplesmente obter alguma recompensa adicional para sua perícia.
Pentaho 5.0 Reportagem de Exemplo:
Guia do Iniciante
ISBN: 978-1-78216-224-7 Paperback: 342 páginas
por favor, verifique www.PacktPub.com para obter informações sobre os nossos títulos
Pentaho Dados Integração 4 livro de
receitas
ISBN: 978-1-84951-524-5 Paperback: 352 páginas
Kettle
3. Criar um projeto simples, mas completo Datamart que irá abranger todas as
principais características do PDI.
por favor, verifique www.PacktPub.com para obter informações sobre os nossos títulos