You are on page 1of 52

1

APLICAÇÕES EM
DELPHI COM BANCO DE
DADOS

Autor:
Márcio Viníssius Fernandes Furtado.
E-mail: marciofurtado@uol.com.br

2004
2

SUMÁRIO

1 INTRODUÇÃO .................................................................................................................................................. 1

2 INTRODUÇÃO A BANCO DE DADOS.......................................................................................................... 2

2.1 MODELO DE BANCO DE DADOS RELACIONAL ................................................................................ 2


2.2 TIPOS DE BANCOS DE DADOS .............................................................................................................. 4
2.3 ARQUITETURAS DE APLICAÇÕES COM BANCO DE DADOS EM DELPHI.................................... 5
2.3.1 Aplicações Desktop. .................................................................................................................................. 5
2.3.2 Aplicações cliente-servidor ....................................................................................................................... 6
2.3.3 Aplicações multicamadas .......................................................................................................................... 8
2.4 SELEÇÃO DO BANCO DE DADOS ....................................................................................................... 10
3 ACESSO A DADOS PELO DELPHI ............................................................................................................. 12

3.1 ENGINE DE ACESSO A DADOS. ........................................................................................................... 12


3.1.1 BDE......................................................................................................................................................... 12
3.1.2 DBEXPRESS .......................................................................................................................................... 13
3.1.3 ADO ........................................................................................................................................................ 14
3.1.4 Interbase Express (iBx) ........................................................................................................................... 14
3.2 COMPONENTES DELPHI DE BANCO DE DADOS ............................................................................. 15
4 CRIANDO BANCO DE DADOS PARADOX ............................................................................................... 16

4.1 BDE ADMINISTRATOR X SQL EXPLORER ........................................................................................ 16


4.2 ALIAS ........................................................................................................................................................ 17
4.2.1 Criando um alias...................................................................................................................................... 18
4.3 DATABASE DESKTOP............................................................................................................................ 19
4.3.1 Tabelas Paradox ...................................................................................................................................... 20
4.3.2 Table Properties....................................................................................................................................... 21
4.3.3 Tipos de Campos ..................................................................................................................................... 21
3

4.4 EXEMPLO ................................................................................................................................................. 22


5 CRIANDO A APLICAÇÃO ............................................................................................................................ 26

5.1 PRIMEIROS PASSOS ............................................................................................................................... 26


5.2 FORMULÁRIO PRINCIPAL .................................................................................................................... 27
5.3 FORMULÁRIO SOBRE............................................................................................................................ 30
5.4 DATAMODULE........................................................................................................................................ 32
5.5 FORMULÁRIO DE CONSULTA ............................................................................................................. 34
5.6 FORMULÁRIO PARA EDIÇÃO DA TABELA PAÍSES ........................................................................ 38
5.7 FORMULÁRIO PARA INSERÇÃO DA TABELA PAÍSES.................................................................... 40
6 RETOQUES FINAIS ....................................................................................................................................... 42

6.1 FORMULÁRIO PRINCIPAL .................................................................................................................... 42


6.2 FORMULÁRIO DE CONSULTA. ............................................................................................................ 45
4

LISTA DE FIGURAS

Ilustração 1 - Aplicação desktop (acesso ao banco de dados em uma única camada) 5


Ilustração 2 - Aplicação cliente servidor (acesso ao banco de dados em duas
camadas) .............................................................................................................. 7
Ilustração 3 – Aplicação multicamadas....................................................................... 9
Ilustração 4 – Diagrama de acesso a base de dados pelo Delphi .............................. 15
Ilustração 5 - BDE ..................................................................................................... 16
Ilustração 6 – SQL Explorer...................................................................................... 17
Ilustração 7 – Novo Alias .......................................................................................... 18
Ilustração 8 – SQL Explorer: Novo alias .................................................................. 18
Ilustração 9 – SQL Explorer: Acessando Dados ....................................................... 19
Ilustração 10 – Database Desktop, com uma tabela aberta ....................................... 20
Ilustração 11 – Pastas do Projeto............................................................................... 23
Ilustração 12 - Criando Alias Paises.......................................................................... 24
Ilustração 13 – Create Table do Database Desktop (Seleção tipo de Tabela)........... 24
Ilustração 14 - Create Table do Database Desktop (Definição dos atributos da tabela)
........................................................................................................................... 25
Ilustração 15 - Tabela Country (paises)..................................................................... 27
Ilustração 16 – Formulário Principal com apenas o Panel ........................................ 28
Ilustração 17 – Picture Editor da Propriedade Picture do componente Image.......... 29
Ilustração 18 – Ferramenta de Alinhamento ............................................................. 29
Ilustração 19 – Formulário Principal do programa ................................................... 30
Ilustração 20 – Formulário Sobre .............................................................................. 31
Ilustração 21 – Formulário Sobre versão final .......................................................... 32
Ilustração 22 – Fields Editor 1................................................................................... 33
Ilustração 23 - Fields Editor 2 ................................................................................... 34
Ilustração 24 – Formulário consulta países ............................................................... 36
Ilustração 25 – Caixa de dialogo Use Unit................................................................ 37
Ilustração 26 – Formulário de Consulta de países com registros .............................. 38
Ilustração 27 – Formulário Alterar Registro ............................................................. 39
Ilustração 28 – Ajuda da Classe TApplication .......................................................... 43
5

Ilustração 29 – Mensagem para inclusão de uma Unit.............................................. 44


Ilustração 30 – View Form ........................................................................................ 45
1 INTRODUÇÃO

Este pequeno programa exemplo, tem como objetivo introduzir o


programador em Delphi, na construção de sistemas usando banco de dados paradox
e a sua interligação com uma aplicação desenvolvida em Delphi 7.

A primeira parte desse documento, explica a parte teórica sobre banco de


dados, os diferentes tipos e uso dos mesmos. Seguido por instruções sobre como
funciona a conexão de um banco de dados com uma aplicação Delphi, e os
componentes que devem ser utilizados pelo programador.

Logo, mostra de maneira prática como montar uma tabela paradox


utilizando o Database Desktop, e como acossá-lo através de uma aplicação Delphi.
2

2 INTRODUÇÃO A BANCO DE DADOS

O banco de dados consiste, em um conjunto de dados relacionados, e


armazenados fisicamente em algum tipo de dispositivo secundário de
armazenamento, geralmente disco magnético na forma de um ou mais arquivos.

As aplicações, são os programas que contém a lógica e as funções


específicas de um negócio para o usuário, com atribuições e tarefas específicas.

O SGBD (Sistema de Gerência de Banco de Dados) funciona como uma


camada lógica entre os dados e os usuários, promovendo independência dos dados,
uma visão abstrata dos mesmos, fornecendo também uma série de operações sobre o
banco de dados, através de uma linguagem embutida, que geralmente é a SQL –
Structured Query Language, para os modelos relacionais.

O ambiente formado pelo banco de dados, o SGBD, e os aplicativos que


utilizam o SGBD como intermediário para acessar o banco de dados, como também
o hardware, é conhecido como Sistema de Banco de Dados (SBD).

Os dados são modelados obedecendo ao modelo do banco de dados, que


são métodos para a descrição dos dados, dos relacionamentos entre os mesmos e das
restrições de consistência e integridade, de maneira a permitir a compreensão da
estrutura dos dados armazenados e a sua manipulação.

2.1 MODELO DE BANCO DE DADOS RELACIONAL

Além do modelo relacional, existem outros modelos de dados usados


para definir um banco de dados. Os mais conhecidos são:

1. Relacional;
3

2. Hierárquico;

3. Redes;

4. Orientado a objetos.

O relacional é o usado pela grande maioria dos bancos de dados


existentes, e SGBDs, e por esse motivo será o estudado. Foi introduzido pelo
matemático e pesquisador da IBM Edgar F. Codd em um documento publicado em
19 de agosto de 1969, suas idéias foram aceitas inicialmente por dois grupos, sendo
um a IBM e outro na Universidade da Califórnia, em Berkeley.

A IBM, desenvolveu no início dos anos 70 a Linguagem de Consulta


Estruturada (SQL), e o grupo da Universidade da Califórnia, criou o INGRES e a
linguagem de consulta QUEL. A partir do final da década de 70 começou a surgir
outros produtos como o Oracle, Informix e Sybase.

Um característica importante do modelo é que o relacionamento entre


tabelas é feito logicamente, ao contrário do modelo hierárquico e em redes, o que
torna o modelo relacional mais independente fisicamente.

Um banco de dados relacional é um conjunto de relações. A relação é a


estrutura básica desse modelo, que muitas vezes é referenciada como simplesmente
tabela. Uma relação é constituída de um conjunto de linhas, que no modelo
relacional é nomeado de tupla. Cada tupla é exclusiva na relação.

Cada tupla (linha) da relação (tabela), é constituída de uma lista de


atributos (colunas), isto é, cada coluna da relação é um atributo. O atributo (coluna)
serve para identificar um elemento que compõe uma relação, e por tanto, o seu nome
deve ser exclusivo na relação.

Cada valor de atributo é retirado de um domínio de possíveis valores,


que é um conjunto de valores atômicos, ou seja, indivisíveis. Atômico é quando um
dado é matematicamente simples, mesmo quando for semanticamente complexo.
Semanticamente complexo quer dizer que o dado pode conter mais de um elemento
de informação, como por exemplo, o nome de uma pessoa que contém o primeiro
nome, o do meio e o sobrenome, mas mesmo assim significa um só elemento.

O domínio se caracteriza como um conjunto de valores permitidos para


um determinado atributo, informando que tipo de dado é permitido. Por exemplo:
uma relação (tabela) Cliente, que contenha, os atributos (colunas) nome do cliente,
identidade e endereço, o atributo nome de cliente poderá conter somente nomes de
clientes, e não o endereço do mesmo, para garantir a integridade do banco de dados.
Ao contrário do atributo o domínio não é exclusivo, ou seja, pode haver um ou mais
atributos com o mesmo domínio.
4

Uma relação, tida aqui como uma tabela de banco de dados, possuir três
propriedades, que são:

• Uma relação não possui uma ordem, tanto de atributo (coluna)


quanto nas tuplas (linhas). O que se pode concluir dessa afirmação
que relações que diferem somente na ordem que são apresentadas
as tuplas e ou atributos, constituem-se na mesma relação;

• Todo atributo é atômico;

• Uma relação não possui tuplas duplicadas. Cada tupla em uma


relação é exclusiva.

Todo modelo de dados impõe condições de integridade. No relacional


não é diferente, sendo que a integridade compreende em um grupo de condições
obrigatórias impostas pelo modelo com a finalidade de assegurar que mudanças
feitas pelos usuários, não resultem em perda da consistência das informações
armazenadas.

Uma das restrições mais óbvias que se deve fazer é a restrição de


domínio que consiste em cuidar para que cada atributo esteja recebendo valores
condizentes com o domínio ao qual está associado.

Uma outra restrição imposta pelo modelo é a restrição de chaves. É


condição obrigatória em uma relação ter pelo menos uma chave. Esse tipo de
restrição cuida para que não haja instâncias da relação com tuplas iguais, pois
quando se define uma chave, os elementos pertencentes aquele atributo não podem
ser iguais. Uma chave primária não pode ter valores nulos.

A restrição de integridade referencial cuida em manter a consistência


entre tuplas de duas relações distintas. Isto é, deve garantir que o valor de uma
chave estrangeira em um tupla de uma relação exista como valor de chave primária
em uma outra relação.

Existem outros tipos de restrições inerentes a integridade de semântica, já


que os até aqui citados dizem mais respeito ao esquema do banco de dados. São
restrições de cunho mais genérico, e estão ligadas intimamente com semântica do
negócio da empresa que se utiliza do sistema de informação.

2.2 TIPOS DE BANCOS DE DADOS

De modo simplório pode-se dividir os bancos de dados em três


categorias:
5

Os bancos de dados desktop, que se constituem em bancos de dados


simples, que em geral não tem nenhum custo adicional de distribuição, mas faltam
recursos a eles. Nessa faixa pode-se citar: o paradox, dBase e Access.

Bancos de dados topo de linha, são sistemas gerenciadores de banco


de dados de alto desempenho e custo. Eles contam com muitos recursos e permitem
a conexão simultânea de um grande números de usuários, suportando banco de
dados da ordem de gigabytes ou maiores. Estes bancos de dados, em geral
necessitam da figura do DBA para administração e gerenciamento do desempenho.
Nesse faixa estão o Oracle, DB/2 e o Sybase.

E os bancos de dados intermediários que situam-se entre os bancos de


dados desktop e os de topo de linha. São banco de dados cliente-servidor, porém não
tão sofisticados como os topo de linha. Em geral, não necessitam de um DBA para
sua administração, já que possuem manutenção simplificada. Tem uma série de
recursos dos bancos de dados topo de linha. Como exemplos, temos: Interbase,
MySql, Firebird, e outros.

2.3 ARQUITETURAS DE APLICAÇÕES COM BANCO DE DADOS EM


DELPHI

O Delphi permite desenvolver sistemas em três arquiteturas diferentes:


desktop (uma camada), cliente-servidora (duas camadas) e multicamada (mais de
duas camadas).

2.3.1 Aplicações Desktop.

São as mais simples, utilizando-se de arquivos simples ou mesmo de


bancos de dados locais. Elas fazem o acesso em uma única camada: a aplicação
conversa diretamente com o arquivo ou com o banco de dados local. Todo o
processamento é feito na máquina cliente, onde está a aplicação.

Ilustração 1 - Aplicação desktop (acesso ao banco de dados em uma única camada)


6

Independentemente de o sistema estar sendo usado em rede ou não, todo


o processamento de uma aplicação desktop é feito na máquina-cliente. Se por
exemplo um usuário desejar localizar os clientes do estado do Rio Grande do Sul,
toda a tabela de clientes será transferida para a aplicação na máquina-cliente, que se
encarregará de separar os clientes desejados, antes de mostrá-los. Essa maneira de
trabalho é muito rápida quando se utiliza uma máquina local, sem acesso à
rede, com uma pequena quantidade de informações. À medida que o volume de
dados cresce e o número de estações aumenta, o desempenho cai: como a tabela
precisa ser transferida pela rede, o tráfego começa a aumentar, deixando o sistema
lento. Além disso, para aumentar a performance, algumas estruturas são mantidas
em cache na memória da máquina-cliente e, se ocorrer algum travamento da
máquina, os dados ficarão corrompidos. São comuns, em aplicações que utilizam
esse tipo de dados, opções para recuperação ou reorganização das informações.

A grande vantagem de bancos de dados desktop é o seu preço:


normalmente não há pagamento de licenças por uso; basta utilizá-los, sem pagar
nada.

Os bancos de dados desktop são adequados para instalações mono-


usuários ou para pequenas redes (até dez usuários), não sendo recomendados para
grandes redes ou sistemas com muita movimentação de dados. Exemplos de banco
de dados que utilizam a arquitetura desktop são: Dbase, Paradox e Access.

2.3.2 Aplicações cliente-servidor

Em banco de dados cliente-servidor, a aplicação já não acessa


diretamente, os dados. Esses bancos de dados são muito mais robustos e seguros,
compondo-se de duas partes:

1. Um servidor, que gerência as requisições ao banco de dados,


processando-as e enviando a resposta adequada. Esse servidor é
conhecido como SGBD, ou seja, Sistema de Gerência de Banco de
Dados;

2. Um cliente, que faz as requisições ao servidor e recebe as


respostas.

Surge a figura do servidor de dados, um programa independente do


cliente, que se encarrega de fazer o acesso aos dados. A aplicação-cliente faz uma
requisição ao servidor, que se encarrega de processá-la e enviar as informações
resultantes. O servidor e o cliente não precisam estar na mesma máquina, podendo,
inclusive, estar separados por milhares de quilômetros. O processamento é dividido
entre a máquina-cliente e o servidor.
7

Ilustração 2 - Aplicação cliente servidor (acesso ao banco de dados em duas camadas)

O acesso cliente-servidor tem diversas vantagens em relação ao acesso


desktop:

• O processamento é dividido entre a máquina-cliente e a


servidora: parte da lógica do sistema é embutida no servidor e não
necessita estar na máquina cliente;

• Aumento da integridade dos dados: como o servidor pode


manter as regras de negócio dentro do seu banco de dados,
qualquer aplicação que acesse o banco de dados deverá segui-la,
independentemente da linguagem que foi escrita;

• Diminuição do tráfego na rede – como o que trafega na rede são


apenas às requisições e as respostas, o volume de dados trafegando
é muito menor.

• Otimização de velocidade de consultas – Como a aplicação


servidora tem a única tarefa de atender às requisições de dados, ela
pode ser otimizada para obter as informações da maneira mais
veloz possível.

• Redução na corrupção dos dados – todo o processamento é feito


no servidor, assim o travamento de uma máquina cliente não afeta
os dados. Além disso, em geral, os gerenciadores de bancos de
dados têm controle de transações. Os servidores têm internamente
dispositivos para manter a integridade das informações e,
eventualmente, repará-las, mesmo sem a intervenção ou
conhecimento por parte do usuário.

• Fácil escalabilidade – o aumento do número de estações


conectadas ao servidor pode ser compensado com a mudança de
hardware: basta colocar uma máquina mais potente para que não
haja queda significativa no desempenho com o aumento do
número de estações.
8

• Segurança das informações que trafegam na rede – ao ser


transferida entre uma máquina cliente e uma servidora, uma
informação poder interceptada e utilizada de maneira indevida.
Alguns SGBDS permitem criptografar os dados que trafegam na
rede, dando assim um nível a mais de segurança às informações.

Além dessas características, muitas funções podem ser transferidas da


aplicação para o servidor de banco de dados: Stored procedures, Triggers ou
gatilhos, Views.

Um outro recurso, importantíssimo para quem precisa de um sistema


robusto, é a possibilidade de limitar o acesso dos usuários do banco de dados. Com
ele pode-se limitar o acesso a algumas tabelas ou até impedir a visualização de
alguns campos.

Normalmente a comunicação entre o servidor e a aplicação-cliente é feita


através de consultas SQL (Structured Query Language – Linguagem Estruturado de
Consultas), que é uma linguagem voltada para consulta e manipulação de bancos de
dados.

Em compensação, geralmente custam mais caros. Um custo por estação


conectada, ou seja, cada estação conectada ao banco de dados deve ter uma licença
do fabricante. Alguns têm uma operação tão complexa que necessita da figura de um
DBA para administrar e manter o banco de dados.

Hoje, porém, existe a possibilidade de obter SGBDs de boa qualidade


(como o Interbase e o FireBird), sem custo algum incluindo o código fonte.

São exemplos de SGBDs: Interbase, Firebird e outros.

2.3.3 Aplicações multicamadas

O acesso multicamadas inclui uma aplicação intermediária entre a


aplicação-cliente e o servidor. A aplicação-cliente já não conversa mais diretamente
com o servidor, e sim com essa aplicação intermediária que, por sua vez, conversa
com o servidor. Isso reduz bastante as necessidades de processamento da aplicação-
cliente. Agora ela se encarrega apenas da interface com o usuário e recebe
informações da aplicação intermediária, que conversa com o servidor de banco de
dados que por sua vez acessa o banco de dados físico.

Com a introdução de mais uma camada, a aplicação-cliente fica bastante


simplificada, fazendo apenas a interface com o usuário e as primeiras
verificações na entrada de dados.
9

Ilustração 3 – Aplicação multicamadas

A aplicação intermediária encarrega-se de processar algumas regras de


negócio, comunicando-se com o servidor. As vantagens deste método são as
seguintes:

• A aplicação cliente fica muito mais leve, necessitando de


máquinas menos potente.

• Não há necessidade de distribuir nenhuma engine de acesso a


dados com a aplicação-cliente. Como não há acesso real aos
dados, tudo o que é necessário são ferramentas de conexão entre a
aplicação cliente e a intermediária;

• Diminuição do trabalho de manutenção de sistemas. Caso alguma


regra de negócio seja alterada, não é necessário alterar a aplicação
cliente (muitas vezes, o usuário nem fica sabendo) – apenas a
aplicação intermediária é modificada.

• Redução do número de licenças do banco de dados necessário.


Como apenas a aplicação intermediária acessa o banco de dados,
apenas uma licença é requerida – as aplicações cliente apenas
fazem acesso à aplicação intermediária.

• Balanceamento de carga. Caso haja mais de um servidor provendo


dados, a aplicação intermediária pode distribuir as requisições para
este ou aquele servidor, de maneira que as cargas estejam
balanceadas.

• Trabalho ininterrupto. Caso haja dois servidores espelhados e um


deles saia do ar, a aplicação intermediária pode desviar o fluxo das
informações para o outro, sem que os usuários percebam qualquer
interrupção.
10

2.4 SELEÇÃO DO BANCO DE DADOS

A decisão por um banco de dados na hora de construir uma aplicação


depende de diversos fatores, entre eles podem ser: preço, disponibilidade,
conhecimento, suporte, velocidade, quantidade de estações com acessos
simultâneos, tamanho do banco de dados, robustez, necessidade de
administração.

Quanto ao tocante preço, logo é levado em conta os banco de dados


desktop (Dbase, Paradox ou Access), sendo que para as duas primeiras opções, não
há custo de distribuição. Mas hoje, existem opções, melhores que os banco de dados
desktop, como o Interbase, FIREBIRD, MySQL e PostgreSQL, que são gratuitos e
cliente servidor. Constituem-se o melhor dos dois mundos, ou seja, é gratuito como
na maioria dos bancos de dados desktop e possuem características avançadas
encontradas em banco de dados topo de linha.

Quanto à disponibilidade, pode ser levado em conta dois aspectos:


facilidade de encontrar, de obter novas licenças ou de atualizar o gerenciador de
banco de dados, bem como disponibilidade na empresa. Muitas vezes, o banco de
dados já foi adquirido ou está em uso em outros aplicativos e deve ser utilizado
obrigatoriamente.

Outras vezes a escolha do banco de dados é direcionada pela


familiaridade que o desenvolvedor tem com o banco de dados. .

Suporte é um fator muito importante para a escolha de um banco de


dados. Deve ser visto as opções de suporte que o banco de dados oferece, tanto
pagas como gratuitas: suporte do fabricante, páginas na Internet, listas de discussão,
entre outras. Outra questão que é incluída nesse mesmo ponto é quanto a atualização
do banco de dados, bem como a solução de bugs encontrados.

A quantidade de estações que acessarão simultaneamente o banco de


dados pode determinar qual o banco de dados a ser usado. Por exemplo, não é
interessante um banco de dados desktop com mais de 10 acessos simultâneos. Isso
se deve ao fato de o banco de dados não ter sido projetado para esta carga de acesso,
diminuindo a velocidade e aumentando a possibilidade de corrupção das
informações. O contrário também é válido quando se usa um banco de dados muito
complexo para utilização apenas em uma estação.

O tamanho do banco de dados também é um limitante para a escolha: o


uso pode atingir o número máximo de registros ou então ultrapassar o tamanho
máximo do banco de dados. Outras limitantes são o tamanho máximo de um registro
ou o número de campos em uma tabela.
11

Robustez é um item muito importante na escolha de um banco de dados.


Ninguém quer chamadas diárias ao suporte técnico devido à corrupção de dados. Por
outro lado desastres acontecem, e por esse motivo é necessário verificar se o banco
de dados tem capacidade de recuperar os dados. Como é feito backup do banco de
dados.

Alguns bancos de dados exigem a contratação de mão-de-obra


especializada para a sua administração. Bancos de dados mais sofisticados requerem
um administrador de banco de dados (DBA – Data Base Administrator) para manter
as tabelas, efetuar sintonia fina do banco de dados e manter a integridade do sistema.
Em alguns casos isso representa um custo muito alto para a empresa, devendo então
ser escolhido um banco de dados que requeira menos manutenção.

Outros requisitos do banco de dados podem ser compatibilidade com este


ou aquele sistema operacional, comunicação entre cliente e servidor criptografada,
replicação de dados, entre outros. Quando se estuda o banco de dados a ser utilizado,
todas estas variáveis deverão ser cuidadosamente verificadas, pois, uma ver definido
o banco de dados, a mudança pode ser muito demorada e principalmente cara.
12

3 ACESSO A DADOS PELO DELPHI

O suporte Delphi para aplicativos de banco de dados é um dos principais


recursos deste ambiente de programação.

Além de acessar dados em banco de dados desktop, o Delphi pode


conectar banco de dados SQL em computadores servidores.

Uma aplicação Delphi, não tem acesso direto aos dados, em vez disso faz
uso de uma engine. E essa comunicação entre o aplicativo Delphi e a engine é feita
através de componentes específicos para a engine encolhida.

3.1 ENGINE DE ACESSO A DADOS.

Os aplicativos Delphi de banco de dados não têm acesso direto à fonte


dos dados que eles fazem referência. O Delphi faz interface com um outro sistema
(tipicamente chamado engine) que é o responsável pelo acesso direto as dados
armazenados na base de dados (Ilustração 4).

Juntamente com a distribuição, o Delphi fornece várias engines de acesso


a dados. As mais conhecidas são discutidas a seguir.

3.1.1 BDE

A BDE (Borland Database Engine) é a engine que acompanha o Delphi


desde a sua primeira versão. É uma engine de acesso a dados muito completa,
permitindo acessar desde bases de dados desktop, como Paradox, dBase ou Access,
até banco de dados cliente-servidor, como Interbase, DB/2 ou Oracle.
13

Possui, então, os drivers para acesso a diversos bancos de dados, além do


acesso a ODBC, engine de acesso a dados da Microsoft, que a complementam,
possibilitando acessar um número ainda maior de banco de dados.

Os componentes que permitem acesso a bancos de dados via BDE


(TTable, TQuery, TSToreProc) são os mais tradicionais e acompanham o Delphi
desde a versão 1.0. Os componentes que dão acesso a outras engines de dados
vieram posteriormente e simulam o comportamento desses.

O BDE permite acesso multidirecional, isto é, ela permite que se navegue


pelos dados em qualquer direção, para frente ou para trás. Isso não é uma coisa
muito comum, pois normalmente os bancos de dados permitem cursores de
navegação unidirecional, somente para frente.

3.1.2 DBEXPRESS

Apesar de a BDE ser uma engine de dados muito poderosa (e talvez por
isso mesmo) ela é muito grande e pesada, sendo uma das maiores críticas em relação
ao Delphi. A BDE, embora muito completa e permitindo acesso a um número muito
grande de banco de dados, desde dBase e Paradox até Oracle, requer o uso de um
grande número de arquivos e dlls. A distribuição de uma aplicação simples de banco
de dados usando BDE requer a distribuição de quase 5 MB em dlls para seu
funcionamento.

Com a introdução do Kylix, a Borland viu a oportunidade de substituir a


BDE por outra engine de banco de dados, mais simples, leve e compacta. Ela
chamou esta nova engine de dbExpress.

Esta é uma camada muito fina sobre o banco de dados, permitindo


velocidade de acesso semelhante ao acesso nativo ao banco. As bibliotecas de
distribuição são muito pequenas e não impõem um aumento significativo em relação
ao tamanho do executável.

Por outro lado, esta engine tem dois inconvenientes:

• Ela permite apenas acesso unidirecional, enquanto a BDE permite


navegar uma consulta em todas as direções;

• Ela é eminentemente baseada em SQL e, portanto, não permite


acesso a bancos de dados desktop, como dBase ou Paradox. Você
pode acessar esses bancos de dados usando drivers ODBC, ligando
o dbExpress à ODBC.
14

3.1.3 ADO

Esse é o nome da interface de acesso à tecnologia ADO (ActiveX Data


Objects), da Microsoft..

ADO é a interface de programação ao novo paradigma de acesso a dados


da Microsoft, OLE DB. Tanto a ADO com o OLE DB estão incluídos no conjunto
de componentes chamado Microsoft Data Access Components (MDAC), permitindo
acesso a uma série de bancos de dados e a à ODBC.

As vantagem de usar esta engine de acesso são:

• Está incorporada ao sistema operacional, caso o usuário esteja


usando o Windows 2000 ou ME, não há necessidade de instalar
nenhuma engine de acesso.

• É escalável, permitindo acesso desde bases de dados desktop até


aplicações multicamadas.

• Por outro lado, ela não é portável para outras plataformas: caso o
desenvolvedor queira portar seu programa para Linux, terá de
trocar todos os componentes de acesso a dados.

3.1.4 Interbase Express (iBx)

O Interbase Express é um conjunto de componentes que permite acesso


nativo ao banco de dados Interbase da Borland. Esses componentes usam a API do
Interbase diretamente e permitem acesso ao banco de dados de maneira muito rápida
e eficiente.

Além disso, ela permite extrair o máximo deste banco de dados: por não
ser um interface genérica, e sim um conjunto de componentes que acessam todos os
recurso de baixo nível da API diretamente. Enquanto as outras engines têm uma
arquitetura em camadas (aplicação -> interface genérica -> driver -> API -> Banco
de dados), o Interbase Express vai diretamente à API, aumentando também a
velocidade de acesso.

A grande desvantagem de utilizar este método é que ele permite acesso


apenas ao Interbase. Caso seja necessário mudar de banco de dados, os componentes
de acesso também devem ser alterados. O Interbase Express foi portado para a
plataforma Linux, podendo ser utilizado da mesma maneira que no Windows.
Assim, se o desenvolvedor quiser um aplicativo que acesse apenas bancos de dados
15

Interbase, cursores multidirecionais e portabilidade entre plataformas, esta é uma


escolha excelente.

3.2 COMPONENTES DELPHI DE BANCO DE DADOS

O Delphi inclui diversos componentes relacionados a banco de dados. A


maior parte deles são de componentes não visuais, já que eles encapsulam conexões
a bancos de dados, tabelas, consultas e elementos similares. Felizmente o Delphi
fornece componentes predefinidos que podem ser usados para editar os dados em
formulários. Estes controles são chamados de controles conscientes de dados (data-
aware)

Para acessar um banco de dados em Delphi, geralmente precisa-se de


uma fonte de dados, identificada pelo componente DataSource. Entretanto, o
componente DataSource não indica os dados diretamente; ele faz referência a um
componente DataSet. Este pode ser uma tabela, o resultado de uma consulta o
resultado de um procedimento armazenado, os dados objetos de uma servidor
remoto (usando o componente ClientDataSet), ou algum outro conjunto de dados
(dataset) personalizado. O componente DataSet, obtém os dados da engine
instalada. No caso da Ilustração 4 a engine usada é o BDE.

Ilustração 4 – Diagrama de acesso a base de dados pelo Delphi


16

4 CRIANDO BANCO DE DADOS PARADOX

4.1 BDE ADMINISTRATOR X SQL EXPLORER

Para administrar o BDE pode ser usado o programa BDE Administrator


(Ilustração 5) onde permite criar e mudar as configurações de um Alias. Também
permite configurar o BDE para acesso os dados de um banco de dados. Por exemplo,
ajustar a engine para gerênciar um banco de dados desktop acessado por múltiplos
usuários.

Ilustração 5 - BDE

Também existe, uma outra ferramenta, para criar e alterar alias chamada
Database Explorer ou SQL Explorer. Nele além de criar e alterar alias, permite
17

também navegar pelas estruturas dos bancos de dados, alterar os dados das tabelas e
executar comandos SQL.

Ilustração 6 – SQL Explorer

4.2 ALIAS

Pode ser considerado um “apelido” para uma base de dados. O


desenvolvedor associa um nome a um caminho de diretório e passa a se referir a
esse caminho por esse nome.

Por exemplo: suponha que está sendo desenvolvido um sistema que usa
o diretório C:\Fontes\Sist1\DB para colocar os arquivos do banco de dados do
sistema. Em vez de digitar todo momento esse diretório quando criar uma referencia
a um arquivo, pode associar o alias alSist1 para esse diretório. Mas diminuir a
digitação não é o principal benefício do alias. O principal é que depois que a
aplicação estiver pronta, certamente será instalada em outro diretório, geralmente em
outro micro. Tendo um alias, basta modificar o diretório associado para o novo
diretório e nenhuma mudança será necessária no código fonte do sistema, pois o
nome do alias não será alterado.
18

4.2.1 Criando um alias

Para criar um alias, pode ser utilizado o SQL Explorer. No menu Object,
é necessário selecionar New.

Ilustração 7 – Novo Alias

Aparece a janela New Database Alias, onde deverá ser informado no


campo Database Driver Name, o drive correspondente ao banco de dados que será
utilizado pelo alias. Nesse caso é selecionado o drive Standard, que correspondente
ao drive padrão de banco de dados do BDE, no caso o Paradox, e logo após basta
confirmar no botão OK.

Nesse ponto a tela do SQL Explorer se parecera como mostrado na


Ilustração 8.

Ilustração 8 – SQL Explorer: Novo alias

Deve-se agora, nomear o alias (para Curso Delphi), com um nome mais
apropriado, para após ser acessado pelo sistema em Delphi ou outro programa
qualquer de banco de dados. Deve ser observada também a informação fornecida na
guia Definition, do lado direito do SQL Explorer. As mais importantes são: Default
19

Driver, que fornece o nome do drive para o banco de dados a ser usado pela Alias,
sendo nesse caso o Paradox; e o Path (C:\Arquivos de programas\Arquivos
comuns\Borland Shared\Data), que fornece o caminho de diretório onde se encontra
o arquivo de banco de dados que deve ser acessado toda vez que for feita referencia
a alias Curso Delphi. Após especificar o caminho é necessário ativar as novas
configurações para o BDE, executando o comando Object -> Apply.

De maneira simples, a partir de agora os arquivos de banco de dados


constantes desse caminho poderão ser acessados e modificados como é mostrado na
Ilustração 9.

Ilustração 9 – SQL Explorer: Acessando Dados

Para alterar as configurações do Alias, já criado anteriormente, basta


selecioná-lo, fazer as alterações necessárias e logo após aplicá-las com o comando
Object -> Apply.

4.3 DATABASE DESKTOP

Para criar um banco de dados novo, normalmente, é necessário dispor de


alguma ferramenta do próprio banco de dados, mas se a base de dados for Paradox,
ou dBase, o desenvolvedor pode usar o Database Desktop, um utilitário que vem
com o Delphi e permite a criação desses tipos de bancos de dados. Fornece uma
interface simples e completa para configuração, definição e manipulação de tabelas
de bancos de dados Paradox e dBase.
20

Ilustração 10 – Database Desktop, com uma tabela aberta

4.3.1 Tabelas Paradox

Cada tabela em Paradox, corresponde a um arquivo, com o mesmo nome,


e cada arquivo tem associado a ele vários arquivos necessários para a criação de
índices, verificação de referências, validação e etc. Portanto o número total de
arquivos na base de dados aumenta rapidamente conforme é implementado novos
cadastros. Por esse motivo, não é aconselhável deixar a base de dados no mesmo
diretório que os programas fontes.

As tabelas de um mesmo banco de dados devem ser salvas na mesma


pasta, pois o Paradox trata a pasta onde estão as tabelas como sendo o banco de
dados. Para criar tabelas Paradox, o desenvolvedor deve seguir os seguintes passos:

• File/New/Table;

• Escolha o tipo da nova tabela, Paradox 7;

• Aparece uma janela para definir a estrutura da tabela, como campos,


índices e demais opções necessárias na criação da tabela;

• Em Field Name, você escolhe o nome do campo, com até 25


caracteres;
21

• Em Type, o Tipo do campo, com a barra de espaço ou o botão direito


do mouse você pode escolher o tipo a partir de uma lista;

• Size é o tamanho do campo, usado somente em alguns tipos de


campos;

• Key especifica os campos que farão parte da chave primária, e deve


ser composta pelos primeiros campos da tabela.

4.3.2 Table Properties

Em Table Properties são definidos os vários aspectos de configuração


da tabela. Muitas dessas opções podem ser implementadas no Delphi e vários
programadores preferem não usá-las no Database Desktop.
Opção Descrição
Validity Checks Validações para os campos, como
obrigatoriedade, valor mínimo e máximo
Table Lookup Indica que o valor atribuído a um determinado
campo tem que estar gravado em outra tabela
Secondary Indexes Cria índices secundários
Referential Integrity Cria integridade referencial, geralmente utilizada
em relacionamentos de 1 para N.
Password Security Permite a criação de senhas, protegendo a tabela
de acesso não autorizado
Table Language Especificar o driver de língua utilizado pela tabela,
geralmente é o Pdox ANSI Intl850
Dependent Tables Mostra todas as tabela dependentes através da
integridade referencial
4.3.3 Tipos de Campos

Os principais tipos de campos são mostrados abaixo, mas existem outros


além desses. Os tamanhos marcados com asterisco indicam que o campo pode
guardar tamanhos maiores que os informados, o que ultrapassar o tamanho será
guardado em um arquivo externo com a extensão MB.
Tipo Descrição Faixa Tamanho
A Alfanumérico 1-255
N Numérico 10 308
$ Monetário
S Inteiro 32767
22

I Inteiro longo 2147483648


D Data
T Hora
@ Data e Hora de modificação
M Memo 1-240*
G Gráfico 1-240*
L Lógico True/False
+ Auto incremental 1-2147483648
4.4 EXEMPLO

Como exemplo iremos criar um alias, que apontará para um tabela


paradox.

A tabela conterá uma lista de países, com suas respectivas capitais, o


continente onde está situada, a área e a população. Baseada nestas informações,
então, chega-se ao seguinte esquema para o banco de dados:
Nome do atributo Tipo Tamanho Chave Primária
Nome Alfanumérico 24 *
Capital Alfanumérico 24
Continente Alfanumérico 24
Área Numérico
População Numérico
Agora que esta definida a tabela a ser criada, começaremos com a criação
de uma estrutura de diretórios onde serão colocados os arquivos do projeto
(compreende os arquivos gerados para a criação do banco de dados, como também
código fonte da aplicação delphi).
23

Ilustração 11 – Pastas do Projeto

Abra o Windows Explorer e crie no drive C (ou onde achar mais


adequado) uma pasta para acomodar o projeto. Nesse caso chame de paises, dentro
dela crie mais duais sub pastas: fonte e basedados.

A pasta fonte ira conter o código fonte em Delphi do projeto, enquanto


basedados, conterá os arquivos do banco de dados paradox.

Usando o SQL Explorer do Delphi, crie um alias chamado paises


conforme é mostrado no tópico Criando um Alias, anteriormente discutido. Sendo
que a opção Path devera conter C:\paises\basedados, como é mostrado na Ilustração
12.
24

Ilustração 12 - Criando Alias Paises

Abra o Database Desktop, que é instalado juntamente com o delphi.


Nele execute FileÆ New Æ Table.

Ilustração 13 – Create Table do Database Desktop (Seleção tipo de Tabela)

Na janela Create Table (Ilustração 13), selecione Paradox 7 e confirme


com OK.

Crie os campos conforme exibido na Ilustração 13. A coluna key do


atributo nome esta marcada com um asterisco indicando que o mesmo é a chave
primária da tabela. Após completar os campos conforme a ilustração, selecione Save
As..., para salvar a tabela. Na caixa de diálogo Save Table As selecione no combo
Alias o alias que foi criado anteriormente (paises) para o banco de dados. Note que
ao selecionar o alias, a combo Salvar indica a sub pasta basedados, para onde foi
definido o caminho do mesmo.

Em nome do arquivo, digite o nome que será dado à tabela, neste caso
paises.db (ou apenas Clientes, pois a extensão será adicionada automaticamente de
acordo com o tipo de arquivo criado).
25

Ilustração 14 - Create Table do Database Desktop (Definição dos atributos da tabela)

Nesse ponto verifique os arquivos gerados na sub pasta basedados da


pasta paises. Ira constatar que foram criados os seguintes arquivos: paises.db e
paises.px.

Agora iremos partir para criar uma interface para acessar essa base de
dados.
26

5 CRIANDO A APLICAÇÃO

5.1 PRIMEIROS PASSOS

Seguindo o desenvolvimento do projeto, nesse ponto serão alterados


alguns parâmetros.

O tópico anterior, foi uma ilustração básica de como criar uma tabela
paradox e serviu perfeitamente para esse propósito. Agora que iremos construir a
interface, é interessante possuir uma base de dados populada de dados para uma
maior compreensão. Com esse intuito será utilizada um tabela, previamente
construída e populada que vem juntamente com a instalação do Delphi. Não há
obrigatoriedade, em usar tal tabela, pois a que foi criada anteriormente como
exemplo é quase igual a esta, sendo a única diferença (além de já possuir dados
como exemplo) que a nossa esta em português e a que vem no delphi esta em inglês.

Para usar a tabela populada, altere a opção Path do alias utilizando o SQL
Explorer para C:\Arquivos de programas\Arquivos comuns\Borland Shared\Data.
Esse caminho de pastas indica um conjunto de tabelas que já vem no delphi,
incluindo é claro a que iremos usar. (country.db - Ilustração 15)
27

Ilustração 15 - Tabela Country (paises)

No Delphi se ainda não foi iniciado um novo projeto, execute File Æ


New Æ Application. Salve o projeto e o formulário que foi criado automaticamente
(File Æ Save Æ All). Primeiramente o Delphi perguntará o nome da unit que será
armazenada, informe principal.pas. Essa unit armazenará o formulário principal do
sistema. Depois será solicitado o nome do projeto, lembre-se que o nome dado para
o projeto será o nome do executável gerado após a compilação do mesmo. Informe
paises para o nome do projeto.

Quando o projeto for compilado para geração de um executável, o


resultado final será um arquivo chamado paises.exe (programa executável).

5.2 FORMULÁRIO PRINCIPAL

• Altere a propriedade Name, do Form1, para FormPrincipal.

• Coloque a propriedade Caption como “Exemplo conexão a banco de


dados”.

• Altere as dimensões da FormPrincipal, para 208x358 (Height=208 e

width = 358)
28

• Na opção BorderIcons, de um clique com o mouse no sinal de adição


da propriedade e altere biMaximize para False. Esta opção desativa o maximizar de
uma janela, sendo assim, o usuário não poderá maximizar o aplicativo.

• Altere a propriedade BorderStyle para bsSingle. Com essa opção não


será permitido ao usuário alterar as dimensões da FormPrincipal.

• Agora na propriedade Position altere para poDesktopCenter. Com


isso a FormPrincipal será sempre carregada no centro da área de trabalho.

• Insira um Panel, da guia Standard no FormPrincipal.

• Altere a propriedade Width desse Panel para 105. A propriedade


Align para alLeft. As propriedades BevelInner e BevelOuter para bvLowered. E
por último apague o conteúdo da propriedade Caption do Panel.

Após isso o formulário irá parecer como o que esta na Ilustração 16.

Ilustração 16 – Formulário Principal com apenas o Panel

• Na guia Additional, selecione o componente Image e coloque-o no


lado direito do formulário, ou seja, do lado do Panel.

• Altere a propriedade Align do componente Image para alClient,


assim ocupará o resto do formulário que se encontra desocupado.

• Na propriedade Picture do Image, clique com o mouse nas


reticências, e aparecerá a tela de edição da propriedade (Picture Editor -Ilustração
17). Selecione o comando Load, para carregar uma imagem no componente. Nela
Aparecerá uma tela de seleção de arquivo. Vá para a pasta \Arquivos
comuns\Borland Shared\Images\Splash\256Color. Carregue o arquivo
HANDSHAK.BMP. Ele aparece na tela do editor de propriedade. Dê um clique no
botão OK, e a figura aparecerá no componente Image.
29

• Por último altere a propriedade Center para True do componente


Image. Com ela True a imagem fica no centro do componente.

Ilustração 17 – Picture Editor da Propriedade Picture do componente Image

• Insira três componentes BitBtn (botões) no Panel do formulário


principal.

Ilustração 18 – Ferramenta de Alinhamento

• Selecione os três botões, mantendo pressionada a tecla Shift, enquanto


dá um clique neles, e, com a paleta de alinhamento (Ilustração 18 -
View/Alignment Palette), alinhe os botões para o lado esquerdo (primeiro botão da
primeira linha), o espaçamento vertical (quarto botão da segunda linha) e centralize
na janela (terceiro botão da primeira linha e terceiro botão da segunda linha).

• Selecione o primeiro botão e faça as seguintes alterações: a


propriedade Name altere para BtnExibir; a propriedade Caption altere para Exibir;
na propriedade Hint escreva “Lista banco de dados”, e logo após altere para True a
30

propriedade ShowHint (Serve para ativar a exibição de dica quando o usuário


pousar o mouse sobre o botão).

• Selecione o segundo botão e faça as seguintes alterações: a


propriedade Name altere para BtnSair; a propriedade Caption altere para Sair; na
propriedade Hint escreva “Termina com a execução do programa”, e logo após
altere para True a propriedade ShowHint.

• Selecione o terceiro botão e faça as seguintes alterações: a propriedade


Name altere para BtnSobre; a propriedade Caption altere para Sobre; na
propriedade Hint escreva “Sobre o programa”, e logo após altere para True a
propriedade ShowHint.

• Na propriedade Ghyph do primeiro botão, clique com o mouse nas


reticências, e aparecerá a tela de edição da propriedade (Picture Editor - Ilustração
17). Selecione o comando Load, para carregar uma imagem no componente. Nela
Aparecerá uma tela de seleção de arquivo. Vá para a pasta \Arquivos
comuns\Borland Shared\Images\buttons. Carregue o arquivo SHOW.BMP. Ele
aparece na tela do editor de propriedade. Dê um clique no botão OK, e a figura
aparecerá no componente BitBtn. Faça o mesmo para os outros dois botões,
alterando apenas o nome do arquivo de imagem a ser carregado: para o botão Sair
selecione o arquivo DOOROPEN.BMP; e para o botão Sobre selecione o arquivo
HELP.BMP. O formulário deverá se parecer com o da Figura 6.

Ilustração 19 – Formulário Principal do programa

Salve todo o projeto novamente. (File Æ Save All)

5.3 FORMULÁRIO SOBRE

É comum colocar uma tela com informações do sistema, tais como sobre
quem o elaborou ou informações sobre a versão. Isso é tão comum em sistemas
Windows que o Delphi tem um modelo para esse tipo de tela.
31

• Selecione File Æ New Æ Other e na guia Forms escolha About Box.


Escolha a opção Copy e confirme em OK. É criada uma tela semelhante à exibida
na Ilustração 20.

Ilustração 20 – Formulário Sobre

• Em seguida troque o nome do formulário para FormSobre (Altere a


propriedade Name).

• Altere a propriedade Caption do formulário para Sobre.

• Selecione o ícone do formulário (componente TImage), e a sua


propriedade Picture. Dê um clique no botão com reticências para abrir o editor de
imagens (Ilustração 17). Selecione o comando Load, para carregar uma imagem no
componente. Nela Aparecerá uma tela de seleção de arquivo. Vá para a pasta
\Arquivos comuns\Borland Shared\Images\Splash\256Color. Carregue o arquivo
HANDSHAK.BMP. Ele aparece na tela do editor de propriedade. Dê um clique no
botão OK, e a figura aparecerá no componente Image

• No label Product Name, altere a sua propriedade Caption para


“Exemplo conexão a banco de dados”.

• Na label Version escreva na propriedade Caption, “Versão 1.0”.

• Na label Copyright: “Copyright 2004”.

• E finalmente na label Comments: “Sistema desenvolvido para ilustrar


o funcionamento da conexão com banco de dados Paradox com aplicativos Delphi,
usando componentes dataware”.
32

• Ainda no label Comments altere as seguintes propriedades: Height


para 49 e width para 257; Alignment para taCenter, para centralizar o texto dentro
da label.

• Salve a unit do formulário Sobre (File Æ Save), e informe o nome da


unit, que é Sobre. Não esqueça de verificar onde esta sendo salva a unit, que deve
ser na pasta do projeto. Pode também ser salvo pelo comando File Æ Save All.

O formulário deverá se parecer com o da Ilustração 21. Por último


execute File Æ Close, para o formulário ser fechado pois não será usado por
momento.

Ilustração 21 – Formulário Sobre versão final

5.4 DATAMODULE

O DataModule, é um com componente semelhante ao Formulário


(TForm) usado para centralizar as tabelas usadas no sistema, ou seja, componentes
não visuais, mas principalmente tabelas, queries e seus DataSources
correspondentes.

Embora seja perfeitamente válido inserir esses componentes diretamente


em uma Form, é interessante incluir os componentes de acesso a dados em um
DataModule, pois dessa maneira separamos o acesso a dados da interface com o
usuário, facilitando a manutenção posterior do programa.. Para esse sistema
exemplo nem seria necessário proceder dessa maneira, pois será usada somente uma
tabela, mas para titulo de aprendizagem será usado DataModule.

Para criar um DataModule, siga os seguintes passos:

• Com o projeto aberto, execute File Æ New Æ DataModule.


33

• Troque a propriedade Name do DataModule para DMDados.

• Logo após insira um componente Table da Guia BDE, no


DataModule.

• Altere a propriedade Name do componente Table para TbPaises.

• Na propriedade DataBaseName, selecione o alias paises (ou


DBDEMOS, esse alias “aponta” para uma base de dados de exemplo que é instalada
juntamente com o Delphi). Será usada a tabela Country.db para este exemplo.

• Na propriedade TableName, escolha a tabela Country.db.

• E finalmente altere para True a propriedade Active do componente


Table. Dessa maneira é ativada a tabela, para assim o aplicativo delphi poder editar,
alterar, excluir dados, ou simplesmente executar uma busca na tabela.

O passo seguinte é configurar os campos da tabela. Isso é feito ligando-se


um campo físico da tabela a um componente TField. Isso ajuda a manipulação dos
campos dentro do programa, além de permitir especificar a máscara de edição, a
máscara de apresentação, uma rotina de validação do campo, e permitir indicar qual
o título que será usado na apresentação dos campos. Para criar TFields
correspondentes aos campos da tabela, você deve dar um clique duplo na tabela para
exibir o Fields Editor. (Ilustração 22)

Ilustração 22 – Fields Editor 1

Ao dar um clique com o botão direito do mouse, aparece um menu, no


qual deve se selecionar Add All Fields. Todos os campos da tabela são adicionados
à lista (Ilustração 23). Então pode-se selecioná-los, um a um, e alterar suas
propriedades ou criar um código para tratar seus eventos.
34

No caso desse exemplo não será criada nenhuma validação de campo.

Ilustração 23 - Fields Editor 2

• Insira agora um componente DataSet, da guia DataAccess.

• Altere a sua propriedade Name, para DSPaises.

• E na sua propriedade DataSet, selecione o componente Table do


DataModule, ou seja, TbPaises.

Feche o DataModule, pois não será usado por enquanto. (File Æ Close)
Note que o projeto ainda continua aberto, e seguiremos a trabalhar nele. Apenas foi
fechado o DataModule para não poluir a tela, deixando-a livre para a criação da
próxima etapa.

5.5 FORMULÁRIO DE CONSULTA

Siga os seguintes passos:

• Considerando que estejas com o projeto do programa aberto, execute o


comando File ÆNew ÆForm.

• Faça as seguintes alterações no formulário recém criado: a propriedade


BorderStyle deve ser alterada para bsDialog; O conteúdo da propriedade Caption
dever ser apagada; Altere as dimensões da Form para Heigth = 367 e Width = 502;
a propriedade Name deve ser alterada para FormConsulta.

• Da guia Standard, insira um Panel no formulário.

• Mude a propriedade Align para alBottom. O Panel será colocado na


parte inferior do formulário. Também altere a propriedade Heigth para 36.
35

• Insira mais um Panel agora na parte superior do formulário. Altere a


propriedade Align do Panel para alClient, para o mesmo ocupar todo o resto do
formulário.

• Da guia Data Controls, insira no Panel superior um DBGrid, e altera


a propriedade Align para alCliente.

• Adicione três componentes BitBtn, no Panel inferior do lado esquerdo


e mais um componente BitBtn no seu lado direito como mostra a Ilustração 24.

• Alinhe os botões como mostrado na Ilustração 24, isto pode ser feito
manualmente (não recomendado), ou usar a ferramenta de alinhamento de
componentes Ilustração 18.

• Altere os Captions dos botões como exibidos na Ilustração 24, e as


propriedades Name de cada um como segue: o primeiro para BtnAlterar, o segundo
para BtnNovo, o terceiro para BtnExcluir e finalmente o terceiro BtnFechar.

• Na propriedade Ghyph do primeiro botão, clique com o mouse nas


reticências, e aparecerá a tela de edição da propriedade (Picture Editor -Ilustração
17). Selecione o comando Load, para carregar uma imagem no componente. Nela
Aparecerá uma tela de seleção de arquivo. Vá para a pasta \Arquivos
comuns\Borland Shared\Images\buttons. Carregue o arquivo EDIT.BMP. Ele
aparece na tela do editor de propriedade. Dê um clique no botão OK, e a figura
aparecerá no componente BitBtn.

Faça o mesmo para os outros três botões, alterando apenas o nome do


arquivo de imagem a ser carregado: para o botão Novo selecione o arquivo
FILENEW.BMP; para o botão Excluir selecione o arquivo ERASE.BMP; e
finalmente para o botão Fechar, selecione o arquivo DOORSHUT.BMP.
36

Ilustração 24 – Formulário consulta países

• Selecione os quatro botões, mantendo pressionada a tecla Shift,


enquanto dá um clique neles, e, altere a propriedade ShowHint de todos os botões
para True. Após clique em qualquer outro componente do formulário que não seja
um botão, para retirar a seleção dos componentes.

• Na propriedade Hint do botão Alterar escreva: “Altera o registro


atual”.

• Na propriedade Hint do botão Novo escreva: “Cria um novo registro”.

• Na propriedade Hint do botão Excluir escreva: “Exclui o registro


atual”.

• Na propriedade Hint do botão Fechar escreva: “Fecha o formulário e


retorna ao principal”.

• Salve a Unit com o nome de consulta.(File Æ Save) Não esquecer de


verificar se a Unit esta sendo salva na pasta correta.

• Pressione Alt+F11, para surgir a tela Use Unit (Ilustração 25).


Selecione modulo e confirme em OK. Com isso surgira uma linha de comando Uses
na Unit do formulário (Código 1), pressione F12 para ver no Editor de Código do
Delphi.
37

Ilustração 25 – Caixa de dialogo Use Unit

var
FormConsulta: TFormConsulta;

implementation

uses modulo;

{$R *.dfm}

end.
Código 1 – Cláusula Uses Formulário de consulta

Essa cláusula indica para o Delphi onde encontrar os componentes de


conexão com o banco de dados, para assim serem usados no formulário.

• Selecione o componente DBGrid do formulário. Na propriedade


DataSet, selecione DMDados.DSPaises. Com esse passo surgira as colunas da
tabela na grade. Se por acaso não aparecerem os dados da tabela, volte para o
DataModule (DMDados), e altere a propriedade Active do componente TbPaises
para True. (Ilustração 26)
38

Ilustração 26 – Formulário de Consulta de países com registros

• Dê um clique duplo sobre o botão Fechar, e insira o Código 2.

procedure TFormConsulta.BtnFecharClick(Sender: TObject);


begin
Close;
end;
Código 2 -– Código fonte botão fechar do formulário Mestre.

Por momento feche o formulário para posterior uso (File Æ Close)

5.6 FORMULÁRIO PARA EDIÇÃO DA TABELA PAÍSES

Com o projeto aberto siga os seguintes passos:

• Crie um novo formulário (File ÆNew Æ Form).

• No novo formulário, altere as seguintes propriedades: BorderStyle


para bsDialog; Caption para “Alterar Registro”; Height para 331; Name para
FormAlterar; Width para 430.

• Insira no formulário três Panels um a baixo do outro.


39

• No primeiro configurar a propriedade Align para alTop; Alignment


para taCenter; O Caption para “Alterar Registro”; Acesse as opções da propriedade
Font, clicando com o mouse no sinal de adição, faça as seguintes alterações: Color
para clHighlight, e Size para 15.

• No terceiro Panel, o inferior, altere a propriedade Align para alBotton.

• No segundo Panel, o do meio, altere a propriedade Align para


alClient.

• Apague o conteúdo do Caption do Panel inferior e o central.

Ilustração 27 – Formulário Alterar Registro

• Insira 5 (cinco) componentes Label da guia Standard, um abaixo do


outro, como mostrado na Ilustração 27. Logo após altere a propriedade Caption de
cada uma para Pais, Capital, Continente, Área (m²) e População. Também alinhe
adequadamente como mostrado na Ilustração 27, no qual poderá ser utilizado a
ferramenta de alinhamento (Ilustração 18)

• Insira 5 (cinco) componentes DBEdit da guia Data Controls, um


abaixo do outro, como mostrado na Ilustração 27. Alinhe adequadamente os
componentes como mostrado na Ilustração 27, no qual poderá ser utilizado a
ferramenta de alinhamento (Ilustração 18)
40

• O último passo nesse momento é ligar cada componente DBEdit com


o seu respectivo TFields, ou seja, com o campo da tabela do componente Table
(TbPaises).

• Pressione Alt+F11, para surgir a tela Use Unit (Ilustração 25).


Selecione modulo e confirme em OK.

• Selecione o primeiro DBEdit, e na sua propriedade DataSource


coloque DMDados.DSPaises. Na propriedade DataField selecione Name. Faça
procedimento semelhante para os outros DBEdit, cada uma com o seu respectivo
campo.

• Insira um DBNavigator da guia Data Controls, e um componente


BitBtn, no Panel inferior, como na Ilustração 27.

• Ainda no DBNavigator, altere a propriedade DataSet para


Dados.DSPaises. Este componente serve para navegação, edição, inserção e
exclusão de registros.

• Altere a propriedade Name do BitBtn, para BtnFechar. E altere sua


aparência como mostrado na Ilustração 27.

• Dê um clique duplo sobre o botão Fechar, e insira o Código 3.


procedure TFormAlterar.BtnFecharClick(Sender: TObject);
begin
Close;
end;
Código 3 – Código fonte botão fechar do formulário Alterar Registro

Finalmente salve a Unit do formulário com o nome de alterar.

5.7 FORMULÁRIO PARA INSERÇÃO DA TABELA PAÍSES

Agora partiremos para a criação do formulário para inclusão de novos


países. Apesar de o próprio formulário de alteração, após ser aberto, ser totalmente
capaz de realizar tal tarefa iremos a titulo de aprendizagem criar um outro
formulário para Inclusão.

A princípio você deve estar pensando: “Agora vou ter que fazer tudo de
novo, deve ter alguma outra maneira”. Não é necessário desenhar todo o formulário
novamente. Podemos simplesmente criar um novo usando o que já existe como
modelo, dessa maneira:
41

• Execute File Æ New Æ paises, escolha FormAlterar e OK.

• Altere o Caption do panel de cima para “Novo Registro”.

• Altere o Caption do formulário para “Novo Registro”, como também


a propriedade Name para FormNovo.

O formulário está pronto. Observe que se pressionar F12 para visualizar o


código e olhar na cláusula Type, verá alto diferente.
type
TFormNovo = class(TFormAlterar)
private
{ Private declarations }
public
{ Public declarations }
end;
Observe que o TFormNovo é uma classe derivada do TFormAlterar, ou
seja, foi criado formulário inteiro baseado na classe TFormAlterar criada
anteriormente. Isso além de tornar a tarefa muito mais rápida, também propicia
vantagens, se o usuário optasse por criar o formulário do zero. Com essa
metodologia, as alterações feitas, não só na aparência do formulário Alterar, como
também a inserção ou melhoramento de código será repassado para para todos os
seus descendentes.

Grave o formulário com o nome de novo. (FileÆ Save)


42

6 RETOQUES FINAIS

Agora que os formulários estão prontos, falta somente “ligar” eles, ou


seja, fazer com que:

1. O formulário principal “chame” o formulário de consulta e o Sobre;

2. O formulário de Consulta “chame” o formulário de edição e inserção


do registro;

6.1 FORMULÁRIO PRINCIPAL

Primeiramente dê um duplo clique com o mouse no botão Sair, para


surgir o editor de código do Delphi, e insira o Código 4.
procedure TFormPrincipal.BitBtn2Click(Sender: TObject);
begin
Application.Terminate;
end;
Código 4 – Código para Terminar a aplicação

Com a linha Application.Terminate, agregada ao botão sair, a aplicação


será encerrada e todos os formulários pertencentes ao aplicativo com ele. Como esse
formulário é o principal, poderia também ser utilizado o comando Close, que fecha o
formulário, pois seria entendido que com o fechamento deste estaria encerrada a
aplicação. Mas se usado em um outro formulário que não seja o principal o comando
Close somente ira fechar o formulário atual, e voltar para o formulário que o
chamou.

Observando ainda a linha em questão pode-se notar que Terminate é um


método de um objeto, que neste caso é o Application. O Objeto Application é
43

instanciado automaticamente quando se tem um aplicativo Delphi, e contém vários


métodos e propriedades que dão suporte a um aplicativo tipicamente Windows. Para
ver os métodos e propriedades desse Objeto selecione Delphi Help no menu Help
do Delphi. Na guia Índice, no campo “1” digite TApplication (nome da classe da
onde é instanciado o objeto Application), selecione na lista do item “2”,
TApplication, e finalmente na próxima tela que surge (Tópicos Encontrados),
novamente TApplication. Surgira finalmente a ajuda completa da classe -Ilustração
28.

Ilustração 28 – Ajuda da Classe TApplication

Dê uma boa olhada nos métodos e propriedades desse objeto, podem ser
úteis para uma aplicação mais robusta.
44

Agora e insira o Código 5 no botão sobre.


procedure TFormPrincipal.BitBtn3Click(Sender: TObject);
begin
FormSobre.ShowModal;
end;
Código 5 – Código fonte para exibir o formulário Sobre

Existem dois métodos para chamar um formulário. O primeiro é o


método Show, exibe o formulário em modo não exclusivo, ou seja, pode abrir o
formulário e continuar trabalhando com outros ao mesmo tempo incluindo o
formulário chamador. O método utilizado neste caso, ShowModal, exibe um
formulário em modo exclusivo, ou seja, não permite o uso formulário
simultaneamente somente em cascata. Para usar o anterior é necessário fechar o
atual.

Para terminar, falta agora somente atrelar o código ao botão exibir que é
mostrado no Código 6.
procedure TFormPrincipal.BitBtn1Click(Sender: TObject);
begin
FormConsulta.ShowModal;
end;
Código 6 -Código fonte para exibir o formulário Mestre

Quando compilar o projeto, surgira uma mensagem semelhante a


Ilustração 29.

Ilustração 29 – Mensagem para inclusão de uma Unit

A mensagem da Ilustração 29 avisa ao usuário que neste caso o


formulário FormConsulta faz uma referencia para o FormAlterar (Formulário para
alterar um registro). Essa referência se faz devido ao uso do comando FormAlterar.
ShowModal no formulário de consulta, para alteração do registro selecionado na
grade.
45

Respondendo Yes, a Unit alterar é incluída na uses do formulário mestre


para o mesmo “enxergar” o formulário, sendo assim, poderá acessar os métodos,
propriedades e componentes do formulário alterar.

Feche o formulário por que não será mais usado para realizar
modificações. (File Æ Close).

6.2 FORMULÁRIO DE CONSULTA.

Com somente o projeto aberto e todos os formulários fechados – de


preferência, ou seja, não é obrigatório – selecione o botão de comando View Form
(Shift+F12), na barra de ferramentas, ou ainda, Forms... no menu View.

Após executar o comando surgira na tela uma caixa de seleção como


exibido na Ilustração 30, selecione FormConsulta e confirme no botão OK.

Ilustração 30 – View Form

Surgirá na tela o formulário consulta. Agora precisamos realizar algumas


alterações para dar maior funcionalidade para o mesmo.

O primeiro botão que será atrelado código é o excluir. Dê um duplo


clique no mesmo e insira o Código 7.
46

procedure TFormConsulta.BtnExcluirClick(Sender: TObject);


begin
DMDados.TbPaises.Delete;
end;
Código 7 – Código fonte do botão excluir no formulário consulta

Analisando o Código 7, pode-se notar dois objetos: DMDados e


TbPaises.

O objeto DMDados, consiste no DataModule anteriormente. E o objeto


TbPaises é um objeto DataSet (Table) inserida no DataModule que faz referencia
física à tabela através da engine.

Então a linha DMDados.TbPaises.Delete, quer dizer que está sendo


executado o método Delete do objeto TbPaises que se encontra no DMDados
(DataModule), que nada mais é que um objeto.

Com isso pode-se notar que alguns dos componentes usados na aplicação
podem fazer referencia a outros objetos, ou ainda conter outros objetos dentro de si.
Como é o caso de TForm (Classe que dá origem aos objetos do tipo formulário),
TPanel (classe que dá origem aos objetos do tipo Panel), no qual ambos podem ter
outros objetos contidos.

Finalmente o método Delete, como o próprio nome já sugere, executa o


procedimento de exclusão de um registro referenciado pelo objeto Table. Para
conhecer outros métodos desse componente consulte a ajuda constante do Delphi,
como explicado anteriormente.

No botão Alterar, coloque o Código 8.


procedure TFormConsulta.BtnAlterarClick(Sender: TObject);
begin
// Ativa o modo de edição do DataSet
DMDados.TbPaises.Edit;
// Exibe o formulário Alterar Registro
// representado pelo objeto FormAlterar
// em modo Modal
FormAlterar.ShowModal;
end;
Código 8 – Código fonte botão alterar no formulário consulta.

A linha FormAlterar.ShowModal, já foi comentada só que com outro


formulário então não será repetido.
47

O que tem novo, é a linha DMDados.TbPaises.Edit, no qual é executado


um método Edit, do componente DataSet que está no DataModule.

Note que antes, de abrir o formulário com o comando


FormAlterar.ShowModal, foi executado o método Edit que altera o estado do
componente DataSource associado ao componente DataSet para o modo de edição.
Assim quando o formulário detalhe é aberto os dados exibidos nele são passíveis de
mudança.

Por último falta colocar o código para o botão Novo.


procedure TFormConsulta.BtnNovoClick(Sender: TObject);
begin
// Ativa o modo de Inserção do DataSet
DMDados.TbPaises.Insert;
// Exibe o formulário Novo Registro
// representado pelo objeto FormNovo
// em modo Modal
FormNovo.ShowModal;
end;
Código 8 – código fonte do botão novo do formulário consulta

Em vez de ser usado o método Edit do DataSet, desta vez foi executado
o Insert. Que coloca o DataSource associado ao componente DataSet para o modo
de Inserção de dados. Uma vez que o formulário Novo Registro seja aberto será
exibido com os campos vários aguardando que sejam inseridos novos dados.

You might also like