Como exportar/importar dados com HPL - High Performance Loader

Versão para impressãoEnviar para amigoVersão PDF

No Informix temos inumeros meios nativos de exportar e importar dados do banco para arquivo. Já demonstrei em outros artigos como trabalhar com o unload/load/dbload , dbexport/dbimport, onunload/onload , External Tables.
Com o HPL você pode utiliza-lo para jobs de execução diárias ou para processos de migração.
A partir da versão 11.50 xC6 passamos a ter como alternativa as EXTERNAL TABLES, considere sua utilização, ela tem se apresentado bem mais fácil de trabalhar além de ter melhor performance.

Neste artigo não irei demonstrar todos os detalhes do HPL, mas sim seu funcionamento básico para trabalhar.

  1. Breve histórico
  2. Outros tutoriais
  3. Caracteristicas
    1. Modo de execução
    2. Configurações
    3. Estrutura
    4. Banco de dados do HPL
  4. Exportanto / Importando dados
    1. Criando um job
    2. Exportando os dados
    3. Importando os dados
    4. ONPLOAD - parametros mais uteis
    5. Exportação/importação mais rápidos
    6. Utilizando vários devices em paralelo + gzip

Breve histórico


O HPL (High Performance Loader) é uma ferramenta muito flexivel, principalmente após a versão 9.40 do Informix onde passou a ser possível gerar os comandos através de scripts em linha de comando. Antes desta versão o DBA não tinha opções e era obrigado a trabalhar apenas de uma ferramenta grafica horrível (ipload), onde para configurar 3 tabelas você levaria aproximadamente uns 5 minutos.

Toda sua configuração é salva em um banco de dados no próprio Informix.

Mas esta limitação da ferramenta grafica nunca foi um empecilho para trabalhar com HPL pois a documentação deste banco de dados é muito detalhado e com isso ficou facil criar ferramentas alternativas para configura-lo. Um colega de trabalho criou em um dia uma Stored Procedure que configura automaticamente em 1 minuto todas as tabelas de um banco dados (no nosso caso era aproximadamente 500 tabelas) algo que seria inviável fazer no modo grafico.
Também é possível encontrar no repositório do IIUG códigos fontes de programas em ESQL/C que fazem o mesmo serviço através de linha de comando.

Mas na versão 9.40 foi adicionado o comando onpladm que permite que você configure os meios e formatos através de linha de comando, permitindo assim alta eficiencia e flexibilidade quando o DBA possui conhecimento básico de shell script para ajuda-lo no trabalho.

Outros tutoriais


Artigo de Andrew Ford sobre HPL , publicado na antiga Database Magazine: Parte 1, Parte 2, Parte 3

Caracteristicas


As principais caracteristicas são:
  • Trabalha com projetos, onde cada projeto possui configurações de exportação/importação de várias tabelas.
  • Suporte a arquivos do tipo COBOL, ASCII, multibyte, delimitado ou binário.
  • A exportação/importação pode ser feita diretamente para uma fita, arquivo ou direcionado para uma aplicação (pipe).
  • Permite que você controle o formato de entrada e como estes dados serão gravados no banco.
  • Executa utilizando recursos de paralelismo (desde que seu ambiente permita este tipo de recurso).
  • Pode executar a carga em qualquer IDS da sua rede, centralizando as configurações em um unico local.
  • Permite carga de tabelas em modo RAW.
  • Pode fazer a gravação dos dados diretamente nos chunks do banco, sem passar pelo buffer do banco.
  • Possui dois modo de execução, denomidados: Express e Deluxe.

Modo de execução


Existem dois modos de execução o Express e o Deluxe. A diferença entre eles está na performance e flexibilidade.

Configurações


Existem alguns parâmetros de configuração do HPL que podem ser salvo em um arquivo. Estas configurações podem afetar a performance principalmente quando utilizado paralelismo.

Estrutura


O HPL trabalha estruturado em: projetos, tabelas, devices, mapeamentos de campos, query, filtro e outros itens.
Ao trabalhar no modo express praticamente todos os itens são cadastrados automaticamente e não há necessidade de altera-los. As alterações mais comuns seria a adição de vários arquivos para exportar em paralelo (para mesma tabela) ou alterar o delimitador.

No modo deluxe já pode ser necessário algumas configurações mais detalhadas.

Banco de dados do HPL


Todas as informações de projetos, jobs, tabelas, campos, arquivos são salvos em um banco de dados no próprio informix. O nome padrão deste banco é "onpload". Você pode acessar, alterar, exportar e importar os dados deste banco.
Ao executar o comando onpload ele automaticamente cria o banco de dados se este não existir.

Para detalhes sobre os parâmetros de configurações e variaveis de ambiente leia o artigo Parâmetros de configuração do HPL


Exportanto / Importando dados


Para administrar o HPL você irá utilizar o comando onpload ou ipload (modo grafico). Para realizar a exportação/importação você pode utilizar o onpladm ou o programa onpload (este comando é chamado pelo onpladm) .
Não irei exemplificar a utilização de todos os parâmetros mas irei citar os mais uteis.

Para demonstrar a exportação e importação com HPL irei utilizar os mesmos dados do Tutorial - parte 3.
Base de dados: myfs_db
Tabela: fs_full

Criando um job


Para realizar a exportação e importação de uma tabela é preciso configura-la apenas uma vez, Para isso utilizamos o programa onpladm e com ele criamos um job para realizar o trabalho.
Cada job está relacionado apenas a uma tabela, tanto para o processo de exportação como importação
Neste exemplo irei demonstar como trabalhar no modo Express.
# Cria um job com o comando onpladm onde os parametros são:
# create job : Defini que será criado um novo job.
# j_fs_full  : Nome do novo job
# -d [device]: Especifica qual device será utilizado, se utilizado PIPE
#              deve-se especificar o comando. Caso deseje trabalhar com 
#              mais de um arquivo será necessário inclui-los manualmente 
#              depois que job for criado.
# -D [bd]    : Especifica qual é o banco de dados que a tabela pertence
# -t [tabela]: Especifica qual tabela será exportada/importada.
$ onpladm create job j_fs_full -d /tmp/fs_full.unl -D myfs_db -t fs_full
Successfully created Job j_fs_full

# Aqui executo comandos para listar alguns os objetos 
# criado pelo job e relacionados apenas a ele.
# Os objetos que exibem L ou U são referentes a Load e Unload
$ onpladm list job
j_fs_full           [L]
j_fs_full           [U]

$ onpladm list device
j_fs_full

$ onpladm list project
default

$ onpladm list map
j_fs_full           [L]
j_fs_full           [U]


Exportando os dados


Agora que já temos o job criado, basta executar a exportação.
Irei executar exportações com o comando unload e em seguida com o HPL, utilizando o comando time para medir o tempo de execução de cada um.
O formato de exportação padrão do HPL é igual ao do UNLOAD, delimitado por "|" (PIPE). Portando os arquivos gerado por eles são compativeis.

Neste ambiente que executei meus testes os chunks do banco de dados estão configurados com cooked file em uma partição EXT2 (que não contém journaling), portanto estou suscetivel a caching de FS o que pode gerar algumas diferenças de performance. Mas mesmo neste ambiente poderemos percerber que a execução com o HPL será bem mais rápido.

# Exporto a tabela fs_full (53 MB em arquivo texto, 320 MB no banco) com 
# o comando SQL unload.
$ time echo "unload to /tmp/fs_full.unl select * from fs_full" | dbaccess myfs_db
Database selected.
260474 row(s) unloaded.
Database closed.
real    0m46.278s
user    0m22.077s
sys     0m5.324s

# Exporto os mesmos dados com o comando onpload. 
# Os parametros utilizados são:
# -j [job]  : Espcifica qual job será executado.
# -f[opcao] : Define que será uma exportação (Unload)
$ time onpload  -j j_fs_full -fu
real    0m20.155s
user    0m14.033s
sys     0m1.544s


Importando os dados


Aqui irei reimportar o arquivo que exportamos. Para isso será necessário limpar a tabela já existente.
Também irei demonstrar o tempo de execução da importação com o LOAD para comparação.
# Limpo os dados da tabela fs_full com o comando TRUNCATE 
# onde especifico o parâmetro "drop storage" para não manter os espaços
# já alocados (extents).
# Veja no Blog do Vagner Pontes sobre o TRUNCATE
$ echo "truncate table fs_full drop storage" | dbaccess myfs_db
Database selected.
Table truncated.
Database closed.

# Como irei demonstrar a execução com o comando LOAD será necessário
# desativar a utilização do Logical Log.
# Se fosse-mos carregar a tabela apenas com o HPL no modo express
# isso não seria necessário.
$ ontape -s -L 0 -N myfs_db -t STDIO > /dev/null
$ time echo "load from /tmp/fs_full.unl insert into  fs_full" | dbaccess myfs_db
Database selected.
260474 row(s) loaded.
Database closed.
real    3m30.833s
user    0m33.978s
sys     0m7.188s

# limpo novamente a tabela
$ echo "truncate table fs_full drop storage" | dbaccess myfs_db
Database selected.
Table truncated.
Database closed.

# Realizo a carga com o comando onpload do HPL
# Repare que a unica diferença do comando utilizado para exportar
# é o parâmetro -fl , que aqui indica realizar um Load.
$ time onpload  -j j_fs_full -fl
real    1m8.157s
user    0m6.016s
sys     0m1.292s

ONPLOAD - parametros mais uteis


 
-f[opcoes] 
  p : O device é um PIPE, ou seja, você pode especificar um comando como 
      o GZIP para receber do STDIN e enviar para o STDOUT.
  u : Unload - exportação
  l : Load - importação
-e [qtde] : Quantidade maxima de erros antes de abortar o processo.
-i [qtde] : Exibir mensagem de linhas processadas a cada N linhas. 
-n [qtde] : Carregar apenas N linhas por device.
-s [qtde] : Pular as N primeiras linhas de cada device.
-I [qtde] : Comitar após N linhas processadas. Valido apenas para o 
            modo deluxe.
-l [arq]  : Nome do arquivo de log a ser gerado
-R [arq]  : Nome base do arquivo de dados rejeitados e filtrados (sem extenção).
            Arquivos .ref e .flt

Exportação/importação mais rápidos


Se você precisa exportar os dados apenas para uma manutenção no mesmo banco ou migrar para outra maquina da mesma arquitetura e versão do IDS, utilize a opção "no conversion".
Este modo de exportação é conhecida como exportação RAW, pois salva um dump dos dados sem converte-los, isso evita processamento de CPU desnecessário, aumentando considerávelmente a performance do processo.

Pessoalmente considero este modo de exportação similar aos comandos onunload/onload já que eles realizam dump de paginas. Mas aqui temos uma flexibilidade muito maior, já que podemos refazer a estrutura de armazenamento da tabela (fragmentação), algo que o com o onunload/onload não é possível.

# Quando exportado um arquivo com HPL ele tem o mesmo formato do UNLOAD
$ head -n2 fs_full.unl
|/|/||755|drwxr-xr-x|ext2|d|d|root|root|0|0|4096|2|1|2009-04-04 21:12:51.000|2009-06-18 15:20:36.000|2009-06-18 15:20:36.000|2049|
|lost+found|/lost+found||700|drwx------|ext2|d|d|root|root|0|0|16384|11|1|2009-03-06 10:04:24.000|2009-03-06 10:04:24.000|2009-03-06 10:04:24.000|2049|

# Recrio o job com o parametro "-n" para defini-lo como "no-conversion"
$ onpladm create job  j_fs_full2 -d /tmp/fs_full.unl -D myfs_db  -t fs_full  -n
Successfully created Job j_fs_full2

# Exporto sem conversão , uncluindo a opção "n" no parametro "-f"
$ time onpload  -j j_fs_full2 -fu
real    0m14.314s
user    0m3.344s 
sys     0m2.480s 

# Veja que o formato do arquivo é diferente. 
$ head fs_full.unl
                                                                                                                                                                                                                                                                                                           /                                                                                                   /                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ódrwxr-xr-xext2      ddroot           root           1Ç                                                                                                                          
        3Ç      $Ç                                                                                                                                                                                                                                                                                                                 lost+found                                                                                          /lost+found                                 

Utilizando vários devices em paralelo + gzip


Aqui irei colocar dois exemplos em um unico código, irei demonstrar como exportar para mais de um device em paralelo e já gerar o arquivo compactado.
Altero o job já existente "j_fs_full2"
# Listo os devices existentes
$ onpladm list device
j_fs_full
j_fs_full2

# Salvo a configuração do device no arquivo "j_fs_full2.device"
$ onpladm describe device j_fs_full2 -F j_fs_full2.device

# Conteudo do arquivo salvo
$ cat j_fs_full2.device
BEGIN  OBJECT  DEVICEARRAY    j_fs_full2

BEGIN  SEQUENCE
TYPE                     FILE
FILE                     /tmp/fs_full.unl
TAPEBLOCKSIZE            0
TAPEDEVICESIZE           0
PIPECOMMAND
END  SEQUENCE

END  OBJECT

# Edito o arquivo, onde duplico o bloco BEGIN/END SEQUENCE
# altero o tipo para PIPE e rescrevo o comando no parametro 
# correspondente.
# Observação: É excencial que o comando esteja entre aspas dupla
$ vi j_fs_full2.device

# Altero o device para a nova configuração
$ onpladm  modify object -F j_fs_full2.device
Successfully modified object DEVICEARRAY   j_fs_full2

# Listo a configuração para verificação.
$ onpladm describe device j_fs_full2
BEGIN  OBJECT  DEVICEARRAY    j_fs_full2

BEGIN  SEQUENCE
TYPE                     PIPE
FILE
TAPEBLOCKSIZE            0
TAPEDEVICESIZE           0
PIPECOMMAND              "gzip -3c > /tmp/fs_full.1.unl.gz"
END  SEQUENCE

BEGIN  SEQUENCE
TYPE                     PIPE
FILE
TAPEBLOCKSIZE            0
TAPEDEVICESIZE           0
PIPECOMMAND              "gzip -3c > /tmp/fs_full.2.unl.gz"
END  SEQUENCE

END  OBJECT

# Executo a exportação 
$ time onpload  -j j_fs_full2 -fu
real    0m18.199s
user    0m10.965s
sys     0m2.832s

# Ai está, os arquivos gerados já compactados.
# Quando os dados são exportados para mais de um device, eles são 
# gerado em modo round robin
$ ls -oh *gz
-rw-r----- 1 informix 4.4M 2009-09-14 23:26 fs_full.1.unl.gz
-rw-r----- 1 informix 4.4M 2009-09-14 23:26 fs_full.2.unl.gz

0
Ainda não votado
Sua avaliação: Nenhum