Firebird: Importação e Exportação de dados diretamente do BD

1

Posted on : 28-03-2012 | By : Paulo H Oliveira | In : Firebird

Uma das opções que sempre temos necessidade de ter em nosso sistema é a importação e exportação de dados através de arquivos textos. E existem diversas formas para realizar essas operações tendo todas elas um resultado positivo, mas o que difere entre elas é a velocidade com que o processo é executado, pois dependendo da quantidade de registros exportados o processamento poderá ficar lento devido a necessidade de ler os registros do banco de dados, montando um cache dos dados, e somente depois descarregá-los para o arquivo texto.

Data da última atualização: 14/05/2004

Mas para nós que utilizamos o Interbase/FireBird temos a disposição uma opção de criar uma tabela dentro do banco de dados que utiliza um arquivo texto externo ao banco para gravar os registros. Sendo assim com essa tabela poderemos ler ou gravar dados dentro do arquivo texto usando diretamente comandos SQL, tornando o processo de importação ou exportação de dados bastante rápido, mesmo que a quantidade de dados a serem processados for grande.

Criando a tabela externa

O comando que utilizaremos para criar a tabela externa dentro do banco de dados é o CREATE TABLE com a opção EXTERNAL FILE, veja a sintaxe da instrução SQL:

CREATE TABLE TABEXPORTA
EXTERNAL FILE ‘C:\EXPORTAR\ARQUIVO.TXT’
( CODIGO char(12), NOME char(15) , QUEBRA char(2) )

Na instrução de CREATE TABLE acima indicamos o nome TABEXPORTA que é o nome ao qual a tabela ficará visível dentro do banco de dados. Após a instrução de EXTERNAL FILE indicamos a opção ‘C:\EXPORTAR\ARQUIVO.TXT’ esse é o caminho e o nome do arquivo texto que será gerado e que conterá os registros da tabela externa. Ao final do comando indicamos a estrutura que o arquivo texto terá:

( CODIGO char(12), NOME char(20), QUEBRA char(2) )

Como estaremos trabalhando com arquivo texto, devemos indicar no final de cada linha a instrução de quebra de linha, por esse motivo que criei no final da estrutura um campo chamado QUEBRA ao qual armazenará exatamente o caracter de quebra de linha.

Exportando dados para o arquivo texto

Como primeiro exemplo, vamos montar uma exportação de dados para um arquivo texto, isso é, iremos ler os dados de uma tabela existente dentro do banco de dados e iremos exportá-los para o arquivo texto.

Os comandos que iremos executar a seguir são comandos SQL, portanto podem ser executados diretamente pelo IBConsole, IBExpert ou qualquer outra ferramenta de manutenção no banco que você utilize.

No exemplo a seguir estarei trabalhando com a tabela EMPLOYEE do banco EMPLOYEE.GDB, que está disponível no seguinte diretório:

C:\Program Files\Common Files\Borland Shared\Data\EMPLOYEE.GDB

Dessa tabela irei utilizar somente alguns campos, veja exemplo no Select abaixo:

SELECT EMP_NO, FIRST_NAME, HIRE_DATE, SALARY
FROM EMPLOYEE

Para exportar os dados dessa tabela EMPLOYEE para um arquivo texto, iremos primeiro criar o arquivo texto dentro do banco de dados, portanto usaremos a instrução de Create Table, conforme exemplo abaixo:

CREATE TABLE TABEXPORTA
EXTERNAL FILE ‘C:\EXPORTAR\ARQUIVO.TXT’ (CODIGO char(12),  NOME char(20),  DATA char(11), SALARIO char(20),QUEBRA char(2) )

Observe que todos os campos foram criados do tipo CHAR, pois estaremos trabalhando com um arquivo texto, e os tamanhos foram definidos para haver compatibilidade entre a estrutura da tabela de origem dos dados, no caso a tabela CADASTRO, e a estrutura do arquivo texto gerado que será o destino dos registros na exportação dos dados.

Bem, após executar a instrução acima a tabela externa será criada e assim poderemos fazer a exportação dos dados.

A exportação dos dados será realizada diretamente através da instrução SQL descrita abaixo:

INSERT INTO TABEXPORTA (CODIGO, NOME, DATA, SALARIO)
SELECT EMP_NO, FIRST_NAME, HIRE_DATE, SALARY
FROM EMPLOYEE

Neste momento os dados foram copiados para a tabela TABEXPORTA. E poderão ser lidos através de uma instrução de SELECT, como se fosse uma tabela normal. Execute o exemplo que segue e veja que os dados estarão visíveis normalmente:

SELECT CODIGO, NOME, DATA, SALARIO FROM TABEXPORTA

Utilizando o NotePad também poderemos visualizar o arquivo texto gerado ao qual ficará parecido com a imagem que segue abaixo:

Observe que os registros não estão separados por linha, isso ocorre porque como as instruções executadas acima foram executadas diretamente pelo IBExport ou IBConsole,  então não utilizamos o campo QUEBRA para armazenar o caracter de salto de linha para o arquivo texto.

Importando dados do arquivo texto

Aproveitando o arquivo texto criado acima, através da exportação dos dados, iremos fazer o inverso agora, importar os dados do arquivo texto para uma tabela do banco de dados.

Como primeiro passo, vamos criar uma nova tabela dentro do banco de dados com a estrutura parecida com a tabela externa. Veja instrução abaixo:

CREATE TABLE TABELA_DESTINO (CODIGO INTEGER, NOME VARCHAR(20), DATA DATE, SALARIO DOUBLE PRECISION )

Após criar a tabela no banco de dados, podemos ler os dados do arquivo texto e importá-los para a nova tabela. E para isso utilizaremos a seguinte instrução:

INSERT INTO TABELA_DESTINO (CODIGO, NOME, DATA, SALARIO)
SELECT CODIGO, NOME, DATA, SALARIO FROM TABEXPORTA

Neste momento os registros do arquivo texto foram importados para a nova tabela criada dentro do banco.

Veja que apenas utilizando as instruções SQL do Interbase e do FireBird, já podemos importar e exportar dados através de arquivos textos externos.

Criando um projeto de exportação no Delphi

A idéia do exemplo que iremos montar é fazer uma exportação de dados genérica, isso é, iremos indicar através de um select os dados que iremos exportar, a rotina irá ler a estrutura desse Select, gerar uma tabela externa e depois efetuar a exportação dos dados para o arquivo texto. Portanto mãos a obra.

Crie um novo projeto;

Abaixo estou listando os componentes que irei utilizar neste projeto e as propriedades que configurei, a lista está na seqüência que devemos colocar os componentes para evitar diferenças no projeto.

Componente StatusBar

Name = StatusBar1

Componente Panel

Name = Panel1
Align = alClient
Caption = vazio

Dentro do componente Panel iremos colocar os demais componentes que seguem abaixo:

Componente Label
Name = Label3
Caption = Instrução SQL para ler o arquivo de origem dos dados
Top = 6
Left = 13

Componente Memo
Name = Memo_SQL
Top = 22
Left = 8
Height = 83

Componente Label
Name = Label4
Caption = Path/Nome do arquivo texto que será gerado
Top = 112
Left = 13

Componente Edit
Name = Edt_ArqTxt
Text = EXPORTAR.TXT
Top = 126
Left = 8

Componente CheckBox
Name = Check_Cabec
Caption = Cabeçalho
State = cbChecked
Top = 155
Left = 19

Componente Label
Name = Label2
Caption = Separador de campos
Top = 156
Left = 119

Componente Edit
Name = Edit_Separador
Text = ,
Top = 153
Left = 231

Componente CheckBox
Name = CheckBox1
Caption = Visualizar o arquivo texto ao final
Top = 155
Left = 299

Componente Button
Name = Button3
Caption = Processar exportação dos dados
Top = 179
Left = 8

Componente Label
Name = Label1
Caption = Log de execução
Top = 209
Left = 13

Componente Memo
Name = Memo_Log
Top = 225
Left = 8
Height = 202

Componente Button
Name = Button1
Caption = Visualizar arquivo texto
Top = 432
Left = 270

Componente IBDatabase
Name = IBDatabase1
DatabaseName = C:\Program Files\Common Files\Borland Shared\Data\EMPLOYEE.GDB

Componente IBTransaction
Name = IBTransaction1

Componente IBQuery
Name = IBQuery1
UniDirectional = True

Essa propriedade UniDirectional é utilizada para que não seja criado o Cachê de registros na memória, pois no momento em que o projeto ler a estrutura da tabela de origem não é necessário visualizar os registros do mesmo.

Para esses três componentes de conexão basta você conectá-los ao seu banco de dados, portanto não irei detalhar esse procedimento.

Após montar o form do projeto o mesmo ficará parecido com a imagem abaixo:

Estando com o nosso form construído, iremos montar as instruções de programação do delphi.

Como primeiro passo acesse o evento onShow do form e inclua a seguinte instrução:

procedure TForm1.FormShow(Sender: TObject);
begin
IBDataBase1.Open;
IBTransaction1.Active := True;
{ path e nome do arquivo texto a ser gerado }
Edt_ArqTxt.Text := ExtractFilePath(Application.ExeName)+’EXPORTAR.TXT’;
end;

Agora iremos criar uma procedure ao qual irá nos auxiliar a executar as instruções SQL no componente IBQuery e criar um Log das instruções executadas. Portanto crie a procedure descrita a seguir:

procedure TForm1.UsaIBQuery(cSQL, cMsg: String; cExec: Boolean);
begin
StatusBar1.SimpleText := cMsg;
try
IBQuery1.Close;
IBQuery1.SQL.Text := cSQL;
{ Apresenta a instrução que será executada na IBQuery }
Memo_Log.Lines.Add( ‘=======’+cMsg+’========’ );
Memo_Log.Lines.Add( IBQuery1.SQL.Text );
Memo_Log.Lines.Add( ” );
if cExec then
begin
IBQuery1.ExecSQL;
IBTransaction1.Commit;
end
else
IBQuery1.Open;
except on E: EDataBaseError do
begin
ShowMessage(‘Erro: ‘+cMsg
+#13+’Original: ‘+E.Message);
Form1.Panel1.Enabled := True;
IBTransaction1.Rollback;
Abort;
end;
end;
end;

Essa procedure será declarada dentro da seção private, conforme exemplo:

private
procedure UsaIBQuery(cSQL, cMsg: String; cExec: Boolean);
public
{ Public declarations }
end;

Agora iremos criar o evento onClick do Button3, que será o botão responsável pela exportação dos dados. E é exatamente neste botão que iremos montar todas as instruções SQL dos passos descritos acima para a exportação dos dados.

Abaixo irei descrever somente algumas partes da procedure, pois são as partes importantes da rotina de exportação:

for i:=0 to IBQuery1.Fields.Count-1 do
begin
Case IBQuery1.Fields[i].DataType of
ftString:  nTam := IBQuery1.Fields[i].DataSize;
ftSmallint, ftInteger, ftWord: nTam := 8;
ftFloat, ftCurrency, ftBCD: nTam := 20;
ftDate, ftTime: nTam := 11;
ftDateTime: nTam := 20;
end;
{ Se o tamanho do nome do campo for maior que nTam encontrado,
então deixa o nTam do tamanho do nome do campo }
if Length( IBQuery1.Fields[i].FieldName ) > nTam then
nTam := Length( IBQuery1.Fields[i].FieldName );

{inclui a vírgula entre os campos do script}
if cScript <> ” then
cScript := cScript +’,';

Nesta instrução acima é lido a estrutura da tabela de origem para que assim possamos criar o arquivo texto de destino com a estrutura idêntica a tabela de origem.

Alguns tamanhos de campos foram definidos como padrão para que as estruturas fiquem compatíveis.

{ o usuário indicou que precisa do cabeçalho no arquivo texto }
if (Check_Cabec.Checked) and (cCabecalho <> ”) then
begin
{ inclui o separador de campos definido pelo usuário }
if Trim(Edit_Separador.Text) <> ” then
cCabecalho := cCabecalho + ‘||’+QuotedStr(‘ ‘+Edit_Separador.Text+’ ‘);
cCabecalho := cCabecalho + ‘,’;
end;
cCabecalho := cCabecalho + QuotedStr(UpperCase( IBQuery1.Fields[i].FieldName ));

Nesta instrução é criada uma string que conterá as instruções do cabeçalho do arquivo texto, observe que já estamos incluindo os separadores dos campos.

cScript := cScript + UpperCase( IBQuery1.Fields[i].FieldName ) + ‘ CHAR( ‘ + IntToStr(ntam+4)+’ ) ‘;
Application.ProcessMessages;
end;
{ Define o início do script para criação da tabela externa }
cScript := ‘CREATE TABLE ‘+nArqInt+’ EXTERNAL FILE ‘ +
QuotedStr(nArqTxt)+’ ( ‘+cScript;
{ Define o final do script para criação da tabela externa
incluimos o caracter de quebra de linha }
cScript := cScript + ‘, QUEBRA CHAR(2) ) ‘;

Nesta instrução geramos o script que ira criar a tabela externa dentro do banco de dados, criando também o arquivo texto.

{ Registra a tabela externa dentro do banco de dados }
UsaIBQuery(cScript, ‘Criando tabela externa’, True);

Neste momento o script gerado é enviado ao componente IBQuery para ser executado gerando a tabela externa.

if (Check_Cabec.Checked) then
begin
cScript := ‘ INSERT INTO ‘+nArqInt+
‘ SELECT ‘+cCabecalho+’,'+QuotedStr(#13#10)+’ FROM RDB$DATABASE’;
{ Exportando cabeçalho para a tabela externa }
UsaIBQuery(cScript, ‘Exportando cabeçalho para a tabela externa’, True);
end;

Se o usuário checou a opção que indica para criar o cabeçalho no arquivo texto, então o projeto irá executar a instrução SQL que irá incluir as informações de cabeçalho no arquivo texto.

{ Monta o script de insert que irá exportar os dados para o arquivo texto }
{ Pega o SQL do início até o FROM }
cScript := Copy(Memo_SQL.Text, 1, Pos(‘FROM’, Memo_SQL.Text)-1);
{ Inclui os separadores nos campos caso o usuário tenha definido }
if Trim(Edit_Separador.Text) <> ” then
cScript := StringReplace(cScript, ‘,’ ,
‘||’+QuotedStr(‘ ‘+Edit_Separador.Text+’ ‘)+’,’
,[rfReplaceAll]);
cScript := cScript + ‘ , ‘ + QuotedStr(#13#10)+’ ‘;
{ Pega o SQL do FROM até o Fim }
cScript := cScript + Copy(Memo_SQL.Text, Pos(‘FROM’, Memo_SQL.Text),
Length(Memo_SQL.Text));
{ Exportando dados para o arquivo texto }
cScript := ‘ INSERT INTO ‘+nArqInt+’ ‘+cScript;

Nesta instrução acima criamos o script responsável pela exportação dos dados da tabela de origem para o arquivo texto de destino. Nela já estamos incluindo os separadores, definidos pelo usuário, para que ao exportar os dados os separadores já sejam incluídos automaticamente.

UsaIBQuery(cScript, ‘Exportando dados para a tabela externa’, True);

Após concluir o script o mesmo é enviado ao componente IBQuery para ser executado.

StatusBar1.SimpleText := ‘Exportação concluida’;  Panel1.Enabled := True;
finally
if nTabCriada then
begin
{ apaga o registro de dentro do banco de dados }
cScript := ‘DROP TABLE ‘+nArqInt;
UsaIBQuery(cScript, ‘Excluindo registro da tabela externa do banco’, True);
end;
{ fecha todas as conexões }
StatusBar1.SimpleText := ‘Fechando o acesso ao banco de dados’;
IBQuery1.Close;
end;

Para finalizar o processo de exportação a tabela externa gerada dentro do banco de dados é excluída do banco, mas esse processo não irá apagar o arquivo texto gerado na exportação. Na verdade isso fará com que o mesmo seja liberado, pois o banco não terá mais nenhuma ligação com o arquivo externo.

{ visualiza o arquivo txt }
if FileExists( nArqTxt ) then
begin
Form2.Memo_Arquivo.Lines.LoadFromFile( nArqTxt );
Form2.ShowModal;
end;
end;

Caso o arquivo texto tenha sido criado corretamente, então iremos visualizá-lo através de um componente Memo colocado no Form2.

A procedure completa do evento onClick do Button3 poderá ser visualizada no final da matéria.

Finalizando a Unit do Form1

Bem, neste momento toda a nossa rotina responsável pela exportação dos dados já foi criada, agora somente iremos finalizar os eventos desse Form1.

Declare na seção implementation a unit do Form2, conforme exemplo:

implementation
uses Unit2;
{$R *.dfm}

Crie o evento onClick do Button1, ao qual irá visualizar o conteúdo do arquivo texto através de um memo no form2.

procedure TForm1.Button1Click(Sender: TObject);
begin
{ visualiza o arquivo txt }
if FileExists( UpperCase( Edt_ArqTxt.Text ) ) then
begin
Form2.Memo_Arquivo.Lines.LoadFromFile( UpperCase( Edt_ArqTxt.Text ) );
Form2.ShowModal;
end;
end;

E crie o evento onClose do Form1 ao qual irá fechar as conexões do banco de dados:

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
{ Fecha as conexão com o banco de dados }
IBTransaction1.Active := False;
IBDataBase1.Close;
end;

Criando o Form2

O form2 é bastante simples, pois a sua utilização é somente para mostrar o conteúdo do arquivo texto gerado na exportação. Neste form coloque os seguintes componentes:

Componente Panel
Align = alBottom
Caption = vazio

Componente Memo
Name = Memo_Arquivo
Align = alClient

Dentro do Panel coloque um componente Button com o Caption = Fechar

E no evento onclick deste Button coloque a seguinte instrução:

procedure TForm2.Button1Click(Sender: TObject);
begin
Form2.Close;
end;

Após construir o Form2 o mesmo ficará com a seguinte aparência:

Neste momento nosso pequeno e interessante projeto está pronto para ser compilado e testado, mas antes vamos verificar as dicas importantes descritas abaixo.

Dicas importantes

1- A instrução SQL a ser utilizada para visualizar os dados, deve ser escrita contendo o nome dos campos, pois a rotina irá utilizar esses nomes para montar a instrução de exportação dos dados e a inclusão dos separadores. Exemplo da instrução SQL:

SELECT E.EMP_NO, E.FIRST_NAME FROM EMPLOYEE E

Poderíamos ter montado de uma forma que não fosse obrigatória a indicação dos campos na instrução SQL, mas o problema não se encontra nos SELECTS simples e sim nos compostos de várias tabelas, pois nesses devemos indicar o nome das tabelas e o nome dos campos no Select, veja exemplo de um SELECT composto:

SELECT E.EMP_NO, E.FIRST_NAME, E.HIRE_DATE, E.SALARY, E.DEPT_NO, D.DEPARTMENT
FROM EMPLOYEE E
LEFT OUTER JOIN DEPARTMENT D ON (D.DEPT_NO = E.DEPT_NO)
ORDER BY E.EMP_NO

Neste SELECT de exemplo estamos visualizando os registros de duas tabelas e esses registros serão exportados para o arquivo texto normalmente.

2- Outra dica muito importante para quem estiver utilizando o FireBird 1.5. Nessa versão devemos habilitar para que o mesmo possa trabalhar com arquivos externos, pois por padrão essa opção está desligada. Para habilitar essa opção simplesmente devemos acessar o arquivo Firebird.conf  que está no diretório principal do FireBird_1_5. Esse arquivo pode ser acessado através do NotePad. Dentro desse arquivo iremos incluir como última linha a seguinte instrução:

ExternalFileAccess = Full

Após incluir essa instrução feche o arquivo e reinicialize o servidor.

Testando o projeto de exemplo

Para utilizar o projeto é bastante simples, o primeiro passo é escrever a instrução SQL que irá visualizar os dados a serem exportados. Em seguida devemos indicar a path e o nome do arquivo texto ao qual será gerado na exportação, indicar se vai incluir Cabeçalho e o Separador de Campos no arquivo texto e pronto. Agora basta clicar sobre o botão para iniciar o processo de exportação dos dados. Ao final da exportação o arquivo texto poderá ser visualizado pelo componente Memo do Form2.

Segue abaixo a procedure completa do evento onclick do Button3, ao qual faz todo o processamento de exportação dos dados.

procedure TForm1.Button3Click(Sender: TObject);
var nArqTxt, nArqInt, cCabecalho, cScript : string;
nTam, i: INTEGER;
nTabCriada: Boolean;
begin
try
Panel1.Enabled := False;

{ Nome da tabela externa criada dentro do banco }
nArqInt := ‘TABEXPORTA’;

{ limpa as variáveis strings onde serão armazenadas a estrutura da tabela }
nTabCriada := False;
cCabecalho := ”; { Nome dos campos incluidos no cabecalho do texto }
nTam := 0; { Tamanho de cada campo a ser exportado }
cScript := ”; { Script para gerar a tabela externa }
{ nome do arquivo texto a ser gerado }
nArqTxt := UpperCase( Edt_ArqTxt.Text );
{ se o arquivo texto já existe, apaga o arquivo }
if FileExists( nArqTxt ) then
DeleteFile( nArqTxt );

{ Instrução que irá ler a instrução SQL colocada pelo usuário no Memo_SQL }
UsaIBQuery(Memo_SQL.Text, ‘Lendo estrutura da tabela de origem’, False);

StatusBar1.SimpleText := ‘ Montando estrutura da tabela externa ‘;
{ lê a estrutura da origem para gerar o arquivo texto de destino }
for i:=0 to IBQuery1.Fields.Count-1 do
begin
Case IBQuery1.Fields[i].DataType of
ftString:  nTam := IBQuery1.Fields[i].DataSize;
ftSmallint, ftInteger, ftWord: nTam := 8;
ftFloat, ftCurrency, ftBCD: nTam := 20;
ftDate, ftTime: nTam := 11;
ftDateTime: nTam := 20;
end;
{ Se o tamanho do nome do campo for maior que nTam encontrado,
então deixa o nTam do tamanho do nome do campo }
if Length( IBQuery1.Fields[i].FieldName ) > nTam then
nTam := Length( IBQuery1.Fields[i].FieldName );

{inclui a vírgula entre os campos do script}
if cScript <> ” then
cScript := cScript +’,';

{ o usuário indicou que precisa do cabeçalho no arquivo texto }
if (Check_Cabec.Checked) and (cCabecalho <> ”) then
begin
{ inclui o separador de campos definido pelo usuário }
if Trim(Edit_Separador.Text) <> ” then
cCabecalho := cCabecalho + ‘||’+QuotedStr(‘ ‘+Edit_Separador.Text+’ ‘);
cCabecalho := cCabecalho + ‘,’;
end;

cCabecalho := cCabecalho + QuotedStr( UpperCase( IBQuery1.Fields[i].FieldName ) );

cScript := cScript + UpperCase( IBQuery1.Fields[i].FieldName ) + ‘ CHAR( ‘+inttostr(ntam+4)+’ ) ‘;

Application.ProcessMessages;
end;

{ Define o início do script para criação da tabela externa }
cScript := ‘CREATE TABLE ‘+nArqInt+’ EXTERNAL FILE ‘+QuotedStr(nArqTxt)+’ ( ‘+cScript;
{ Define o final do script para criação da tabela externa
incluimos o caracter de quebra de linha }
cScript := cScript + ‘, QUEBRA CHAR(2) ) ‘;

{ Registra a tabela externa dentro do banco de dados }
UsaIBQuery(cScript, ‘Criando tabela externa’, True);
nTabCriada := True;

if (Check_Cabec.Checked) then
begin
cScript := ‘ INSERT INTO ‘+nArqInt+
‘ SELECT ‘+cCabecalho+’,'+QuotedStr(#13#10)+’ FROM RDB$DATABASE’;

{ Exportando cabeçalho para a tabela externa }
UsaIBQuery(cScript, ‘Exportando cabeçalho para a tabela externa’, True);
end;

{ Monta o script de insert que irá exportar os dados para o arquivo texto }
{ Pega o SQL do início até o FROM }
cScript := Copy(Memo_SQL.Text, 1, Pos(‘FROM’, Memo_SQL.Text)-1);

{ Inclui os separadores nos campos caso o usuário tenha definido }
if Trim(Edit_Separador.Text) <> ” then
cScript := StringReplace(cScript,’,',’||’+QuotedStr(‘ ‘+Edit_Separador.Text+’ ‘)+’,',[rfReplaceAll]);

cScript := cScript + ‘ , ‘ + QuotedStr(#13#10)+’ ‘;

{ Pega o SQL do FROM até o Fim }
cScript := cScript + Copy(Memo_SQL.Text, Pos(‘FROM’, Memo_SQL.Text), Length(Memo_SQL.Text));

{ Exportando dados para o arquivo texto }
cScript := ‘ INSERT INTO ‘+nArqInt+’ ‘+cScript;
UsaIBQuery(cScript, ‘Exportando dados para a tabela externa’, True);

StatusBar1.SimpleText := ‘Exportação concluida’;  Panel1.Enabled := True;
finally
if nTabCriada then
begin
{ apaga o registro de dentro do banco de dados }
cScript := ‘DROP TABLE ‘+nArqInt;
UsaIBQuery(cScript, ‘Excluindo registro da tabela externa do banco’, True);
end;
{ fecha todas as conexões }
StatusBar1.SimpleText := ‘Fechando o acesso ao banco de dados’;
IBQuery1.Close;
end;
{ visualiza o arquivo txt }
if FileExists( nArqTxt ) then
begin
Form2.Memo_Arquivo.Lines.LoadFromFile( nArqTxt );
Form2.ShowModal;
end;
end;

Conclusão

Bem é isso amigos, neste artigo podemos conhecer mais uma característica do banco de dados Interbase/FireBird. O projeto que criamos foi até simples, a idéia é mostrar como podemos utilizar essas instruções para criar uma exportação de dados diretamente do banco para o arquivo texto.

Um grande abraço a todos.

O projeto de exemplo referente a este artigo está disponível para download aqui.

Sobre o Autor

André Colavite
Consultor Técnico do The Club

Compartilhe :

  • Stumble upon
  • twitter

Comentários (1)

Ótima matéria. Parabéns

Escreva um comentário

Security Code: