Acessando o banco de dados Oracle a partir do Delphi

Em vista de muitos hoje possuírem sistemas rodando com banco de dados Oracle, resolvemos publicar em detalhes todos passos necessários para se conectar a um banco Oracle a partir do Delphi de modo nativo (usando BDE) e através do ODBC. Temos observado também que dúvidas sobre este assunto estão sempre presentes nas listas de discussão sobre Delphi e sobre Oracle.

Utilizamos com bons resultados as versões do Delphi 2.0 até a 4.0, BDE versões 4.5 e 5.0, e o Oracle7 Workgroup Server Release 7.3.2.1. Naturalmente tais informações serão de grande ajuda para configuração em outras versões.

Passos:

1 - Caso tenha instalado em sua máquina algum cliente do Oracle 16 bits, poderá ter algum tipo de conflito com drives de 32 bits. Portanto, desinstale todos os clientes Oracle e instale somente o cliente Oracle 32 bits. Normalmente isto é feito a partir do CD de instalação do Oracle executando o programa d:\win95\install\setup.exe

2 - Ao executar o instalador do cliente Oracle para Windows 95, você deverá de inicio informar o idioma (o mesmo que foi informado durante a instalação do próprio banco), tendo o English como padrão.

3 - Entre com o nome da empresa e o diretório onde serão armazenados os arquivos do cliente Oracle.

4 - Será solicitado o tipo da instalação. Escolha a opção "Selective Products Install".

5 - Será apresentada uma lista dos produtos ou componentes disponíveis. Apesar de poder instalar todos, serão apenas necessários para a conexão com o banco Oracle a partir do Delphi os seguintes componentes:

Sql *Net Client (para criação do alias no cliente Oracle)

Oracle Installer (para instalar/remover componentes)

6 - Selecione os protocolos desejados para comunicação com o banco, ou poderá deixar selecionado a sugestão do instalador e prosseguir.

7 - Após completar 100% da instalação, você visualizará os componentes instalados:

Oracle Installer
Oracle Named Pipes Adapter (protocolo de acordo com sua rede)

Oracle SPX Adapter (protocolo de acordo com sua rede)

Oracle TCP/IP Adapter (protocolo de acordo com sua rede)

Required Support Files

Sql *Net Client

8 - Saia do instalador. Não será necessário reiniciar a máquina por enquanto.

9 - Clique no botão iniciar -> programas -> Oracle for windows 95 -> Sql Net Easy Configuration

10 - Selecione "Add Database Alias", e clique OK

11 - Informe na sequência:

Database Alias (nome na sua máquina que representará o acesso ao banco)

Escolha o Protocolo (normalmente TCP/IP)

TCP/IP Host Name (informe o numero IP do servidor Oracle)

Database Instance (nome da instância do banco, consulte o DBA)

12 - Clique em "yes" e saia do Sql Net Easy Configuration

13 - Chame o BDE Administrator, e clique na guia Configuration -> Drivers ->Native e selecione ORACLE. Como sugestão use as seguintes configurações:

VERSION
  4.0

TYPE
  SERVER

DLL32
  SQLORA32.DLL

VENDOR INIT
  ORA73.DLL

DRIVER FLAG
 (DEIXAR VAZIO)

TRACE MODE
  0

BATCH COUNT
  200

BLOB SIZE
  32

BLOBS TO CACHE
  64

ENABLE BCD
  FALSE

ENABLE INTEGERS
  FALSE

ENABLE SCHEMA CACHE
  FALSE

LANGDRIVER
  (DEIXAR VAZIO)

LIST SYNONYMS
  NONE

MAX ROWS
  –1

NET PROTOCOL
  TNS

OBJECT MODE
  TRUE

OPEN MODE
  READ/WRITE

ROWSET SIZE
 20

SCHEMA CACHE DIR
 (DEIXAR VAZIO)

SCHEMA CACHE SIZE
  8

SCHEMA CACHE TIME
  –1

SERVER NAME
  (COLOQUE O NOME DA INSTANCIA DO BANCO, DEFAULT: ORCL)

SQLPASSTHRU MODE SHARED
  AUTOCOMMIT

SQLQRYMODE
   SERVER

USER NAME
  (NOME DE USUARIO, OPCIONAL)

14 - Clique no item de menu Object -> Apply

15 - Agora precisamos apenas criar um Alias que será enxergado no Delphi. Para isso, clique na guia Database, clique com o botão direito do mouse sobre o item da lista ´Databases´ e selecione a opção ´New´. Escolha a opção ORACLE. Entre com o nome do Alias, que pode ser qualquer um que não exista. Agora altere do lado esquerdo na guia Definition, no item SERVER NAME, e coloque o nome do Database Alias que você criou no Sql Net Easy Configuration.

16 - Clique no item de menu Object -> Apply

17 - Reinicialize seu computador.

18 - Ok, agora basta abrir o Delphi e utilizar este Alias como qualquer outro!

Nomes dos arquivos que estão sendo executados

É comum e até relativamente fácil encontrarmos rotinas para listar todas as janelas abertas. Mas muitas vezes não é apenas o caption das janelas que queremos listar e sim o nome do arquivo executável.

Veja então uma rotina que cria uma lista de strings com esses nomes:

uses TLHelp32; // não esqueça de incluir esta unit
procedure ListProcess(List: TStrings);
var
  ProcEntry: TProcessEntry32;
  Hnd: THandle;
  Fnd: Boolean;
begin
  List.Clear;
  Hnd := CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0);
  if Hnd <> -1 then
  begin
  ProcEntry.dwSize := SizeOf(TProcessEntry32);
  Fnd := Process32First(Hnd, ProcEntry);
  while Fnd do
  begin
  List.Add(ProcEntry.szExeFile);
  Fnd := Process32Next(Hnd, ProcEntry);
  end;
  CloseHandle(Hnd);
  end;
end;
E para utilizar esta rotina é muito simples, veja:
procedure TForm1.Button1Click(Sender: TObject);
begin
  ListProcess(ListBox1.Items);
end;

Lendo e gravando arquivos de texto

Existem vários métodos em Delphi para gravar arquivos texto a partir de informações gravadas em bases de dados ou para ler arquivos texto e armazená-los em bases de dados. Esta dica apresenta um destes métodos: o uso de TextFiles.

TextFile é um tipo de dado pré-definido no Delphi e corresponde ao tipo Text do Turbo Pascal e do Object Pascal.

Inicialmente para acessar um arquivo de texto, você precisa definir uma variável tipo TextFile, no local que você achar mais apropriado, da seguinte forma:

var arq: TextFile;
Vamos precisar também de uma variável tipo string para armazenar cada linha lida do arquivo:

var linha: String;
Antes de se iniciar a leitura do arquivo, precisamos associar a variavel TextFile com um arquivo fisicamente armazenado no disco:

AssignFile ( arq, 'C:\AUTOEXEC.BAT' );
Reset ( arq );
A rotina AssignFile faz a associação enquanto Reset abre efetivamente o arquivo para leitura. AssignFile corresponde à Assign do Turbo Pascal. Em seguida é necessário fazer uma leitura ao arquivo, para isto utilizaremos a procedure ReadLn:

ReadLn ( arq, linha );
O comando acima lê apenas uma linha de cada vez, assim precisamos de um loop para efetuar várias leituras até que o arquivo acabe. Para verificar o fim do arquivo, utilizaremos a função Eof:

while not Eof ( arq ) do
Agora uma rotina quase completa para fazer a leitura de um arquivo texto. Esta rotina recebe como parâmetro o nome do arquivo que será lido:

procedure percorreArquivoTexto ( nomeDoArquivo: String );
var arq: TextFile;
linha: String;
begin
AssignFile ( arq, nomeDoArquivo );
Reset ( arq );
ReadLn ( arq, linha );
while not Eof ( arq ) do
begin
{ Processe a linha lida aqui. }
{ Para particionar a linha lida em pedaços, use a função Copy. }
ReadLn ( arq, linha );
end;
CloseFile ( arq );
end;
E também uma rotina quase completa para gravação de um arquivo texto. Esta rotina recebe como parâmetro o nome do arquivo que será gravado e uma tabela (TTable) de onde os dados serão lidos:

procedure gravaArquivoTexto ( nomeDoArquivo: String; tabela: TTable );
var arq: TextFile;
linha: String;
begin
AssignFile ( arq, nomeDoArquivo );
Rewrite ( arq );
tabela.First;
while not tabela.Eof do
begin
Write ( arq, AjustaStr ( tabela.FieldByName ( 'Nome' ).AsString, 30 ) );
Write ( arq, FormatFloat ( '00000000.00', tabela.FieldByName ( 'Salario' ).AsFloat ) );
WriteLn ( arq );
tabela.Next;
end;
CloseFile ( arq );
end;
Note nesta segunda rotina, a substituição de Reset por Rewrite logo após o AssignFile. Rewrite abre o arquivo para escrita, destruindo tudo que houver lá anteriormente .

Note também o uso de Write e WriteLn para gravar dados no arquivo texto.

Finalmente note o uso de AjustaStr e FormatFloat para garantir que campos string e numericos sejam gravados com um número fixo de caracteres. FormatFloat é uma rotina do próprio Delphi enquanto AjustaStr está definida abaixo:

function AjustaStr ( str: String; tam: Integer ): String;
begin
while Length ( str ) < tam do
str := str + ' ';
if Length ( str ) > tam then
str := Copy ( str, 1, tam );
Result := str;
end;
O uso da função AjustaStr é fundamental quando você estiver gravando arquivos texto com registros de tamanho fixo a partir de bases de dados Paradox que usualmente não preenchem campos string com espaços no final.

Exibindo as propriedades do arquivo

A dica abaixo apresenta o código de implementação para exibir na tela uma janela padrão Windows de propriedades do arquivo.

Para implementar este procedimento é necessário acrescentar a unit ShellAPI.As propriedades do arquivo são armazenadas numa estrutura chamada TShellExecuteInfo, que corresponde a um registro com os campos: tamanho do arquivo (cbSize), atributos (fMask), nome (lpFile) , shell (lpVerb) e modo de apresentação da janela (nShow).O primeiro passo do procedimento é zerar todas a propriedades da Shell ( FillChar(S,SizeOf(S),0) ), segundo passo é atualizar estas propriedades (With S do ) em relação ao arquivo indicado (Arq :String) e o terceiro passo é abrir a janela de propriedades com os valores atualizados (ShellExecuteEx(@S)).

Código Completo:

Procedure Propriedades(Arq:String);
Var
s:TShellExecuteInfo;
Begin
FillChar(S,SizeOf(S),0);
With S do Begin
cbSize := SizeOf(S);
fMask := SEE_MASK_FLAG_NO_UI or SEE_MASK_INVOKEIDLIST or SEE_MASK_NOCLOSEPROCESS;
wnd := Handle;
lpVerb := 'properties';
lpFile := Pchar(Arq);
nShow := sw_ShowNormal;
End;
ShellExecuteEx(@S);
End;

Criando um diretório

Para criar um diretório você precisa usar a função ForceDirectories, o exemplo a baixo testa se não existe um diretório e cria o diretório apartir de uma variável string testando se o diretório já existe

Unit
 
FileCtrl
 
procedure TForm1.Button1Click(Sender: TObject);
var
  Dir: string;
begin
Dir := 'C:\APPS\SALES\LOCAL';
 
if not DirectoryExists(Dir) then
  ForceDirectories(Dir);
  Label1.Caption := Dir + ' foi criado';
end;

Colocar uma barra de progresso na inicialização do sistema

É bem simples, trata-se de abrir por código todas as tabelas na entrada do programa, portanto deixe todas as tabelas fechadas no datamodule.

procedure DataModule.OnCreate;
var Tabela, i: Integer;
begin
  Tabela := 0;
  for I := 0 to ComponentCount -1 do
    if Components[I] is TTable then
      with TTable(Components[I]) do
        if (Tag = 9) and not Active then  // Tag = 9 identifica as tabelas à serem abertas
         try
           Inc(Tabela);  // contador das tabelas q já foram abertas.
           lblInfo.Caption := Format('Abrindo as Tabelas (%d/%d)', [Tabela, Total]);
           {aqui, informo à uma label o andamento do processo, usei o formato totalTabelasAbertas/TotalàAbrir, pode-se trocar para porcentagem ou até usar o ProgressBar.}
           lblInfo.Refresh; // vital para atualizar a tela durante o processo.
           Application.ProcessMessages;
           Open;
        except
   Raise; // quem estiver a fim, pode-se colocar aqui uma verificação, se deu zebra e a zebra é indice corrompido, rodar rotina de recriação de indice da tabela.
end;

Alternando Bitmaps no Fundo de um Form.

Um leitor perguntou recentemente sobre imagens de fundo em Forms.... Apesar de já se ter escrito diversos artigos sobre este tópico, sua questão tinhas algumas novidades. Primeiramente, ele desejava que o fundo se alternasse periodicamente.
Essencialmente, a solução para isto seria a aplicação de outros artigos similares. Em primeiro lugar, para resolver a questão de se ter diversas imagens, os bitmaps devem ser carregados em um array quando o Form for criado. A mudança periódica da imagem s
Finalmente, para tratar do assunto "não leia as imagens do disco", recorremos aos resources. Um arquivo de resource é apenas um caminho para empacotar muito bem qualquer tipo de dados que será anexado ao executável durante o processo de Linkedição. Para o
BITMAP1 BITMAP IMAGE1.BMP
BITMAP2 BITMAP IMAGE2.BMP
BITMAP3 BITMAP IMAGE3.BMP
BITMAP4 BITMAP IMAGE4.BMP
BITMAP5 BITMAP IMAGE5.BMP
A primeira parte de cada linha é o identificador que você utilizará no código para capturar uma imagem em particular. A segunda parte é o tipo de resource (neste caso, bitmap). E a última parte é o nome do arquivo que deve ser utilizado para a imagem. Ist
{$R MYBMPS.RES}
Quando o executável está sendo linkeditado (um passo antes da compilação), o resource será automaticamente anexado ao executável. Para carregar as imagens do resource no array de bitmaps no programa, fiz simplesmente:
    for a := 1 to NumBmps do
    begin
       Bmps[a] := TBitmap.Create;
       Bmps[a].LoadFromResourceName(hInstance,'BITMAP'+IntToStr(a));
    end;
É basicamente isto... A seguir a listagem da Unit principal:
unit Unit1a;
interface
uses
    Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
    ExtCtrls, StdCtrls;
const
    NumBmps = 5;
type
    TForm1 = class(TForm)
        Timer1: TTimer;
        Edit1: TEdit;
        CheckBox1: TCheckBox;
        ListBox1: TListBox;
        procedure FormCreate(Sender: TObject);
        procedure FormDestroy(Sender: TObject);
        procedure FormPaint(Sender: TObject);
        procedure Timer1Timer(Sender: TObject);
    private
       Bmps : Array[1..NumBmps] of TBitmap;
       SelectedBmp : Integer;
    public
    { Public declarations }
    end;
var
    Form1: TForm1;
implementation
{$R *.DFM}
{$R MYBMPS.RES}
procedure TForm1.FormCreate(Sender: TObject);
var
    a : Integer;
begin
    for a := 1 to NumBmps do
    begin
        Bmps[a] := TBitmap.Create;
        Bmps[a].LoadFromResourceName(hInstance,'BITMAP'+IntToStr(a));
    end;
    SelectedBmp := 1;
end;
procedure TForm1.FormDestroy(Sender: TObject);
var
    a : Integer;
begin
    for a := 1 to NumBmps do Bmps[a].Free;
end;
procedure TForm1.FormPaint(Sender: TObject);
var
    x,y,w,h : Integer;
begin
    w := Bmps[SelectedBmp].Width;
    h := Bmps[SelectedBmp].Height;
    for x := 0 to (Width div w) do
        for y := 0 to (Height div h) do
            Canvas.Draw(x*w,y*h,Bmps[SelectedBmp]);
end;
procedure TForm1.Timer1Timer(Sender: TObject);
begin
    Inc(SelectedBmp);
    if SelectedBmp > NumBmps then SelectedBmp := 1;
    Paint;
end;end.

Técnicas de depuração em Delphi e Prevenção de Bug

Fonte: www.activedelphi.com.br

Muitas vezes pegamos um sistema legado de outro programador para realizarmos implementação de novas funcionalidades ou corrigir eventuais "bugs". Neste caso você vai precisar depurá-lo para encontrar os "bugs". O Delphi oferece ótimas ferramentas de depuração e quando você sabe como usá-las, você vai economizar muito tempo para corrigir o "bug" e chegar no resultado desejado

Neste caso quero indicar um tutorial que encontrei e ajudou quando o assunto era depuração de programas.

Aqui está o conteúdo:

Project options - antes que você possa começar a utilizar as ferramentas depurador do Delphi, você tem que certificar-se de todas as configurações necessárias são definidas opções depurador .

Breakpoints - Quando pressionar a tecla F5 ou clicando na barra esquerda do seu editor você pode adicionar uma linha vermelha para a sua fonte. Esta linha de origem terão um ponto de interrupção. Ao executar o programa, a execução irá parar quando ele passa a linha de origem. Agora você pode seguir em sua origem, usando algumas teclas de função.

Call stack - a janela Call Stack exibe as chamadas de função que o trouxe para a sua localização atual no programa e os argumentos passados para cada chamada de função.

Local variables - essa janela vai mostrar todas as variáveis locais e o seu valor atual no atual função ou procedimento.

Watches - você adicionar um Watches para controlar os valores das variáveis do programa ou expressões como você passar por cima ou em código de rastreamento.

Idéias para criar os seus próprios recursos de depuração Prevenção Bug Try-Finally Gotchas Try-Except Gotchas

O artigo completo você pode visualizar no link:

https://docs.google.com/fileview?id=0B0YypBtQL4eAYzA2NDRmYjQtN2MzZS00NzMzLWFjYTktYjBkMTY0ZTI3ZDVh&hl=pt_BR