Material Delphi diego

Índice

1 INTRODUÇÃO AO AMBIENTE DELPHI® ................................................. 2
1.1 AMBIENTE DELPHI ........................................................................ 2
1.2 TIPOS DE ARQUIVOS GERADOS PELO D ELPHI .............................................. 2
1.2.1 Units (.pas) ..................................................................................................................................... 2
1.2.2 Estrutura das units...................................................................................................................... 2
1.2.3 Forms (.dfm) .................................................................................................................................. 3
1.2.4 Projeto (.dpr)................................................................................................................................. 3
1.2.5 Esquema da estrutura dos arquivos ........................................................................................ 3
1.2.6 Outros tipos de arquivos............................................................................................................ 4
1.3 ÁREA DE TRABALHO ....................................................................... 4
1.3.1 Menus ............................................................................................................................................... 5
1.3.2 Botões de atalho........................................................................................................................... 5
1.3.3 Paleta de componentes ............................................................................................................... 5
1.3.4 Object Inspector ......................................................................................................................... 5
1.3.4.1 Properties (aba) .........................................................................................................................................5
1.3.4.2 Events (aba).................................................................................................................................................7
1.3.5 Form (Formulários) ...................................................................................................................... 8
1.3.6 Unit ................................................................................................................................................... 9
1.3.6.1 Estrutura de uma unit ..............................................................................................................................9
1.4 PROGRAMANDO NO AMBIENTE D ELPHI ..................................................... 9
1.4.1 Principais tipos de dados do ambiente Delphi ..................................................................... 9
1.4.2 Conversão de tipos ..................................................................................................................... 10
1.4.3 Declaração de variáveis............................................................................................................ 10
1.4.3.1 Variáveis globais....................................................................................................................................... 10
1.4.3.2 Variáveis locais ......................................................................................................................................... 11
1.4.4 Declaração de procedimentos e funções ............................................................................. 11
1.4.5 Tratamento de erros (exceções) .......................................................................................... 13
1.4.5.1 Bloco Try ... Except ................................................................................................................................. 13
1.4.5.2 Bloco Try... Finally ................................................................................................................................... 13
1.4.6 Depurando a aplicação (debugger) ........................................................................................ 14
1.4.6.1 Breakpoints ................................................................................................................................................ 14
1.4.6.2 Watches ..................................................................................................................................................... 15
1.5 TRABALHANDO COM COMPONENTES ......................................................15
1.5.1 Paleta de componentes (Component palette’s) .................................................................. 15
1.5.2 Propriedades................................................................................................................................ 16
1.5.3 Eventos (Events) ........................................................................................................................ 16
1.5.4 Métodos ........................................................................................................................................ 16
2 BANCO DE DADOS INTERBASE®........................................................18

2.1 INTRODUÇÃO ............................................................................18
2.2 BANCO DE DADOS INTERBASE ............................................................18
2.3 SQL DML (DATA MANIPULATION LANGUAGE) ...........................................18
2.3.1 Cláusula Select (“selecione”)................................................................................................... 19
2.3.2 Cláusula From (“origem”) .......................................................................................................... 19

Prof. Eduardo Cotrin Teixeira

2.3.3 Cláusula Where (“onde”)........................................................................................................... 20
2.3.4 Cláusula Order By ...................................................................................................................... 21
2.3.5 Operadores .................................................................................................................................. 21
2.3.5.1 Operadores de comparação .................................................................................................................. 21
2.3.5.2 Operadores lógicos ............................................................................................................................ 22
2.4 SQL DDL (D ATA DEFINITION LANGUAGE) ..............................................22
2.4.1 Criando um banco de dados Interbase ................................................................................ 23
2.4.2 Interbase Interactive SQL .................................................................................................... 25
2.4.3 Criando tabelas no Interbase................................................................................................. 25
3 DESENVOLVENDO UM APLICATIVO COM BANCO DE DADOS (INTERBASE).......28
3.1 INICIANDO UMA NOVA APLICAÇÃO ......................................................28
3.2 CONFIGURANDO OPÇÕES DO PROJETO ....................................................29
3.3 DEFININDO O MENU DO FORMULÁRIO PRINCIPAL .........................................29
3.4 CONECTANDO O APLICATIVO (D ELPHI) AO INTERBASE ...................................32
3.4.1 O que são Data Modules?......................................................................................................... 32
3.5 CONECTANDO AO B ANCO.GDB ............................................................32
3.6 TRANSAÇÕES E ACESSO CONCORRENTE EM BANCO DE DADOS .............................34
3.6.1 Controlando transações através do componente IBTransaction ................................. 34
3.7 ADICIONADO AS TABELAS DO BANCO DE DADOS .........................................34
3.7.1 Conectando a tabela Departamento ..................................................................................... 34
3.7.2 Conectando a tabela Dependentes........................................................................................ 35
3.7.3 Conectando a tabela Estados.................................................................................................. 35
3.7.4 Conectando a tabela Funcionários ......................................................................................... 36
3.8 ADICIONANDO OS CAMPOS DAS TABELAS ................................................37
3.9 ADICIONADO CAMPOS L OOKUPS ..........................................................39
3.10 CADASTRO DE ESTADOS ...............................................................41
3.10.1 Habilitando e Desabilitando os botões da barra .............................................................. 44
3.10.2 Adicionando os códigos dos botões da barra..................................................................... 45
3.10.3 Adicionando código do formulário ......................................................................................... 46
3.10.4 Validações de dados .................................................................................................................. 47
3.10.4.1 Verificando a existência chave primária: ................................................................................... 47
3.10.4.2 Verificando os campos de preenchimento obrigatório ........................................................... 50
3.10.5 Pesquisa do Cadastro de Estados .......................................................................................... 51
3.11 CONSTRUINDO FORMULÁRIOS MODELOS (REPOSITÓRIO) ...............................56
3.11.1 Adicionando o formulário de Cadastro Estados ao Repositório ................................... 56
3.11.2 Adicionando o formulário de Pesquisa de Estados ao Repositório .............................. 56
3.12 CADASTRO DE DEPARTAMENTO ........................................................56
3.12.1 Pesquisa do Cadastro de Departamento .............................................................................. 58
3.13 CADASTRO DE FUNCIONÁRIOS .........................................................60
3.13.1 Pesquisa do Cadastro de Funcionários ................................................................................. 63
3.14 CADASTRO DE DEPENDENTES ..........................................................66
3.14.1 Definindo a tabela Dependente como detalhe da tabela Funcionário ........................ 68
3.14.2 Quando posso aplicar o recurso mestre-detalhe ? .......................................................... 68
4 RELATÓRIOS ...............................................................................70
4.1 ELABORANDO RELATÓRIO SIMPLES (RELATÓRIO DE E STADOS)............................70


4.2 ELABORANDO RELATÓRIO MESTRE-DETALHE (FUNCIONÁRIO E SEUS DEPENDENTES) ......73
4.3 UTILIZANDO QUERY PARA ELABORAR RELATÓRIO DE SOMA DE SALÁRIOS POR
D EPARTAMENTO ................................................................................77
5 RELACIONANDO O APLICATIVO A AJUDA ON-LINE (F1)...........................82
5.1 DEFININDO O ARQUIVO DE AJUDA DO APLICATIVO ......................................82
5.2 DEFININDO A AJUDA CONTEXTUAL (F1) .................................................82
5.3 ATIVANDO A AJUDA PELO FORMULÁRIO PRINCIPAL .......................................82
6 CONSTRUINDO O INSTALADOR ........................................................83
6.1 CRIANDO O PROJETO DE INSTALAÇÃO ...................................................83
6.2 CONFIGURANDO AS OPÇÕES DE INSTALAÇÃO .............................................83
6.2.1 Configurando o grupo Set the Visual Design ..................................................................... 84
6.2.2 Configurando o grupo Specify Components and Files ..................................................... 85
6.2.3 Configurando o grupo Select User Interface Components........................................... 86
6.2.4 Configurando o grupo Specify Folders and Icons ............................................................ 86
6.2.5 Configurando o grupo Run Disk Builder ............................................................................... 87
6.2.6 Grupo Create Distribution Media.......................................................................................... 87
7 REFERÊNCIAS BIBLIOGRÁFICAS ........................................................89


Índice de Figuras

Figura 1 – Área de Trabalho............................................................................................................................... 4
Figura 2 – Utilizando breakpoints .................................................................................................................. 14
Figura 3 – Janela Watch List .......................................................................................................................... 15
Figura 4 – Paleta de componentes .................................................................................................................. 16
Figura 5 – Estrutura de diretórios utilizada para o desenvolvimento do aplicativo ....................... 23
Figura 6 – Janela Create Database ............................................................................................................... 23
Figura 7 – Janela Register Database ............................................................................................................ 24
Figura 8 – Modelagem de um sistema para cadastrar funcionários..................................................... 25
Figura 9 – Data Module ..................................................................................................................................... 32
Figura 10 – Janela Database Component Editor ........................................................................................ 33
Figura 11 – Data Module DM_Funcionarios com os componentes ......................................................... 36
Figura 12 – Definição de campo Lookup na tabela funcionário .............................................................. 40
Figura 13 – Formulário de Cadastro de Estados ........................................................................................ 41
Figura 14 – Barra de botões............................................................................................................................. 44
Figura 15 – Formulário de Pesquisa de Estados ......................................................................................... 51
Figura 16 – Formulário de Cadastro de Departamentos .......................................................................... 57
Figura 17 – Formulário de Pesquisa de Departamentos ........................................................................... 58
Figura 18 – Formulário de Cadastro de Funcionários ............................................................................... 61
Figura 19 – Formulário de Pesquisa de Funcionários................................................................................. 63
Figura 20 – Cadastro de Dependentes ......................................................................................................... 66
Figura 21 – Relatório de Estados.................................................................................................................... 70
Figura 22 – Relatório de Funcionários e Dependentes ............................................................................ 73
Figura 23 – Relatório da soma de Salários por Departamento.............................................................. 78
Figura 24 – Tela inicial do InstallShield ...................................................................................................... 83
Figura 25 – Tela de opções de configuração de projeto ......................................................................... 84
Figura 26 – Janelas lado a lado ....................................................................................................................... 86
Figura 27 – Grupos de arquivos da instalação ............................................................................................ 86
Figura 28 – Componentes de Interface ....................................................................................................... 87


1

ADVERTÊNCIA

Esta apostila aborda o ambiente Delphi através do desenvolvimento de um aplicativo de
controle de funcionários. Para que os resultados sejam alcançados, é fundamental que os
passos sejam seguidos a risca (nomes de diretórios, nomes de arquivos, nomes de tabelas,
nomes de componentes, etc).

DIREITOS AUTORAIS

Todos os direitos reservados e protegidos pela Lei 5988 de 14/12/1973. Nenhuma
parte desta apostila, sem autorização prévia por escrito do autor, poderá ser reproduzida ou
transmitida sejam quais forem os meios empregados: eletrônicos, mecânicos, fotográficos,
gravação ou quaisquer outros. Todo esforço foi feito para fornecer a mais completa e
adequada informação. Contudo, o autor não assume responsabilidade pelos resultados e uso da
informação fornecida. Recomendo aos leitores testar a informação antes da efetiva utilização.

MARCAS REGISTRADAS

Todos os termos mencionados nesta apostila conhecidos como marcas registradas ou de
serviços foram devidamente apresentados na forma iniciada por maiúscula. O uso de termos
nesta apostila não deve ser considerado como infração a validade das marcas registradas ou de
serviços.
Delphi é marca registrada da Borland Corporation.
Interbase é marca registrada da Interbase Software Corporation.
InstallShield é marca registrada da InstallShield Corporation.
Windows é marca registrada da Microsoft Corporation.

No caso de erros, omissões, etc , favor enviar e-mail para: cotrin@utfpr.edu.br

Autor do material original (Delphi 5):
Prof. Edson dos Santos Cordeiro-Unopar Londrina, 2000
Esta adaptação (Delphi 7):
Prof. Eduardo Cotrin Teixeira - UTFPR Cornélio Procópio, 2007

Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 2

1 INTRODUÇÃO AO AMBIENTE DELPHI®

1.1 Ambiente Delphi

O desenvolvimento de software com qualidade e rapidez constitui-se em requisitos
indispensáveis exigidos pelo mercado. Dentre as inúmeras ferramentas de desenvolvimento, o
ambiente Delphi tem se destacado pela rapidez e grande número de recursos oferecidos ao
desenvolvedor. Classificado como uma ferramenta RAD (Rapid Application Development), o
ambiente Delphi oferece uma série de recursos que agilizam e facilitam o desenvolvimento de
aplicativos. Além disso, o suporte que o ambiente oferece para acesso a diversos bancos de
dados chamou a atenção da comunidade de desenvolvedores fazendo com que a ferramenta, em
pouco tempo, fosse adotada por milhões de programadores no mundo todo.

1.2 Tipos de arquivos gerados pelo Delphi

1.2.1 Units (.pas)
Um programa é construído através de módulos de código fonte chamados de units. Cada
unit é armazenada em seu próprio arquivo (.PAS) e compilada separadamente, gerando um
arquivo .DCU (Dephi Compiled Unit). Os arquivos de units compilados (.DCU) são unidos (linked)
para criar uma aplicação. As units permitem:
Dividir um programa em diversos módulos que podem ser editados separadamente;

Criar bibliotecas que poder ser compartilhadas entre diversas aplicações;
Distribuir bibliotecas para outros desenvolvedores sem disponibilizar o código
fonte.

1.2.2 Estrutura das units

unit Unit1; {identificação da unit}
interface
uses SysUtils, Windows, Messages, Classes, Graphics, Controls, Forms, Dialogs; {Cláusula uses}
type
TForm1 = class(TForm) {Declaração de classe}
private
{ Private declarations } {Declarações privadas}
public
{ Public declarations } {Declarações públicas}
end;
var
Form1: TForm1; {declaração de instância - objeto}
implementation
{$R *.DFM} {diretiva do compilador para “unir - link” o formulário a unit}
end. {finaliza a unit}



1.2.3 Forms (.dfm)
Formulários (forms) são a parte visível de uma aplicação Delphi. Arquivos de
formulários (extensão .dfm) descrevem cada componente presente no formulário, incluindo os
valores de suas propriedades. Cada formulário em uma aplicação Delphi é associado a uma unit
(.pas), entretanto, nem toda unit precisa ter um formulário associado. A unit associada ao
formulário contém o código fonte de qualquer evento associado aos componentes de um
formulário. Os formulários recebem o mesmo nome da unit que está associado diferenciando-
se apenas pela extensão (.dfm).

1.2.4 Projeto (.dpr)
O ponto central do código fonte de um projeto é chamado de arquivo de projeto. Este
arquivo é atualizado pelo Delphi durante o desenvolvimento da aplicação. O arquivo de projeto
contém referências para todas as units e forms usados no projeto.

program Project1; {identificação do projeto}
uses {indica as units utilizadas pelo projeto}
Forms,
Unit1 in 'UNIT1.PAS' {Form1}; {nome das units associadas ao projeto}
{$R *.RES} {arquivos de recursos associado ao projeto}
begin {início do bloco principal do programa}
Application.Initialize;
Application.CreateForm(TForm1, Form1); {cria o primeiro formulário automaticamente}
Application.Run; {executa a aplicação}
end. {final do bloco principal do programa}

1.2.5 Esquema da estrutura dos arquivos

TESTE

.DPR .EXE

FORM 1 FORM 2 FORM N

.DCU .DCU .DCU

FORM 1 FORM 2 FORM N

.DFM UNIT 1 .DFM UNIT 2 .DFM UNIT N ROTINAS

.PAS .PAS .PAS .PAS



1.2.6 Outros tipos de arquivos

Extensão Definição Função
.DPR Arquivo do Projeto Código fonte em Pascal do arquivo principal do projeto. Lista todos os
formulários e units no projeto, e contém código de inicialização da aplicação.
Criado quando o projeto é salvo.
.PAS Código fonte da Unit Contém todas as declarações, procedimentos, funções e eventos associados
(Object Pascal) aos componentes de um formulário.
.DFM Arquivo gráfico do Arquivo binário que contém as propriedades, e seus respectivos valores, de
formulário um formulário contido em um projeto. Um .DFM está sempre associado a um
arquivo .PAS do projeto.
.DSK Situação da Área de Armazena o estado corrente da área de trabalho, como por exemplo onde as
Trabalho janelas (paleta de componentes, Object Inspector, etc.) estão posicionadas,
suas medidas, etc.
.RES Arquivo de Recursos do Arquivo binário que contém o ícone, mensagens da aplicação e outros
Compilador recursos usados pelo projeto.
.DOF Delphi Options File Contém o conjunto de opções do projeto (opções de: compilador, linker,
diretórios, diretivas, etc.)
.CFG Arquivo de configuração Armazena o conjunto de configuração do projeto. Este arquivo tem o mesmo
do projeto nome do arquivo de projeto, porém, com a extensão .cfg.
.~DPR Arquivo de Backup do Gerado quando o projeto é salvo pela segunda vez.
Projeto
.~PAS Arquivo de Backup da Unit Se um .PAS é alterado, este arquivo é gerado.
.~DFM Backup do Arquivo gráfico Se você abrir um .DFM no editor de código e fizer alguma alteração, este
do formulário arquivo é gerado quando você salva o arquivo.

1.3 Área de trabalho

Normalmente, quando o Delphi é inicializado, é criado um projeto (project1.dpr), uma
unit (unit1.pas) e um formulário (form1.dfm) (veja Figura 1).

Menus
Botões atalho Paleta de componentes

Object Form
Inspector

Unit

Figura 1 – Área de Trabalho



1.3.1 Menus
Os menus (File, Edit, Search, View, Project,...) possibilitam o acesso a diversos
recursos do ambiente Delphi.

1.3.2 Botões de atalho
Os botões de atalho permitem acionar diversos recursos do ambiente Delphi sem
precisar acionar o menu correspondente. Funções como “salvar” podem ser acessadas de
maneira rápida. Os botões de atalho podem ser personalizados de acordo com as necessidades
do desenvolvedor. Para configurar esta área, basta dar um clique com o botão direito sobre os
“botões de atalho” e acionar a opção “Customize”. Através desta opção, é possível esconder
barras de ferramentas, adicionar ou excluir botões de atalho.

1.3.3 Paleta de componentes
Nesta área são disponibilizados os diversos componentes (visuais e não visuais) que
podem ser utilizados durante a programação de um aplicativo. Os componentes estão
organizados por grupos através das paletas (Standard, Additional, Win32, ...). Para adicionar
um componente ao formulário (botões, caixa de edição, figuras, ...) dê um clique sobre o
componente desejado e, logo em seguida, clique sobre o formulário.

1.3.4 Object Inspector
Quando você seleciona um componente do formulário, o Object Inspector mostra suas
propriedades publicadas (nem todas as propriedades de um componente aparecem no Object
Inspector) e, quando apropriado, permite que sejam alteradas. A janela do Object Inspector é
divida em duas abas: Properties (Propriedades) e Events (Eventos).

1.3.4.1 Properties (aba)
Esta aba é dividida em duas colunas: a primeira coluna mostra o nome da propriedade
do componente selecionado e a segunda mostra os possíveis valores para a propriedade. Para
colunas cujo valor é do tipo booleano ou numeral, é disponibilizada uma lista (drop-down) onde
pode-se escolher o valor desejado com um clique. Se um sinal de mais (+) aparece próximo ao
nome da propriedade, pode-se clicar sobre este sinal para que sejam visualizados uma lista de
subvalores para a propriedade (é o caso da propriedade Font). Se um sinal de menos (-)
aparece próximo a propriedade, pode-se clicar sobre este sinal para que os subvalores sejam
escondidos. Quando mais de um componente é selecionado, o Object Inspector mostra todas
as propriedades que são comuns entre este componentes (exceto o name), se o valor desta
propriedade comum for alterado, o novo valor é aplicado a todos os componentes selecionados.
Algumas propriedades como Font têm um editor de propriedades especial. Isto pode ser
observado através de um botão com reticências (...) que aparece no momento em que o valor da



propriedade é selecionado. Para abrir este editor, basta dar um clique sobre este botão ou um
duplo clique sobre o campo onde consta o valor da propriedade. Os editores de propriedade
possibilitam maior facilidade na atribuição de valores de propriedades mais complexas.

Propriedades comuns entre componentes:
Diversos componentes possuem propriedades que são comuns entre si. Este recurso
possibilita que diversos componentes em um formulário, que possuam uma determinada
propriedade em comum, recebam o novo valor de uma única vez. Por exemplo: você pode ter
diversas labels (rótulos) e edits (caixa de edição) sobre um formulário e alterar o tamanho e
cor da fonte de todos estes componentes uma única vez selecionado todos estes componentes
e alterando os valores na propriedade Font. Abaixo, serão listadas algumas propriedades que
são comuns entre diversos componentes:

Posição e tamanho:
Quatro propriedades definem a posição e tamanho de um componente em um
formulários:

Height: define a altura do componente;
Width: define o comprimento do componente;
Top: a posição (vertical) do componente em relação ao formulário;
Left: a posição (horizontal) do componente em relação ao formulário.

Visualização:
Estas propriedades definem a aparência visual de um componente:
BorderStyle: define o estilo da borda de um componente;
Color: muda a cor de fundo de um componente;
BevelKind: define o estilo da linha da borda de um componente;
Font: muda a cor, tipo, tamanho, estilo da fonte do componente.

Navegação:
Diversas propriedades definem como o usuário poderá navegar entre os componentes
de um formulário:

Caption: define o texto que será visualizado pelo usuário. Nesta propriedade pode-
se definir a tecla de atalho (Arquivo) que sublinham uma determinada letra e,
através da combinação (ALT+<letra sublinhada>) o usuário acessa a função deste
componente. Este recurso pode ser acessado adicionando o caracter (&) antes da
letra de atalho na propriedade Caption (ex.: &Salvar resultaria em Salvar).



TabOrder: indica a ordem em que o componente receberá foco no formulário.
Inicialmente, a ordem é definida a medida que os componentes são adicionados ao
formulário. Esta ordem de foco pode ser alterada mudando o valor que aparece na
propriedade TabOrder sendo que 0 (zero) indica o primeiro componente que
receberá foco no formulário. A propriedade TabOrder só funcionará se a
propriedade TabStop estiver com valor True;
TabStop: define se um componente receberá foco (True) ou não (False) quando o
usuário acionar a tecla TAB.

Propriedades comuns entre componentes de edição de texto:
Text: define o texto que aparecerá no componente;
CharCase: força a entrada do texto em normal, maiúscula ou minúscula;
ReadOnly: define se o usuário poderá (false) ou não (true) alterar o texto
existente no componente;

MaxLength: limita o tamanho do texto;
PasswordChar: substitui o texto por um determinado caracter (normalmente
asterisco);

HideSelection: define se o texto será selecionado ou não quando o componente
receber foco.

1.3.4.2 Events (aba)
A aba Events (Eventos) do Object Inspector permite que formulários e componentes
sejam conectados a rotinas do programa. Os eventos permitem que uma rotina (procedimento
ou função) associada a um formulário ou componente seja executada. Deste modo, podemos,
por exemplo, associar ao clique de um botão a execução de uma rotina que fecha um
determinado formulário.

O usuário clica sobre um botão (ação);
Ao clicar sobre o botão é disparado um evento;
O evento clicar dispara uma rotina (procedimento ou função)

Ação evento rotina

clique ao clicar fecha formulário



Portanto, o evento é o meio pelo qual pode-se associar a execução de uma rotina
definida na aplicação a um determinado componente. A aba Events do Object Inspector mostra
todos os eventos do componente selecionado.

Eventos comuns entre componentes
Assim como as propriedades, existem diversos eventos que são comuns entre os
componentes. Muitos destes eventos, como o evento OnClick (ao clicar), estão presentes em
mais de um componente. Quando componentes possuem eventos em comum, pode-se associar
estes eventos a diversos componentes ao mesmo tempo e, consequentemente, a mesma rotina
associada ao evento comum poderá ser disparada de diversos componentes (reuso de código).
Para visualizar eventos comuns entre dois ou mais componentes, basta selecionar estes
componentes e observar a aba Events. A aba Events mostrará apenas os eventos comuns entre
os componentes selecionados. Abaixo são apresentados alguns dos eventos que são comuns
entre componentes:

OnClick: este evento ocorre quando clica-se sobre um determinado componente;
OnEnter: ocorre quando o componente recebe foco;
OnExit: ocorre quando o foco sai do componente;
OnKeyDown: ocorre quando é pressionada uma tecla enquanto o componente está
selecionado (foco);

OnKeyPress: ocorre quando é digitado um caracter.

Como associar uma rotina (procedimento ou função) a um determinado evento
A aba Events possui duas colunas: a primeira mostra uma lista dos eventos do
componente selecionado, e a segunda mostra o nome das rotinas associadas. Para habilitar um
evento e associar uma rotina a este evento, basta dar um duplo clique na segunda coluna (coluna
de valores que localiza-se logo após o nome do evento que deseja-se habilitar).
Automaticamente será criado um bloco de código onde a rotina a ser executada poderá ser
implementada.

1.3.5 Form (Formulários)
Formulários são a base de toda as aplicações desenvolvidas em Delphi. É uma janela
(tela) onde pode ser definida uma interface (janelas principais, caixa de diálogo, etc). Este
componente pode conter outros componentes, desempenhando o papel de contêiner de
componentes. Assim, é possível adicionar a um formulário diversos outros componentes como:
botões, caixas de edição, menus, etc.
Por tratar-se de uma janela, inclui funcionalidades comuns de uma janela como: menu de
controle, botões de maximizar e minimizar, barra de título e bordas redimensionáveis. Estas
propriedades, como outras, podem ser acessadas através do Object Inspector.

As rotinas pertencentes ao formulário e aos componentes adicionados ao mesmo, são
acondicionados na unit correspondente. Assim, para cada formulário é criado uma unit.



1.3.6 Unit
Nas units (módulos) são implementados os procedimentos e funções do formulários ou
dos componentes do formulário.

1.3.6.1 Estrutura de uma unit

Unit unit1 Define o nome da unit (nome do módulo). O nome da unit é definido no
momento em que aciona-se a opção Save no menu File;
Interface Esta seção inicia-se na palavra reservada Interface e continua até a
seção Implementation. Na seção Interface são declaradas constantes,
tipos, variáveis, procedimentos e funções. No caso de procedimentos ou
funções, são declarados apenas os cabeçalhos.
Uses Lista as units e bibliotecas utilizadas pela unit atual. Os nomes são
separados por vírgula e, ao final, ponto e vírgula (;). A cláusula uses
também pode aparecer na seção Implementation para evitar a
referência circular entre units.
Implementation A seção Implementation define os procedimentos e funções declarados
na seção Interface, ou seja, é onde são implementadas as rotinas a
serem executadas. Os procedimentos e funções podem ser chamados
em qualquer ordem. Na seção Implementation podem ser declaradas
constantes, tipos, variáveis, procedimentos, funções, porém, estas
declarações não poderão ser acessadas por outras units. Se for
necessário adicionar outra cláusula uses na seção Implementation, esta
deve aparecer imediatamente depois da palavra reservada
Implementation.

1.4 Programando no ambiente Delphi

1.4.1 Principais tipos de dados do ambiente Delphi

Tipos inteiros

Tipo Faixa Formato
Integer –2147483648..2147483647 32 bits
Shortint –128..127 8 bits
Smallint –32768..32767 16 bits
Longint –2147483648..2147483647 32 bits
Int64 –2^63..2^63–1 64 bits
Byte 0..255 8 bits
Word 0..65535 16 bits
Longword 0..4294967295 32 bits



Tipos reais

Tipo Faixa Formato Em bytes
Real48 2.9 x 10^–39 .. 1.7 x 10^38 11–12 6
Single 1.5 x 10^–45 .. 3.4 x 10^38 7–8 4
Double 5.0 x 10^–324 .. 1.7 x 10^308 15–16 8
Extended 3.6 x 10^–4951 .. 1.1 x 10^4932 19–20 10
Comp –2^63+1 .. 2^63 –1 19–20 8
Currency –922337203685477.5808.. 922337203685477.5807 19–20 8
Real 5.0 x 10^–324 .. 1.7 x 10^308 15–16 8

Tipos string

Tipo Tamanho máximo em caracteres Memória requerida
ShortString 255 2 - 256 bytes
String 255 256 bytes
AnsiString ~2^31 4 bytes - 2GB 8 bits
WideString ~2^30 4 bytes - 2GB

1.4.2 Conversão de tipos
O ambiente Delphi possui diversas funções que permitem a conversão de tipos de
dados. Estas conversões freqüentemente são necessárias no processo de desenvolvimento de
um aplicativo. Dentre as diversas funções de conversão de tipos, segue abaixo um quadro das
funções mais utilizadas.

Função Retorno Descrição
IntToStr(<tipo inteiro>) String Converte um inteiro em string
StrToInt(<tipo string>) Inteiro Converte um tipo string em um inteiro
StrToFloat(<tipo string>) Real Converte uma string em real
FloatToStr(<tipo real>) String Converte um tipo real em string
StrToDate(<tipo string>) Data Converte uma string em tipo data
DateToStr(<tipo data>) String Converte uma data em string
TimeToStr(<tipo horas>) String Converte horas em string
StrToTime(<tipo string>) Horas Converte string em horas

1.4.3 Declaração de variáveis

1.4.3.1 Variáveis globais
As variáveis globais, que podem ser utilizados por diversos procedimentos dentro de
uma unit podem ser declaradas logo abaixo da seção Implementation. Entretanto, as variáveis
declaradas nesta seção não serão visíveis por outras units.
Caso haja a necessidade de uma outra unit utilizar variáveis globais, é necessário que
esta variável seja declarada na seção Public.



unit Unit1;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;
type
TForm1 = class(TForm)
private
{ Private declarations }
public
{ Public declarations }
z : string; //variável global pública, pode ser acessada pela própria unit e por outras units
end;
var
Form1: TForm1;
implementation
{$R *.DFM}

var s : string[20]; //variável global, só pode ser acessada pela própria unit.

end.

1.4.3.2 Variáveis locais
As variáveis locais devem ser declaradas dentro do procedimento ou função em que são
utilizadas, entre o cabeçalho do procedimento/função e a palavra reservada begin, com o nome
da variável antecedida da palavra reservada var e precedida do tipo de dado.

Procedimento Teste;
var VariavelLocal : string;
begin
bloco de código
end;

1.4.4 Declaração de procedimentos e funções
Para a declaração de um procedimento ou função deve ser especificado seu nome, nome
e tipo de parâmetro (opcional) e, no caso de funções, o tipo do retorno.

Procedure MinhaProcedure (nome, fone: string; idade: integer; salario: double);
Function MinhaFuncao(salario, desconto: double) : double;

Esta parte da declaração é chamada de protótipo ou escopo ou ainda, cabeçalho.

Function MinhaFuncao(salario, desconto: double) : double; Protótipo ou escopo ou cabeçalho
Begin
MinhaFuncao := salario – desconto; bloco de código ou corpo da função
end;

No bloco de código ou corpo da função/procedimento é definida a rotina que será
executada quando a função/procedimento for chamada.
Os procedimentos ou funções podem ser declarados logo após a palavra reservada
Implementation (cabeçalho e corpo). Neste caso, estas declarações somente serão visíveis
para a própria Unit.



Procedimentos e funções também podem ser declarados na seção Interface (somente
cabeçalho). Se o procedimento/função for declarado na parte Public, poderá ser
disponibilizado para outras units. Se o procedimento/função for declarado na parte Private,
este somente estará disponível para a própria unit. O cabeçalho e corpo do
procedimento/função devem ser declarados na seção Implementation.

...
Private
Procedure Teste1;
Public
Function Teste2 : boolean;
...
Implementation
...
procedure Tform1. Teste1;
<declaração de variáveis locais, caso necessário>
begin
//bloco de código
end;

Function Teste2 : boolean;
<declaração de variáveis locais, caso necessário>
begin
//Bloco de código
end;

Exercícios sugeridos:
Funções e procedimentos:
Elabore uma função que receberá dois valores inteiros (parâmetros de entrada) e
retorne a multiplicação destes valores. Utilize dois Edits para entrada de valores e uma
label para mostrar o resultado. A função deve ser chamada através do evento OnClick
de um botão.
Elabore um procedimento que verifique se as dimensões do formulários são menores
que (utilize um botão para chamar o procedimento):
♦ Height (altura): 500 e,
♦ Widht: (largura): 700.
Se as dimensões (as duas) forem menores que as apontadas acima, o procedimento deve
redimensionar o formulário para:
♦ Height (altura): 600 e,
♦ Widht: (largura): 800.
Eventos:
Utilize o evento OnCreate para verificar se a propriedade WindowState é igual a
wsNormal, caso afirmativo, a propriedade WindowState deve ser igual a wsMaximized.
Propriedades:
Utilize o evento OnClick de um botão para mudar o Caption de um formulário.
Sub propriedades:
Utilize o evento OnClick de um botão para mudar a cor de um formulário.



1.4.5 Tratamento de erros (exceções)

1.4.5.1 Bloco Try ... Except
Qualquer aplicativo está sujeito a ocorrência de erros. A origem dos erros pode ser
das mais variáveis: erros na codificação, entrada de dados, saída de dados, etc. O tratamento
de erros ou possíveis erros pode ser feito através das palavras chaves “Try ... Except”.
Quando um bloco protegido é declarado através de Try...Except, pode-se definir
possíveis respostas para os erros que ocorrerão neste bloco.

Exemplo:
Try Inicia a proteção do código
StrToInt(Edit1.Text); //linha 1
StrToInt(Edit2.Text);//linha 2 Bloco protegido
StrToInt(Edit3.Text);//linha 3
Except Bloco de tratamento: se ocorrer algum erro no
ShowMessage(‘Digite um valor numérico’); código protegido, a mensagem é executada
End; //end do Try Final do bloco protegido

Quando ocorre um erro (exceção) em qualquer linha do bloco de código protegido, o
controle da execução passa imediatamente para o tratamento, independente de haver ou não
outras linhas a serem executadas no bloco protegido. Se ocorrer um erro na linha 1 (exemplo
acima), as linhas 2 e 3 não serão executadas sendo passado o controle para o bloco de
tratamento.
Entretanto, se não ocorrerem erros no bloco protegido, o bloco de tratamento não será
executado, passando o controle ou execução para o bloco de código seguinte (após o end do
try), se houver.

1.4.5.2 Bloco Try...Finally
Existem situações onde uma rotina deve ser executada mesmo que ocorra um erro.
Utilizando o exemplo ilustrado na seção anterior, podemos definir o seguinte bloco de código:

Try Inicia a proteção do código
StrToInt(Edit1.Text); //linha 1
StrToInt(Edit2.Text);//linha 2 Bloco protegido
StrToInt(Edit3.Text);//linha 3
Finally
Begin
Edit1.Clear; Bloco de tratamento: ocorrendo ou não erros no
Edit2.Clear; bloco protegido, estas linhas serão executadas.
Edit3.Clear;
End; //end Finally
End; //end do Try Final do bloco protegido



No código acima, se ocorrer um erro na linha 1, as linhas 2 e 3 não são executadas e
todos os procedimentos existentes no bloco de tratamento são processados.
Se não ocorrer nenhum erro nas linhas 1, 2 e 3, o bloco de tratamento também é
executado.
Portanto, utilize esta estrutura para executar códigos que sempre deverão ser
processados, independente da ocorrência de erros ou não.

1.4.6 Depurando a aplicação (debugger)
A ocorrência de erros em uma aplicação exige que o desenvolvedor utilize técnicas que
permitam a localização destes erros (depuração). O ambiente Delphi oferece diversos recursos
que possibilitam ao desenvolvedor a localização de erros. Estas ferramentas, quando utilizadas
adequadamente, podem reduzir o tempo de depuração agilizando a procura e solução do erro.

1.4.6.1 Breakpoints
Breakpoints permitem marcar um determinado ponto do programa com a finalidade de
interromper a execução do aplicativo neste ponto. Quando a aplicação for executada, na linha
do código onde está localizado o breakpoint ocorre uma interrupção de execução e o código
fonte onde o breakpoint está localizado é visualizado. Através deste recurso é possível
examinar valores de variáveis, fluxo de controle do algoritmo (F8), loops, etc.
Através da tecla F8 pode-se executar linha-a-linha o código fonte observando o
comportamento do programa.
Para um breakpoint ser válido, é necessário que seja adicionado em uma linha de código
executável. Linhas de código não executáveis são, por exemplo, comentários, linhas em branco,
declarações (procedimento, funções, variáveis), etc. As linhas de códigos que não forem válidas
são visualizadas com um “x” no ícone do breakpoint na margem esquerda do código fonte,
durante a depuração. As linhas válidas são visualizadas com o símbolo ( ) (Figura 2).

Figura 2 – Utilizando breakpoints
Para adicionar um breakpoint no código fonte, selecione a linha onde será posicionado o
breakpoint e então utilize um dos seguintes meios:
Clique na margem esquerda da linha;
Clique com o botão direito do mouse em qualquer parte da linha e escolha
Debug|Toggle Breakpoint no menu suspenso;
Posicione o cursor em qualquer parte da linha onde será adicionado o breakpoint e
então pressione a tecla F5;
Escolha a opção no menu Run|Add Breakpoint|Source Breakpoint e defina a linha
onde será adicionado o breakpoint;



Na janela Breakpoint List (View|Debug Windows|BreakPoints), clique com o botão
direito do mouse e escolha no menu suspenso a opção Add|Source Breakpoint.

1.4.6.2 Watches
A janela Watch List (View|Debug Windows|Wathces ou Ctrl+Alt+W) mostra os valores
correntes de expressões (variáveis, propriedades de componentes, resultados de funções, etc)
baseado no ponto de execução do programa. Veja a Figura 3.

Figura 3 – Janela Watch List
Para adicionar uma expressão na janela Watch, clique com o botão direito sobre a
janela e selecione no menu suspenso a opção Add Watch... (Ctrl + A.)
No menu suspenso da janela Watch são disponibilizadas diversas funcionalidades que
permitem manipular a utilização deste recurso de depuração, os mais importantes são:
Edit Watch: abre a caixa de diálogo Watch Properties que permite modificar as
propriedades da expressão selecionada;
Add Watch: abre a caixa de diálogo Watch Properties que permite criar um watch;
Enable Watch: habilita uma expressão watch desativada;
Disable Watch: desabilita uma expressão watch ativa;
Delete Watch: remove uma expressão;
Enable All Watches: habilita todos os watches;
Disable All Watches: desabilita todos os watches;
Delete All Watches: remove todos os watches;
Stay On Top: mantém a janela Watches List sempre visível quando outras janelas
recebem foco;

1.5 Trabalhando com componentes
Por trata-se de um ambiente visual (padrão Windows®), a interação entre o aplicativo e
o usuário é definida através de componentes. Basicamente, existem dois tipos de componentes:
componentes visuais e componentes não visuais. Os componentes visuais são aqueles que são
visíveis quando o aplicativo é executado (tempo de execução – runtime) e os não visuais são
aqueles que aparecem em tempo de projeto (no momento em que se está programando - design)
como uma pequena figura, e não são visíveis quando o aplicativo é executado.

1.5.1 Paleta de componentes (Component palette)
Os componentes são disponibilizados na paleta de componentes (Figura 4) e agrupados
por categorias. Para adicionar um componente ao formulário basta dar um clique sobre o
componente e adicioná-lo ao formulário (dando um clique na posição onde o componente deverá
ser adicionado).



Figura 4 – Paleta de componentes

1.5.2 Propriedades
A propriedade (veja seção 1.3.4.1 Properties (aba)) é um atributo (característica) de
um componente (objeto) com valores pré definidos (p.e.: Font) ou valores que podem ser
definidos pelo programador (p.e.: Caption). As propriedades de um componente podem ser
acessadas ou alteradas de duas maneiras:
Através do Object Inspector: as propriedades que aparecem no Object Inspector
são propriedades publicadas (published). O acesso é disponibilizado em duas colunas
na aba Properties: uma coluna onde são definidos os nomes das propriedades e a
outra com os respectivos valores. Para visualizar as propriedades de um
componente no Object Inspector, basta selecionar o componente no formulário.
As propriedades também podem ser acessadas ou alteradas diretamente no código
fonte. Para isso, deve-se digitar o nome do componente (definido na propriedade
name) seguido de um ponto (.) e o nome da propriedade

Form1.Caption := ‘Menu Principal’ Alterando o valor da propriedade
ShowMessage(Form1.Caption); Consultando o valor de uma propriedade

☺Dica: No Object Inspector somente são visíveis as propriedades publicadas
(published), portanto, podem existir outras propriedades que não estão visíveis no Object
Inspector. Estas propriedades não publicadas podem ser acessadas no código.

1.5.3 Eventos (Events)
Os eventos (veja seção 1.3.4.2 Events (aba)) permitem a um determinado componente
disparar um determinado procedimento/função. Por exemplo: botões possuem o evento OnClick
(ao clicar) que pode executar uma determinada rotina.

1.5.4 Métodos
Método é um procedimento ou função associado a uma classe. Componentes possuem
métodos que executam um código que atende a uma determinada finalidade. Por exemplo: o
componente Formulário (Form) possui um método chamado Close. Este método, quando
acionado, fecha o formulário (Form1.Close). Para acessar os métodos de um componente basta
definir o nome do componente seguindo de um ponto (.) mais o nome do método.



☺Dica: Para visualizar a lista de propriedades do componente no código, basta digitar o
nome do componente (definido na propriedade name) seguindo de um ponto (.) e após alguns
segundos será possível ver uma lista das propriedades, métodos e eventos de um componente.



2 BANCO DE DADOS INTERBASE®

2.1 Introdução
A importância da informação na maioria das organizações é indiscutível. Armazenar e
prover acesso a estas informações tornou-se uma atividade essencial. Informações podem ser
acondicionadas e organizadas de diversas maneiras: fichas, arquivos, documentos, fichários,
etc.
Com o advento da informatização, aplicações foram desenvolvidas para desempenhar
este papel. Estas aplicações, os bancos de dados, tornaram-se elementos de fundamental
importância para as organizações pelos inúmeros benefícios proporcionados. Os banco de dados
permitem que estas informações sejam relacionadas, armazenadas e recuperadas com rapidez
e segurança. Além disso, os bancos de dados possibilitam que informações sejam protegidas de
acesso não autorizado; permitem que uma mesma informação seja compartilhada por múltiplos
usuários; padroniza a entrada de dados, restringem e consistem o armazenamento dos dados,
evitam a redundância de informações, etc.

2.2 Banco de dados Interbase
O banco de dados Interbase, como a maioria dos bancos de dados, permite que sejam
criadas estruturas de dados onde serão armazenadas e gerenciadas as informações de uma
organização. Assim, como uma linguagem ou ambiente de programação, a criação de estruturas
de dados é definida através de uma linguagem chamada SQL (Structured Query Language –
Linguagem de Consulta Estruturada). A linguagem SQL foi padronizada e diversos bancos de
dados utilizam este padrão. Porém, devido a diversas necessidades, a linguagem SQL foi
complementada e, no caso do Interbase, é chamada de ISQL.
A linguagem SQL pode ser utilizada de duas maneiras: como linguagem de manipulação
de dados (DML-Data Manipulation Language) e como linguagem de definição de estruturas de
dados (DDL-Data Definition Language).

2.3 SQL DML (Data Manipulation Language)
As informações de um banco de dados podem ser manipuladas através da SQL DML
(DML Data Manipulation Language ou Linguagem de Manipulação de Dados). Através da DML é
possível aplicar as seguintes operações sobre as informações armazenadas em um banco de
dados:
Consultas;
Inserção de novas informações;
Atualização e;
Exclusão de informações já armazenadas;

A estrutura da manipulação de dados consiste basicamente em 3 cláusulas: select, from
e where.



2.3.1 Cláusula Select (“selecione”)
É utilizada para definir quais campos de uma tabela serão listados como resultado de
uma consulta. Por exemplo: suponhamos que exista uma tabela com os seguintes campos:

Codigo_Cliente Nome Telefone Cidade Cpf
1 José 999999-99 Cornélio Procópio 999.999.999-99
2 Rafaela 888888-88 Cornélio Procópio 888.888.888.-88
3 Saulo 777777-77 Londrina 777.777.777-77
4 José 666666-66 Santa Mariana 666.666.666-66

Quadro 1 – Estrutura de uma tabela de clientes
A cláusula Select permite que o resultado de uma consulta possa ser visualizado de
diversas maneiras:
a) Mostrar todos os campos no resultado da consulta:
Select Codigo_Cliente, Nome, Telefone, Cidade, Cpf
b) Mostrar apenas os nomes dos clientes:
Select Nome
c) Mostrar apenas os nomes e telefones de todos os cliente:
Select nome, telefone

Como pode ser observado, ainda seria possível outras inúmeras combinações. Então, a
definição dos campos resultantes em uma consulta é especificado utilizando-se a cláusula
Select mais o nome do campo. Quando mais de um campo formar o resultado de uma consulta,
estes devem ser separados por vírgula observando que após o último nome do campo listado na
cláusula Select não deve ser empregada a vírgula

☺ Dica: Em situações onde todos os campos serão selecionados (como no item “a” do
exemplo anterior), pode ser empregado o asterisco (*) para substituir todos os nomes de
campos
Ex. Select * From Cliente

2.3.2 Cláusula From (“origem”)
A cláusula From define a origem e relações existentes nos elementos (campos)
apontados na cláusula Select. Deste modo, é necessário determinar em uma consulta pelo
menos as duas cláusulas (Select e From) para que seja proporcionado um resultado para uma
consulta.
Utilizando o Quadro 1 definido na seção anterior, para que a consulta produza
resultados, é necessários apontar quais elementos (campos) do conjunto cliente farão parte do
resultado e, qual a origem (conjunto, tabela) destes elementos. Por exemplo:
a) Mostrar todos os campos no resultado da consulta:
Select Codigo_Cliente, Nome, Telefone, Rg, Cpf
From Cliente
b) Mostrar apenas os nomes dos clientes:
Select Nome
From Cliente



c) Mostrar apenas os nomes e telefones de todos os clientes:
Select nome, telefone
From Cliente
d) ...

Então, através destas duas cláusulas já é possível produzir resultados em uma consulta.

2.3.3 Cláusula Where (“onde”)
A cláusula Where define as “condições” (predicado) que poderão definir (restringir) o
resultado de uma consulta. Nos exemplos utilizados nas seções anteriores, os resultados das
consultas sempre retornariam todos os elementos de um conjunto, ou seja, todos os clientes
cadastrados na tabela ou conjunto Cliente. Entretanto, nem sempre é necessário que as
consultas retornem como resultado todos os elementos de um conjunto. Por exemplo, poderia
ocorrer a situação onde seria necessário como resultado somente as informações de um
determinado cliente.
Pode-se definir na cláusula Where a condição que irá restringir o resultado desta
consulta. Para que isso seja possível, é necessário definir uma condição, por exemplo,
selecionar todos os campos de clientes onde o código do cliente seja igual a 1. Esta sentença
em SQL poderia ser definida da seguinte maneira:

Select *
From Cliente
Where Codigo_Cliente = 1

Resultado

É importante tomar cuidado no emprego da condição. Determinadas condições podem
não restringir o resultado da consulta. Por exemplo, se a sentença SQL definida anteriormente
fosse definida da seguinte maneira:

Select *
From Cliente
Where nome = “José”

Resultado

Se o objetivo da consulta era somente a visualização das informações do primeiro
cliente (código 1), este não foi alcançado com precisão.
Existem situações onde este tipo de consulta é necessário. Por exemplo, poderia
ocorrer a necessidade de se obter todos os cliente residentes na cidade de Cornélio Procópio,
neste caso o elemento que poderia atender a esta condição seria:



Select *
From Cliente
Where Cidade = “Cornélio Procópio”

Resultado

2.3.4 Cláusula Order By
Normalmente, o resultado de uma consulta é retornado em “ordem natural”, ou seja,
ordenado pela chave primária ou pelo índice ativo. A cláusula Order By organiza o resultado de
uma consulta de acordo com a coluna definida na cláusula Order By. A coluna utilizada nesta
cláusula deve aparecer na cláusula Select. Naturalmente, os dados são organizados na ordem
ascendente (“asc”), de “A” a “Z” ou “1” a “9”. Para organizar na ordem descendente pode-se
utilizar a palavra chave “desc” após o nome da coluna especificada na cláusula Order By.

Select Codigo_Cliente, Nome, Cpf
From Cliente
Order by cpf asc

Resultado
3 Saulo 777777-77 Londrina 777.777.777-77

2.3.5 Operadores
A necessidade de definição de restrições no resultado de uma consulta exige que seja
definida uma condição. Os operadores auxiliam na definição da condição que irá restringir o
resultado da pesquisa.

2.3.5.1 Operadores de comparação
Utilizados para comparar dados de uma coluna com os valores definidos na condição.

Operador Significado
< menor
> maior
<= menor igual
>= maior igual
= igual
<> diferente
Between Entre
Starting With Iniciado com



Operador Starting With
O operador de comparação Starting With retorna os valores iniciados por um
determinado caracter ou uma seqüência de caracteres.

Select Nome
From Cliente
Where Nome Starting With “J”

Resultado

Aviso: o Interbase diferencia caracteres maiúsculos de minúsculos e vice-versa.
Desta forma, “Select Nome From Cliente Where Nome Start With “j” ” não retornaria nenhum
resultado, pelo fato de não existir nenhum nome iniciado com a letra “j” (em minúsculo).

2.3.5.2 Operadores lógicos
Utilizados para combinar ou negar uma condição.

Operador Significado
Not não
And e
Or ou

Existem outros operadores que podem ser utilizados no Interbase. Entretanto, o
objetivo deste curso é apenas proporcionar uma visão geral sobre a aplicação da SQL.

2.4 SQL DDL (Data Definition Language)
A DDL é utilizada para definir, alterar e excluir um banco de dados e/ou objetos de um
determinado banco de dados.
Os objetos definidos através da DDL (tabelas, procedures, triggers, etc.) são
conhecidos como metadados (dados sobre dados).
O Interbase é um banco de dados relacional. Um banco de dados relacional é uma
coleção de tabelas bidimensionais compostas de linhas (também chamados registros) e colunas
(chamados também de campos).
O banco de dados Interbase é armazenado em arquivos com a extensão .gdb. Para criar
um banco de dados é necessário o nome do usuário e senha. Quando o banco é instalado, o
usuário e a senha de acesso padrão são, respectivamente, sysdba e masterkey. Além do nome
do usuário e senha, deve ser definido o nome para o banco.



2.4.1 Criando um banco de dados Interbase
Para criar um banco de dados será utilizado o aplicativo IBConsole que acompanha o
banco. Antes, porém, vamos criar alguns diretórios. Crie uma estrutura de diretórios como
sugerido na Figura 5.

Figura 5 – Estrutura de diretórios utilizada para o desenvolvimento do aplicativo

Agora com a estrutura de diretórios montada, vamos criar o banco.

1. Primeiro devemos verificar se o banco já foi iniciado (start) (botão
Iniciar|Programas|Interbase|Interbase Server Manager);
2. Agora, inicialize o aplicativo IBConsole (botão Iniciar|Programas|Interbase|
IBConsole) e clique 2 vezes em Local Server, se for pedido usuário e senha use
usuário SYSDBA, e digite a senha “masterkey” (em minúsculas);
3. No Local Server, agora conectado, será exibida uma árvore (Databases, Backup,
Certificates, Server Log e Users), clique com o botão direito em Databases e
selecione a opção Create Database...;
4. Na caixa de edição “Filename” digite o caminho (path) e nome do banco:
C:AplicativoBancoBanco.gdb. Certifique-se de que o caminho (diretório) e nome
do banco (incluindo a extensão .GDB) estão como descritos aqui (veja a Figura 6).
Lembre-se que o caminho indicado já deve existir;
5. Na caixa de edição “Alias” digite: Banco. Esse é o nome pelo qual o banco criado
será referenciado;
6. Clique no botão “Ok”.
Se tudo correu bem, o IBConsole vai exibir “Banco” em Databases, e mostrar a árvore
de informações do banco (Domains, Tables, Indexes, etc.).

Figura 6 – Janela Create Database



A partir deste momento você está conectado ao banco que acabou de criar.

Aviso: toda vez que você precisar trabalhar com qualquer banco de dados criado no
Interbase, certifique-se de que o banco está inicializado (Started). Normalmente, quando o
banco não está ativo (not started) aparece a mensagem “Statement failed, SQLCODE = -901”.

No Interbase, todo banco de dados deve ser registrado (opção do menu suspenso
aberto ao clicar com o botão direito em Databases ou em menu Database|Register). No
momento da criação, por padrão, o banco já é automaticamente registrado. Se o objetivo for
abrir um banco (arquivo GDB) já existente em um Interbase Server onde esse banco ainda não
foi registrado, não é necessário criar o banco novamente, basta registrar o arquivo no
servidor. Para isso, faça o seguinte:
1. No Local Server já conectado, clique com o botão direito em Databases e selecione a
opção Register...;
2. Na caixa de edição “File:” digite o caminho (path) e nome do banco, ou escolha
diretamente através do botão “...”;
3. Na caixa de edição “Alias” digite o nome do banco. Esse é o nome pelo qual o banco
criado será referenciado, como padrão é colocado o nome do arquivo, mude para o nome
que for necessário (veja a Figura 7);
4. Se for necessário, informe login (User Name) e senha (Password).
5. Clique no botão “Ok”.

Figura 7 – Janela Register Database



2.4.2 Interbase Interactive SQL
A janela Interbase Interactive SQL (Menu Tools|Interactive SQL) permite que suas
sentenças SQL DML ou DDL sejam executadas. Além disso, existem outros inúmeros recursos
disponibilizados através de seus menus.

2.4.3 Criando tabelas no Interbase
A proposta desta etapa é construir um banco de dados simples com 4 tabelas (Figura 8)
que conterão informações relacionadas a funcionários de uma determinada organização.
Não é objetivo deste curso discutir regras de normalização ou qualquer conceito
relacionado a construção de modelos de estruturas de dados.
Entretanto, é de fundamental importância o planejamento do desenvolvimento de
software. A aplicação de métodos, técnicas e ferramentas constituem-se elementos
indispensáveis que agregam qualidade ao desenvolvimento de aplicações.

Figura 8 – Modelagem de um sistema para cadastrar funcionários
Com base no modelo apresentado na Figura 8, vamos construir as tabelas de dados
utilizando SQL DDL para definir as estruturas de dados do sistema (use o Interactive SQL).
A definição de uma tabela em DDL:

Definição da tabela Departamento:

CREATE TABLE tb_Departamento (
Dpt_Codigo SMALLINT NOT NULL,
Dpt_Descricao VARCHAR(40) NOT NULL,
PRIMARY KEY (Dpt_Codigo)
);



Definição da tabela Estado (Unidades da Federação):

CREATE TABLE tb_Estado (
Est_Sigla CHAR(2) NOT NULL,
Est_Descricao VARCHAR(40) NOT NULL,
PRIMARY KEY (Est_Sigla)
);

Definição da tabela funcionário:

CREATE TABLE tb_Funcionario (
Fun_codigo INTEGER NOT NULL,
Est_Sigla CHAR(2) NOT NULL,
Dpt_Codigo SMALLINT NOT NULL,
Fun_Nome VARCHAR(40) NOT NULL,
Fun_DataNascimento DATE NOT NULL,
Fun_dddResidencial CHAR(2) NOT NULL,
Fun_FoneResidencial VARCHAR(9) NOT NULL,
Fun_Rua VARCHAR(40) NOT NULL,
Fun_Complemento VARCHAR(20),
Fun_Bairro VARCHAR(40) NOT NULL,
Fun_Cidade VARCHAR(40) NOT NULL,
Fun_Cep CHAR(8),
Fun_Salario DOUBLE PRECISION NOT NULL,
PRIMARY KEY (Fun_codigo),
FOREIGN KEY (Dpt_Codigo)
REFERENCES tb_Departamento,
FOREIGN KEY (Est_Sigla)
REFERENCES tb_Estado
);

Definição da tabela Dependentes:

CREATE TABLE tb_Dependentes (
Fun_codigo INTEGER NOT NULL,
Dep_Codigo SMALLINT NOT NULL,
Dep_Nome VARCHAR(40) NOT NULL,
Dep_DataNascimento DATE NOT NULL,
Dep_Parentesco VARCHAR(20) NOT NULL,
PRIMARY KEY (Fun_codigo, Dep_Codigo),
FOREIGN KEY (Fun_codigo)
REFERENCES tb_Funcionario
);



Palavra chave Significado
Create table Sentença de criação de tabelas
Not null Define que o campo é de preenchimento obrigatório
Primary key Define a chave primária de uma tabela
Foreign key Define a chave estrangeira de uma tabela
References Define o nome da tabela origem da chave estrangeira
Integer Tipo de dado inteiro
Smallint Tipo de dado inteiro curto
Varchar Tipo de dado string de tamanho dinâmico
Char Tipo de dado string de tamanho fixo
Date Tipo de dado que armazena data e hora
Double precision Tipo de dado real, utilizado para armazenar valores
monetários
Drop Utilizado para excluir metadados. Ex.: drop table <nome da
tabela>
Alter Utilizado para atualizar metadados. Ex.: alter table
tb_Departamento drop Dpt_Descricao, add Dpt_Descricao
varchar(50) not null



3 DESENVOLVENDO UM APLICATIVO COM BANCO DE DADOS (INTERBASE)

A proposta deste capítulo é desenvolver uma aplicação com acesso ao banco de dados
Interbase. A aplicação terá como base a modelagem definida no Capítulo 2 (Figura 8). Serão
construídos cadastros, relatórios, consultas, instalador e help para a aplicação.

3.1 Iniciando uma nova Aplicação
O primeiro passo será iniciar um novo projeto e salvá-lo:

Escolha no menu principal a opção File|New|Application;
No Object Inspector, modifique as seguintes propriedades do formulário (Form1):
Caption: Menu Principal;
Name: FPrincipal;
WindowState: wsMaximized;
Escolha no Menu Principal, a opção File|Save All;
Na janela Save Unit1 As:
Encontre o diretório C:AplicativoFontes (onde será salvo o código fonte);
Salve a unit1 com o nome UF_Principal;
Clique no botão Salvar;
Na janela Save Project1 As:
Salve o projeto com o nome Funcionarios;

O que foi feito?

Propriedades manipuladas:
- Name: define o nome do componente formulário. Não pode conter acento, espaço, ç, etc. ou
seja, deve ser definido com caracteres “puros”. Outro detalhe importante é que não podem
existir dois componentes com o mesmo nome;
- Caption: define o nome que aparecerá na barra de título do formulário. Esta propriedade
permite a utilização de acentos, espaços, etc;
- WindowState: esta propriedade possui 3 valores pré-definidos:
- WsMaximized: o formulário é maximizado quando chamado;
- WsMinimized: o formulário é minimizado quando chamado;
- WsNormal: a janela será visualizada conforme chamado.

Quando a opção Save All foi acionada foi definido que os fontes deveriam ser salvos no
diretório especificado. Na primeira janela, definiu-se o nome da unit (não do formulário).
Observe que o nome sugerido para salvar a unit foi o nome do formulário (definido na
propriedade “name”) antecedido da letra “U”, procure utilizar convenções, regras para nomear
arquivos, componentes, etc.



Formulário Unit
FPrincipal UF_Principal
Desta maneira, fica mais fácil relacionar o componente formulário aos arquivos que
serão gerados (UF_Principal.pas e UF_Principal.dfm).
Na segunda janela (Save Project1 As), foi definido o nome do projeto. Como discutido
no capítulo anterior (veja a seção 1.2.4), as units e forms são agrupadas por projeto. É
importante observar que a janela “Save Project1 As” aparecerá uma única vez.

3.2 Configurando opções do projeto
Todo projeto desenvolvido no ambiente Delphi, basicamente, irá gerar três grupos de
arquivos: arquivos fontes (.pas, .dfm, .dpr, .res, .dof, .cfg etc.); arquivos compilados (.dcu, .exe)
e arquivos de backup (.~pa; .~df, enfim, todas as extensões antecedidas do caracter “~”). É
interessante separar os arquivos fontes e arquivos de backup dos arquivos compilados para
permitir uma melhor organização do projeto. Esta separação pode ser feita através de
diretórios. Como sugerido na seção 2.4.1, os arquivos compilados (.dcu e .exe) podem ser salvos
automaticamente no diretório Exe. Para que isto ocorra é necessário definir esta opção no
ambiente Delphi.

Selecione a opção Project|Options...;
Selecione aba Directories/Conditionals;
Na caixa de edição Output Directory digite o caminho do diretório Exe
(C:AplicativoExe);
Na caixa de edição Unit Output Directory digite também o caminho do diretório
Exe (C:AplicativoExe).
Clique no Botão OK.

Output Directory: define onde será acondicionado o arquivo .exe quando o projeto for
compilado (F9).
Unit Output Directory: define onde serão acondicionados os arquivos .dcu quando o
projeto for compilado (F9).

Aviso: antes de definir os caminhos na Opções de Projeto, crie os diretórios
necessários. Se os diretórios já foram criados, certifique-se de que os caminhos estão
digitados corretamente, caso contrário, o projeto não será compilado e uma mensagem de erro
será gerada. Se nestas opções, por um erro de digitação por exemplo, fossem definidos os
caminhos como sendo (C:AplicativoExes), poderia ocorrer uma das mensagens de erro
abaixo:
• [Fatal Error] UF_Principal.pas(40): Could not create output file 'C:AplicativoExesUF_Principal.dcu', ou
• [Fatal Error] Could not create output file 'C:AplicativoExesFuncionario.exe'

3.3 Definindo o menu do formulário Principal

O próximo passo é definir um menu para o formulário principal:



Adicione um componente MainMenu (Paleta Standard);
Modifique a propriedade do MainMenu (clique sobre o componente):
Name: mmPrincipal.

Dê um duplo clique sobre o componente MainMenu para acionar o Editor de Menu;
Modifique as seguintes propriedades:
Caption: &Cadastros.
Name: imCadastros;

Clique sobre o item de menu “Cadastros”;
No item em branco que aparece logo abaixo, modifique as seguintes propriedades:
Caption: Funcionários;
Name: imFuncionarios;
ShortCut: escolha Ctrl+F.

Clique sobre o item de menu em branco logo abaixo de Funcionários:
Caption: Estados (UF);
Name: imEstados;
ShortCut: escolha Ctrl+E.

Clique sobre o item de menu em branco logo abaixo de Estados:
Caption: Departamentos;
Name: imDepartamentos;
ShortCut: escolha Ctrl+D.

Clique sobre o item de menu em branco logo abaixo de Departamentos;
Modifique a propriedade:
Caption: - (hífen).

Clique sobre o item de menu em branco logo abaixo da linha divisória do menu Cadastros;
Modifique as propriedades:
Caption: Sair;
Name: imSair;
ShortCut: Ctrl+S.

Clique sobre o item de menu em branco do lado direito do item Cadastros;
Caption: &Relatórios;
Name: imRelatorios.



Clique sobre o item de menu Relatórios;
Clique sobre o item de menu em branco logo abaixo do item Relatórios;
Name: imRelFuncionarios.

Clique sobre o item de menu em branco logo abaixo do item Funcionários;
Caption: Estados;
Name: imRelEstados.

Clique sobre o item de menu em branco do lado direito do item Relatórios;
Caption: &Ajuda;
Name: imAjuda.

Clique sobre o item de menu Ajuda;
Clique sobre o item de menu em branco logo abaixo do item Ajuda;
Caption: Ajuda do Sistema;
Name: imAjudaSistema.

Clique sobre o item de menu em branco logo abaixo do item Ajuda do Sistema;
Caption: - (hífen).

Clique sobre o item de menu em branco logo abaixo da linha divisória;
Caption: Sobre o Sistema;
Name: imSobre.

O que foi feito?

O componente MainMenu permite a criação de menus. Os itens na parte superior são os
grupos que podem conter subgrupos de menus.

Propriedades manipuladas:
Name: define o nome do componente.
Caption: Define o nome que será visível ao usuário. Pode conter acentos, espaços, ç, etc. O
caracter “&”, quando adicionado na frente de uma letra, cria um atalho que pode ser
acionado através da combinação de teclas ALT+ “letra antecedida pelo &”;
ShortCut: a propriedade ShortCut lista uma série de combinações de teclas que podem ser
atribuídas ao item de menu, chamadas de teclas de aceleração.
Alguns itens de menu foram criados com o caracter hífen (“-”) na propriedade Caption.
Quando somente este caracter é adicionado, é criado uma linha divisória entre os itens de



menus. Este recurso é particularmente importante principalmente quando é necessário
fazer divisões internas no menu para agrupar funcionalidades relacionadas.

3.4 Conectando o Aplicativo (Delphi) ao Interbase
A próxima etapa é conectar o aplicativo que está sendo desenvolvido ao banco de dados
Banco.gdb criado no Interbase.
No menu File escolha a opção New | Data Module;
Name: DMFuncionarios.
No menu File, selecione a opção Save All;
Aponte para o diretório C:AplicativoFontes;
Nome do arquivo: UDM_Funcionarios;
Clique no botão Salvar.

3.4.1 O que são Data Modules?
A utilização de Data Modules permite a centralização de componentes não visuais,
normalmente componentes relacionados a banco de dados, porém, outros componentes não
visuais podem ser adicionados ao Data Module.

Figura 9 – Data Module
O Data Module, então, funciona como um contêiner para componentes não visuais.
Neste caso, será utilizado para acondicionar os componentes que serão necessários para
conectar o aplicativo que está sendo desenvolvido ao banco de dados criado no Interbase.
Os componentes não visuais podem ser adicionados diretamente no interior do Data
Module. Com o auxílio do Object Inspector, as propriedades dos componentes adicionados ao
Data Module podem ser alteradas.

3.5 Conectando a Banco.gdb

Primeiro precisamos conectar o aplicativo que está sendo desenvolvido ao arquivo .GDB
que foi criado no Interbase (Banco.gdb). Esta conexão é feita através do componente
IBDatabase que trata especificamente de conexões realizadas com bancos criados no
Interbase.

Na paleta de componentes, selecione a paleta Interbase;
Dê um clique sobre o componente IBDatabase (4º componente) e adicione-o ao Data
Module DMFuncionarios;
Dê um duplo clique sobre o componente IBDatabase;



Na janela Database Component Editor modifique os seguintes campos (Figura 10):
Database: aponte para o diretório onde encontra-se o arquivo Banco.gdb
(C:AplicativoBancoBanco.gdb). Para facilitar a localização do diretório, utilize o
botão “Browse”;
User Name: SYSDBA;
Password: masterkey;
Character Set: None;
Login Prompt: desmarque esta opção;
Clique no botão “OK” para salvar e fechar a janela.

Figura 10 – Janela Database Component Editor

Modifique as seguintes propriedades do componente IBDatabase (clique no componente
IBDatabase para visualizar suas propriedades no Object Inspector):
Name: DBBanco;

Para conectar-se ao arquivo Banco.gdb, modifique o valor da propriedade Connected (do
componente IBDatabase) para True. Se ocorrer alguma mensagem de erro, verifique se todos
os passos descritos anteriormente estão corretos.

O que foi feito?

Campos manipuladas na janela Database Component Editor:
DatabaseName: o campo Database aponta o diretório onde está localizado o arquivo .GDB,
ou seja, o arquivo que contém todas as informações do banco (metadados) que foi criado
para a aplicação. Através desta propriedade pode-se relacionar o aplicativo em
desenvolvimento ao banco de dados onde serão armazenadas as informações geradas pela
aplicação.
User Name: Nome do usuário que está autorizado para acessar o banco;
Password: senha do usuário;



Login Prompt: quando este campo está marcado, toda vez que houver uma conexão com o
banco de dados será solicitado o nome do usuário e senha (SYSDBA|masterkey). Se não
estiver marcado, não será solicitado o nome do usuário e senha, porém, não será permitido
a conexão com o banco de dados. Neste caso, usuário e senha devem ser definidos no
campo Settings. Se o nome do usuário e senha estiverem definidos nos campos “User
Name” e “Password”, automaticamente, quando for desmarcado esta opção eles serão
adicionados no campo “Settings”.

Propriedades manipuladas do componente IBDatabase:
Name: define o nome do componente IBDatabase.

3.6 Transações e acesso concorrente em banco de dados

Um dos conceitos relacionados a banco de dados é transação. Toda transação iniciada
em um banco de dados deve ser finalizada com Commit ou Rollback. Commit grava efetivamente
todas as modificações (inserção, alteração) realizadas no banco desde o início da transação.
Rollback não efetiva nenhuma das modificações (inserção, alteração) realizadas no banco desde
o início da transação.

3.6.1 Controlando transações através do componente IBTransaction
O componente IBTransaction representa a instância da transação atual e simplifica
muito o controle de transações. Com este objeto, é possível controlar transações concorrentes
originárias da mesma conexão com o banco de dados, ou em Threads independentes.
Para que haja o controle de transações será necessário adicionar o componente
IBTransaction no Data Module.

Selecione o componente IBTransaction (5º componente) e adicione-o ao Data Module
DMFuncionarios;
DefaultDatabase: selecione DBBanco;
Name: DBTBanco;
Active: True.

3.7 Adicionado as tabelas do banco de dados
Todo processo de conexão com o banco já foi definido, agora é necessário conectar as
tabelas do banco com a aplicação.

3.7.1 Conectando a tabela Departamento




Selecione o componente IBTable (1º componente) e adicione-o ao Data Module
DMFuncionarios;

Database: selecione DBBanco;
TableName: selecione TB_DEPARTAMENTO;
Name: Tb_Departamento;
Active: True;

Na paleta de componentes, selecione a paleta Data Access;
Selecione o componente DataSource (1º componente) e adicione-o ao Data Module
DMFuncionarios;
AutoEdit: False;
DataSet: Selecione Tb_Departamento;
Name: dsDepartamento;

3.7.2 Conectando a tabela Dependentes

DMFuncionarios;
TableName: selecione TB_DEPENDENTES;
Name: Tb_Dependentes;
Active: True;

DMFuncionarios;
AutoEdit: False;
DataSet: Tb_Dependentes;
Name: dsDependentes;

3.7.3 Conectando a tabela Estados

DMFuncionarios;
TableName: selecione TB_ ESTADO;
Name: Tb_ Estado;
Active: True;



DMFuncionarios;
AutoEdit: False;
DataSet: Tb_ Estado;
Name: dsEstado;

3.7.4 Conectando a tabela Funcionários
DMFuncionarios;
TableName: selecione TB_FUNCIONARIO;
Name: Tb_Funcionario;
Active: True;

DMFuncionarios;
AutoEdit: False;
DataSet: Tb_Funcionario;
Name: dsFuncionario;

Figura 11 – Data Module DM_Funcionarios com os componentes

O que foi feito?
Propriedades manipuladas no componente IbTable:
Database: identifica o componente Database que representa as tabelas de um banco de
dados (.GDB). A propriedade Database deve ser a primeira a ser definida.
TableName: utilize esta propriedade para selecionar o nome da tabela a qual o componente
IbTable irá representar. Nota: para que a lista das tabelas estejam disponíveis, é
necessário especificar o componente Database na propriedade Database. Também é
necessário que a propriedade Active do componente IbTable esteja False.



Name: Define o nome do componente IbTable.
Active: quando Active é False, a tabela está fechada, ou seja, o componente IbTable não
pode ler ou gravar dados na tabela que está representando. Quando Active é True, os
dados podem ser lidos e gravados na tabela.

Propriedades manipuladas no componente DataSource:
AutoEdit: não permite inserção ou edição automática dos dados.
DataSet: conecta o componente DataSource ao componente IbTable.
Name: define o nome do componente.

IbTable DataSource Sigla

BD IBDatabase Descrição
(.GDB)
IbTable DataSource

3.8 Adicionando os campos das tabelas
Até o momento foram realizadas as conexões com o banco e tabelas (veja Figura 11)
através dos componentes IbTable e DataSource. Agora, é necessário adicionar os campos das
tabelas que foram definidos ao criá-las no Interbase.

Adicionando os campos da tabela Departamento:

Dê um duplo clique na tabela Departamento (Tb_Departamento);
Na janela que aparece (Fields Editor), dê um clique com o botão direito sobre a área em
branco e selecione a opção “Add all fields”;
Dê um clique sobre o primeiro campo (DPT_CODIGO);
digite na propriedade DisplayLabel: Código;
Dê um clique sobre o segundo campo (DPT_DESCRICAO);
digite na propriedade DisplayLabel: Descrição.
Feche a janela Fields Editor.

Adicionando os campos da tabela Dependentes:

Dê um duplo clique na tabela Dependentes (Tb_Dependentes);
Dê um clique sobre o primeiro campo (FUN_CODIGO);
digite na propriedade DisplayLabel: Cód. Func.;
Dê um clique sobre o segundo campo (DEP_CODIGO);
digite na propriedade DisplayLabel: Cód. Depend.;
Dê um clique sobre o terceiro campo (DEP_NOME);
digite na propriedade DisplayLabel: Nome;
Dê um clique sobre o quarto campo (DEP_DATANASCIMENTO);
digite na propriedade DisplayLabel: Data Nasc.;
digite na propriedade EditMask: !99/99/9999;1;_



Dê um clique sobre o quinto campo (DEP_PARENTESCO);
digite na propriedade DisplayLabel: Parentesco;

Adicionando os campos da tabela Estado:

Dê um duplo clique na tabela Estado (Tb_Estado);
Dê um clique sobre o primeiro campo (EST_SIGLA);
digite na propriedade DisplayLabel: Sigla;
Dê um clique sobre o segundo campo (EST_DESCRICAO);
digite na propriedade DisplayLabel: Descrição;

Adicionando os campos da tabela Funcionários:

Dê um duplo clique na tabela Funcionário (Tb_Funcionario);
Dê um clique sobre o primeiro campo (FUN_CODIGO);
digite na propriedade DisplayLabel: Código;
Dê um clique sobre o segundo campo (EST_SIGLA);
digite na propriedade DisplayLabel: Estado;
Dê um clique sobre o terceiro campo (DPT_CODIGO);
digite na propriedade DisplayLabel: Cód. Depto.;
Dê um clique sobre o quarto campo (FUN_NOME);
digite na propriedade DisplayLabel: Nome;
Dê um clique sobre o quinto campo (FUN_DATANASCIMENTO);
digite na propriedade DisplayLabel: Data Nasc.;
digite na propriedade EditMask: !99/99/9999;1;_
Dê um clique sobre o sexto campo (FUN_DDDRESIDENCIAL);
digite na propriedade DisplayLabel: DDD;
digite na propriedade EditMask: !(99);0;_
Dê um clique sobre o sétimo campo (FUN_FONERESIDENCIAL);
digite na propriedade DisplayLabel: Tel.;
digite na propriedade EditMask: !9999-9999;1;_
Dê um clique sobre o oitavo campo (FUN_RUA);
digite na propriedade DisplayLabel: Logradouro;
Dê um clique sobre o nono campo (FUN_COMPLEMENTO);
digite na propriedade DisplayLabel: Complemento;
Dê um clique sobre o décimo campo (FUN_BAIRRO);
digite na propriedade DisplayLabel: Bairro;
Dê um clique sobre o décimo primeiro campo (FUN_CIDADE);
digite na propriedade DisplayLabel: Cidade;



Dê um clique sobre o décimo segundo campo (FUN_CEP);
digite na propriedade DisplayLabel: CEP;
digite na propriedade EditMask: !99.999-999;0;_
Dê um clique sobre o décimo terceiro campo (FUN_SALARIO);
digite na propriedade DisplayLabel: Salário;
modifique a propriedade Currency para True;

O que foi feito?

Propriedades manipuladas na janela Fields Editor:
DisplayLabel: permite determinar um nome para o campo que seja compreensível para o
usuário.
EditMask: quando existe a necessidade de formatar a entrada de dados, máscaras são
recursos poderosos que o desenvolvedor deve utilizar. Através desta propriedade é
possível definir as máscaras de entrada de dados. A máscara “!99.999-999;1;_” pode ser
utilizada para formatar a entrada de CEP. Seu formato, no momento da entrada de dados
seria: __.___-___. Neste exemplo, o número 9 (nove) indica que somente um valor
numérico é aceito nesta posição, porém, não é obrigatório. O número 1 (um) no final da
máscara indica que a máscara será gravada juntamente com seu conteúdo no banco de
dados, ou seja, além dos oito dígitos do CEP, serão gravados ainda mais dois caracteres: o
ponto (.) e o hífen (-). Neste caso, quando necessitamos gravar a máscara, é importante
ficar atento para o tamanho que será definido para o campo no banco de dados. Caso a
máscara seja somente para visualização (não há a necessidade de gravá-la com os dados),
basta trocar o número 1 que está no final da máscara por 0 (zero), ex.: “!99.999-999;0;_”.
Finalmente, o último caracter da máscara (_) indica que os espaços serão preenchidos por
sublinha (_). Se quiséssemos que os espaços fossem preenchidos por zeros, por exemplo,
bastaria trocar o sublinha por 0 (zero), ex.: “!99.999-999;1;0”. Existem outros caracteres
que são utilizados para definir máscaras de entrada de dados. Para maiores informações
consulte o Help do Delphi.
Currency: quando o campo tratar-se de valor monetário e existir a necessidade de
formatá-lo para moeda, basta passar para True o valor desta propriedade. Esta
propriedade somente aparecerá para campos do tipo Real (ponto flutuante).

3.9 Adicionando campos Lookup
Freqüentemente ocorre a necessidade da utilização de campos Lookup. Exemplificando,
quando um funcionário é cadastrado, é necessário ler uma sigla do Estado (UF) para seu
endereço residencial. Os Estados (UF) estarão cadastrados na tabela Estado, portanto, seria
coerente adicionar um combobox listando os estados cadastrados para que o usuário selecione
um dentre os cadastrados. Este tipo de recurso evita a digitação de uma sigla de estado que
não exista, validando a informação e garantindo assim a integridade dos dados. Existem duas
maneiras de adicionar campos Lookup:
1º. Utilizando o componente DBLookupComboBox presente na paleta Data Controls e;
2º. Adicionando diretamente no Fields Editor.



A segunda opção é mais interessante pelo fato do campo Lookup aparecer como um
componente Grid, o que não ocorreria com a primeira opção.

Adicionando campo Lookup na tabela funcionário para Estado:
Dê um duplo clique sobre a tabela Funcionário (Tb_Funcionario);
Na janela Fields Editor, dê um clique com o botão direito e selecione a opção “New Field...”;
Na janela New Field (veja Figura 12), modifique as seguintes propriedades:
Name: Estado;
Type: selecione String;
Size: 40;
Marque o botão Lookup;
DataSet: selecione Tb_Estado;
Result Field: selecione EST_DESCRICAO;
Lookup Keys: selecione EST_SIGLA;
Key Fields: selecione EST_SIGLA;
Clique no botão OK;
Selecione o campo Estado no Fields Editor;
Digite na propriedade DisplayLabel: Estado.

Figura 12 – Definição de campo Lookup na tabela funcionário
Adicionando campo Lookup na tabela funcionário para Departamento:
Dê um duplo clique sobre a tabela Funcionário (Tb_Funcionario);
Na janela Fields Editor, dê um clique com o botão direito e selecione a opção “New Field...”;
Na janela New Field, modifique as seguintes propriedades:
Name: Departamento;
Type: selecione String;
Size: 50;
Marque o botão Lookup;
DataSet: selecione Tb_Departamento;
Result Field: selecione DPT_DESCRICAO;
Lookup Keys: selecione DPT_CODIGO;
Key Fields: selecione DPT_CODIGO;
Clique no botão OK;
Selecione o campo Departamento no Fields Editor;
Digite na propriedade DisplayLabel: Departamento.



O que foi feito?

Campos manipulados na janela New Field:
Name: define o nome do campo Lookup (sem acentos, espaços, etc.);
Type: define o tipo do campo Lookup que está sendo criado;
Size: define o tamanho do campo Lookup;
DataSet: define a origem do campo (qual tabela);
Result Field: define qual campo da tabela origem será visível para o usuário;
Lookup Keys: define qual é o campo chave da tabela origem que será gravado na tabela
destino;
Key Fields: define o campo de destino que receberá o valor do campo de origem;

3.10 Cadastro de Estados
A próxima etapa é a criação dos cadastros necessários para o funcionamento do
sistema. Nos próximos tópicos será abordado como criar formulários em tempo de execução,
métodos do componente IbTable, tratamento de erros de banco de dados, etc.

Figura 13 – Formulário de Cadastro de Estados

Definindo as propriedades do formulário:
No menu File, selecione a opção New | Form;
Modifique as seguintes propriedades do formulário:
Caption: Cadastro de Estados (UF);
Height: 300;
Name: FC_Estados;
Position: poScreenCenter;
Width: 500.
Salvando o formulário:
No menu File, selecione a opção “Save”;
Verifique se o diretório apontado é c:AplicativoFontes;
Nomeie o arquivo para: UFC_Estados;



Adicionando os campos de entrada de dados:
No Data Module DM_Funcionarios, dê um duplo clique sobre a tabela Estado (Tb_Estado)
para visualizar o Fields Editor;
Arraste a janela Fields Editor para o canto superior direito da tela;
Visualize o formulário FC_Estados (Shift+F12);
Clique sobre o campo EST_SIGLA na janela Fields Editor e arraste para o formulário
FC_Estados;
Uma caixa de confirmação deverá aparecer perguntando se você quer adicionar a unit do
Data Module na cláusula uses do formulário Estados, clique no botão Yes;
Clique sobre o campo EST_DESCRICAO no Fields Editor e arraste sobre o formulário
FC_Estados (posicione conforme Figura 13).

Adicionando uma grid para visualizar os dados cadastrados:
Na paleta de componentes Data Controls, selecione o componente DBGrid e adicione-o ao
formulário;
Modifique as seguinte propriedades:
Align: alBottom; {alinha a grid na parte inferior do formulário}
Height: 150; {define a altura da grid}
Name: grdDados; {define o nome do componente grid}
ReadOnly: True; {não permite a edição dos dados através da grid}
DataSource: selecione DMFuncionarios.dsEstado. {define a tabela origem de dados}

Construindo a Barra de botões:
Na paleta de componentes Standard, selecione o componente Panel e adicione-o ao
formulário;
Align: alBottom; {alinha o painel na parte inferior do formulário}
BevelOuter: bvLowered; {deixa o painel em baixo relevo}
Caption: deixe em branco; {não mostra o caption do painel}
Height: 50; {define a altura do painel}
Name: pnlBarraBotao. {define o nome do componente}
Definindo os botões da barra:
Na paleta de componentes Additional, selecione o componente BitBtn e adicione-o na barra
de botões (7 botões BitBtn) (veja Layout final na Figura 14);
Modifique as seguintes propriedades dos botões:
Primeiro botão:
Caption: &Novo; {define o caption e tecla de atalho}
Glyph: selecione um ícone para o botão; {define uma imagem}
*Dica: procure em Arquivos de Programas/Arquivos Comuns/Borland Shared/
Images/Buttons
Height: 48; {define a altura do botão}
Hint: digite “Adiciona um novo registro”; {define a mensagem (hint) de ajuda}
Layout: blGlyphTop; {coloca a imagem na parte superior}
Name: btnNovo; {define o nome do componente}
ShowHint: True; {habilita a visualização do hint}
Width: 65. {define a largura do botão}



Segundo botão:
Caption: &Salvar;
Enabled: False;
Glyph: selecione um ícone para o botão;
Height: 48;
Hint: digite “Salva o registro atual”;
Layout: blGlyphTop;
Name: btnSalvar;
ShowHint: True;
Width: 65.

Terceiro botão:
Caption: &Alterar;
Height: 48;
Hint: digite “Altera o registro atual”;
Layout: blGlyphTop;
Name: btnAlterar;
ShowHint: True;
Width: 65.

Quarto botão:
Caption: &Cancelar;
Enabled: False;
Height: 48;
Hint: digite “Cancela inclusão/alteração”;
Layout: blGlyphTop;
Name: btnCancelar;
ShowHint: True;
Width: 65.

Quinto botão:
Caption: &Excluir;
Height: 48;
Hint: digite “Exclui o registro atual”;
Layout: blGlyphTop;
Name: btnExcluir;
ShowHint: True;
Width: 65.



Sexto botão:
Caption: &Pesquisar;
Height: 48;
Hint: digite “Pesquisa de dados”;
Layout: blGlyphTop;
Name: btnPesquisar;
ShowHint: True;
Width: 65.

Sétimo botão:
Caption: &Sair;
Height: 48;
Hint: digite “Sai do formulário”;
Layout: blGlyphTop;
Name: btnSair;
ShowHint: True;
Width: 65.

Figura 14 – Barra de botões

3.10.1 Habilitando e Desabilitando os botões da barra
Como pode ser percebido, dois botões da barra ficaram desabilitados (Enabled = False).
Os botões Salvar e Cancelar somente podem ficar habilitados se houver uma inclusão ou
alteração dos dados. Para gerenciar estas mudanças, criaremos um procedimento.

Na unit do formulário Estados (utilize F12 para visualizá-la), encontre a seção Public e logo
abaixo da palavra Public, declare o procedimento:
procedure HabilitaBotao(Ativar: Boolean);
posicione o cursor na procedure que acabou de criar e pressione a combinação de teclas
Ctrl+Shift+C para criar o corpo do procedimento;
Digite o seguinte código (apenas o indicado pela chave, o resto já foi criado):
procedure TFC_Estados.HabilitaBotao(Ativar: Boolean);
begin
btnNovo.Enabled := Ativar;
btnSalvar.Enabled := not Ativar;
btnAlterar.Enabled := Ativar;
btnCancelar.Enabled := not Ativar;
btnExcluir.Enabled := Ativar;
btnPesquisar.Enabled := Ativar;
btnSair.Enabled := Ativar;
grdDados.Enabled := Ativar;
end;



3.10.2 Adicionando código aos botões da barra

Código do Botão Novo:

Dê um duplo clique sobre o botão Novo para chamar o evento OnClick;
Adicione o seguinte código:
try //inicia bloco protegido
DMFuncionarios.Tb_Estado.Insert; //Coloca a tabela em modo de inserção
ActiveControl := DBEdit1; // coloca o foco no DBEedit1 (sigla do estado)
HabilitaBotao(False); //Habilita e desabilita botões da barra
except
begin //inicio tratamento caso ocorra erros
Application.MessageBox('Erro ao inserir. Operação Cancelada.','Erro',mb_IconError+mb_Ok);
DMFuncionarios.Tb_Estado.Cancel; //cancela a inserção caso ocorra algum erro
end; //end do begin do except
end; //end do try

Código do botão Salvar:

Dê um duplo clique sobre o botão Salvar para chamar o evento OnClick;
Adicione o código abaixo:
try
DMFuncionarios.Tb_Estado.Post; //Salva os dados da tabela
HabilitaBotao(True); //Habilita e desabilita botões da barra
except
Application.MessageBox('Erro ao salvar. Operação não concluída.','Erro',mb_IconError+mb_Ok);
end; //end do try

Código do botão Alterar

Dê um duplo clique sobre o botão Alterar para chamar o evento OnClick;

try
DMFuncionarios.Tb_Estado.Edit; //coloca a tabela em modo de alteração
except
begin
Application.MessageBox('Erro ao alterar. Operação cancelada.','Erro',mb_IconError+mb_Ok);
DMFuncionarios.Tb_Estado.Cancel; //Cancela a alteração
end; //end do try

Código do botão Cancelar

Dê um duplo clique sobre o botão Cancelar para chamar o evento OnClick;
DMFuncionarios.Tb_Estado.Cancel; //Cancela inserção/alteração dos dados



Código do botão Excluir

Dê um duplo clique sobre o botão Excluir para chamar o evento OnClick;

{verifica se existem registros na tabela antes de excluir}
if DMFuncionarios.Tb_Estado.RecordCount = 0 then {= 0 indica tabela vazia}
begin
Application.MessageBox('Não existem registros para excluir.','Erro',mb_IconError+mb_Ok);
exit; //sai do procedimento sem executar as linhas a seguir
end;

if Application.MessageBox('Confirma Exclusão?', 'Confirmação', mb_IconQuestion+mb_YesNo) = idYes then
begin
try
DMFuncionarios.Tb_Estado.Delete; //deleta o registro atual da tabela
except
Application.MessageBox('Erro ao excluir.','Erro',mb_IconError+mb_Ok);
end; //end do try
end; //end do if

Código do botão Sair

Dê um duplo clique sobre o botão Sair para chamar o evento OnClick;
Close; //fecha o formulário

3.10.3 Adicionando código ao formulário
Além dos códigos adicionados na barra de botões, existem ainda algumas precauções
que devem ser tomadas. Por exemplo: se o usuário clicar no botão Alterar, fizer alterações e
clicar no botão Sair sem salvar os dados, as mudanças realizadas no cadastro não serão
efetivadas. Devemos também garantir que a tabela de Estados esteja ativa quando o
formulário de Estados for chamado. Estes procedimentos podem ser implementados nos
eventos existentes no formulário.

Código de abertura do formulário:

Selecione o formulário (verifique se o nome do formulário aparece na parte superior
(combobox) do Object Inspector);
Selecione a aba Events do Object Inspector para visualizar os eventos do formulário;
Localize o evento “OnCreate”, dê um duplo clique sobre a caixa em branco logo a frente do
nome do evento para chamar o Editor de Código do evento;
Digite o código abaixo:
{verifica se a tabela está fechada (Active = False)}
if DMFuncionarios.Tb_Estado.Active = False then
DMFuncionarios.Tb_Estado.Active := True;



Código de fechamento do formulário:

Selecione o formulário;
Selecione a aba Events do Object Inspector para visualizar os eventos do formulário;
Localize o evento “OnCloseQuery”, dê um duplo clique sobre a caixa em branco logo a
frente do nome do evento para chamar o Editor de Código do evento;
Digite o código abaixo:
{Verifica se o estado da tabela está em inserção ou edição}
if DMFuncionarios.Tb_Estado.State in [dsInsert, dsEdit] then
if Application.MessageBox('Deseja salvar os dados?', 'Confirmação', mb_IconQuestion+mb_YesNo)= idYes then
CanClose := False //Não permite o fechamento do formulário
else //Else do "Application.MessageBox('Deseja ..."
begin
DMFuncionarios.Tb_Estado.Cancel; //Cancela a inclusão/Alteração
CanClose := True; //permite o fechamento do formulário
end //end do else "Application.MessageBox('Deseja ..."
else //Else do "if DMFuncionarios.Tb_Estado.State ..."
CanClose := True; //permite o fechamento do formulário

Aviso: no código de fechamento do formulário existe uma condição que verifica se o
estado da tabela está em modo de inserção ou edição (if DMFuncionarios.Tb_Estado.State in
[dsInsert, dsEdit] then). A propriedade “Estado” (state) armazena o estado da tabela e pode
receber diversos valores (dsInactive, dsBrowse, dsEdit, dsInsert, dsSetKey, dsCalcFields,
dsFilter, dsNewValue, dsOldValue, dsCurValue, dsBlockRead, dsInternalCalc, dsOpening). Para
que esta linha de código execute é necessário adicionar na cláusula uses, no início da Unit, a
unit Db, caso contrário o Delphi irá gerar um erro: Undeclared identifier: 'dsInsert'. Veja o
exemplo:
...
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
ExtCtrls, StdCtrls, Buttons, Mask, DBCtrls, Grids, DBGrids, Db;
...

3.10.4 Validações de dados
Toda aplicação deve conter validações que garantam a consistência dos dados. Verificar
se o código já existe (violação de chave primária − Key Violation) e se os campos obrigatórios
estão preenchidos (campos requeridos) são algumas das validações necessárias na maioria das
aplicações.

3.10.4.1 Verificando a consistência de chave primária:

Existem várias maneiras de verificar a repetição do valor da chave primária. Neste
exemplo, vamos trabalhar com querys, para explorar os recursos deste componente.



Visualize o Data Module DMFuncionarios (Shift+F12);
Na paleta de componentes Interbase, selecione o componente IBQuery e adicione-o ao
Data Module DM_Funcionarios;
Modifique as seguintes propriedades do componente IBQuery:
Name: qryValidaPk;

O próximo passo é definir o código no formulário de cadastros de Estados que irá
verificar a existência de Estados já cadastrados:

Visualize o formulário de Estados (Shift+ F12);
Na seção public da Unit (UFC_Estados) declare o seguinte procedimento:
procedure ValidaChave(Chave: String);
Pressione a combinação de teclas (Shift+Ctrl+C) para criar o corpo do procedimento;
Digite o seguinte código:

{Verifica se a tabela está em modo de inserção ou edição}
if DMFuncionarios.Tb_Estado.State in [dsInsert, dsEdit] then
begin
DMFuncionarios.qryValidaPk.Active:= False; //desativa a query
DMFuncionarios.qryValidaPk.SQL.Clear; //Limpa o conteúdo de cláusulas SQL da query
{Adiciona uma cláusula SQL}
DMFuncionarios.qryValidaPk.SQL.Add('Select EST_SIGLA from Tb_Estado where EST_SIGLA= '''+
chave+'''');
DMFuncionarios.qryValidaPk.Active:= True; //Ativa a query
{Verifica se existem registros na query}
if DMFuncionarios.qryValidaPk.RecordCount > 0 then
begin
Application.MessageBox('Este estado já está cadastrado.','Erro',mb_IconError+mb_Ok);
DMFuncionarios.Tb_Estado.Cancel; //Cancela a inserção/Alteração;
HabilitaBotao(True); ////Habilita e desabilita botões da barra
DMFuncionarios.Tb_Estado.Locate('EST_SIGLA', chave, []); //posiciona no registro existente
end; //end do "if DMFuncionarios.qryValidaPk.RecordCount..."
DMFuncionarios.qryValidaPk.Active:= False; //Desativa a query
end;

Agora é só chamar o procedimento de validação. Podemos chamar este procedimento ao
sair do DBEdit1.

Chamada do procedimento através do DBEdit1:

Clique no componente DBEdit1;
Selecione a aba “Events” do Object Inspector para visualizar os eventos do DBEdit1;
Localize o evento “OnExit” (ao sair), dê um duplo clique sobre a caixa em branco logo a
frente do nome do evento para chamar o Editor de Código do evento;

if DBEdit1.Text <> '' then
{Chama o procedimento de validação de chave primária}
ValidaChave(DBEdit1.Text);



O que foi feito?
Explicação das propriedades e métodos utilizados nos códigos.

Tabela Estado (Tb_Estado)
TTable.Insert: Método que coloca a tabela em modo de inserção de dados (inclusão). Para
que este método execute é necessário que a tabela esteja ativa (Active deve ser igual a
True);
TTable.Post: método que grava os dados na tabela. Para que este método seja executado é
necessário que a tabela esteja no modo de inserção ou edição;
TTable.Edit: método que coloca a tabela em modo de edição (alteração). A tabela deve
estar ativa.
TTable.Cancel: método que cancela uma inserção ou edição da tabela.
TTable.Delete: método que exclui o registro selecionado.
TTable.RecordCount: propriedade que retorna a quantidade de registros existentes na
tabela.
TTable.Active: propriedade que define quando uma tabela está aberta ou não. Tabela
aberta = True. Tabela fechada = False;
TTable.State: indica o estado da tabela, os mais importantes são:
dsInactive: tabela fechada;
dsBrowse: tabela está no modo de navegação;
dsEdit: tabela está no modo de edição (alteração);
dsInsert: tabela está no modo de inserção;
dsSetKey: tabela está no modo de pesquisa;
dsCalcFields: (campos calculados) um cálculo está em progresso;
dsFilter: processo de filtragem em progresso;
TTable.Locate: (usado em DMFuncionarios.Tb_Estado.Locate('EST_SIGLA', chave, []);)
pesquisa o conteúdo de um ou mais registros e posiciona o cursor. 1º Parâmetro: nomes dos
campos onde será realizada a pesquisa entre aspas simples; 2º parâmetro: valor a ser
pesquisado no(s) campo(s) entre aspas simples; 3º parâmetro (opcional): define opções de
pesquisa sendo duas opções: loCaseInsensitive: não diferencia letras maiúsculas de
minúsculas; loPartialKey: efetua busca de valores retornando valores de campos parciais,
exemplo: “Cam” poderia retornar “Campos”, “Campinas” etc. Esta função é aplicada tanto
para tabelas como para Queryes.

Query qryValidaPk:
TQuery.Active: determina se a query está fechada (False) ou aberta (True);
TQuery.Sql.Clear: limpa as cláusulas SQL que estão armazenadas na propriedade SQL.
TQuery.Add: adiciona cláusulas SQL na propriedade SQL.

Mensagem: (Application.MessageBox('Este estado já está cadastrado.','Erro',mb_IconError+mb_Ok);)
Application.MessageBox: define uma caixa de mensagem genérica. 1º parâmetro: mensagem
que será exibida para o usuário. 2º parâmetro: título da caixa de mensagem. 3º parâmetro:
botões que serão adicionados a caixa de mensagem.



3.10.4.2 Verificando os campos de preenchimento obrigatório
Para verificar os campos que devem ser preenchidos (obrigatórios) será implementada
uma função que irá verificar, antes de salvar, se existe algum campo requerido que esteja com
valor nulo, caso exista, aparece uma mensagem e a operação é cancelada.

Visualize o formulário de Estados (Shift+ F12);
Na seção public da Unit (UFC_Estados) declare a seguinte função:
function VerificaCampoObrigatorio: Boolean;
Pressione a combinação de teclas (Shift+Ctrl+C) para criar o corpo da função;
Digite o seguinte código com exceção das linhas em cinza:

function TFC_Estados.VerificaCampoObrigatorio: Boolean;
var i : integer;//declaração de variável local
begin
//executa loop até o número de registros existentes na tabela
for i:= 0 to DMFuncionarios.Tb_Estado.Fields.Count - 1 do
begin
{Verifica se o campo é obrigatório}
if DMFuncionarios.Tb_Estado.Fields[i].Required = true then
begin
{Verifica se existe valor para o campo}
if DMFuncionarios.Tb_Estado.Fields[i].IsNull then
begin
Application.MessageBox(PChar('Campo obrigatório: '+DMFuncionarios.Tb_Estado.Fields[i].DisplayLabel),
'Erro',mb_IconError+mb_Ok);
VerificaCampoObrigatorio := True; //retorna True, existe campo obrigatório sem preencher
Break; //cancela o loop;
end
else
VerificaCampoObrigatorio:= False; //retorna False, não existe campo obrigatório sem preencher
end;
end;

A próxima etapa é chamar a função. Isto pode ser feito no evento “OnClick” do botão
Salvar (btnSalvar) adicionando uma condição antes de salvar os dados (Post).
Dê um duplo clique no botão salvar (btnSalvar);
Antes da palavra reservada “try” digite o seguinte código (as duas primeiras linhas
assinaladas):

⇒ if VerificaCampoObrigatorio = True then
⇒ exit;
try
DMFuncionarios.Tb_Estado.Post; //Salva os dados da tabela



3.10.5 Pesquisa do Cadastro de Estados

Figura 15 – Formulário de Pesquisa de Estados

Definindo as propriedades do formulário:
No menu File, selecione a opção New | Form para criar um novo formulário;
Modifique as seguintes propriedades do novo formulário:
BorderStyle: selecione bsDialog;
Caption: Pesquisa de Estados;
Height: 300;
Name: FP_Estados;
Position: selecione poScreenCenter;
Width: 500;
No menu File, selecione a opção Save;
Verifique se o diretório atual é c:AplicativoFontes;
Nomeie o arquivo para: UFP_Estados;

Definindo as propriedades do componente RadioGroup:
Na paleta de componentes Standard, selecione o componente RadioGroup e adicione-o ao
formulário na parte superior esquerda (veja Figura 15);
Caption: “Pesquisa por:”;
Height: 80;
Items: clique no botão com reticências e adicione duas linhas: “Sigla” e “Descrição”;
ItemIndex: 0 (zero);
Name: rgOpcao;
Width: 120.

Definindo as propriedades do componente Label:
Na paleta de componentes Standard, selecione o componente Label e adicione-o ao
formulário (veja Figura 15);
Caption: “Texto da pesquisa”;
Font: deixe em negrito;
Name: lblTexto;



Definindo as propriedades do componente Edit:
Na paleta de componentes Standard, selecione o componente Edit e adicione-o ao
CharCase: ecUpperCase; //Transforma todos os caracteres em maiúsculo
Name: edtTexto;
Text: deixe em branco.

Definindo as propriedades do componente BitBtn de pesquisa:
Na paleta de componentes Additional, selecione o componente BitBtn e adicione-o ao
Caption: &Pesquisar;
Glyph: defina uma figura para o botão, de preferência a mesma utilizada no botão
Pesquisar do formulário Estado;
Name: btnPesquisar;
Width: 125.

Definindo as propriedades do componente BitBtn para sair do formulário:
Na paleta de componentes Additional, selecione o componente BitBtn e adicione-o ao
Caption: &Sair;
Glyph: defina uma figura para o botão, de preferência a mesma utilizada no botão Sair
do formulário Estado;
Name: btnSair;
Width: 125.

Definindo a Query de pesquisa:
Data Module;
Name: qryPesquisas.
Na paleta de componentes Data Access, selecione o componente DataSource e adicione-o
ao Data Module;
AutoEdit: False; //quando Falso não permite que os dados sejam alterados na grid
DataSet: selecione qryPesquisas;
Name: dsQryPesquisa.



Definindo a grid de visualização dos dados da pesquisa:
Visualize o formulário de Pesquisa de Estados (FP_Estado) (Shift+F12);
Na paleta de componentes Data Controls, selecione o componente DBGrid e adicione-o ao
formulário de Pesquisa de Estados;
No menu File, selecione a opção Use Unit;
Na janela Use Unit, selecione UDM_Funcionarios e clique no botão Ok. Isto permitirá que o
formulário de Pesquisa de Estados utilize os componentes do Data Module DMFuncionarios;
Modifique as seguintes propriedades da DBGrid:
Align: alBottom;
DataSource: selecione DMFuncionarios.dsQryPesquisa;
Height: 180;
Name: dbgPesquisa;
Options: clique no sinal de + ao lado do nome da propriedade para visualizar as
subpropriedades e, na subpropriedade dgTitles, selecione False;
ReadOnly: True.

O que foi feito?

Propriedades manipuladas no componente RadioGroup:
Items: esta propriedade permite adicionar uma lista de opções de botões de seleção. Para
cada linha adicionada no editor, é criado uma opção. O primeiro elemento da linha (Sigla)
recebe o índice 0 (zero), o segundo elemento da lista (Descrição) recebe 1 e, se houvessem
mais seguiriam esta seqüência. Portanto, os elementos da lista iniciam em 0 (zero.)
ItemIndex: utilize esta propriedade para definir um valor inicial para sua lista assinalando
um elemento, se definirmos o valor 0 (zero) para esta propriedade, será marcado o
primeiro elemento da lista, valor 1 marca o segundo elemento da lista e assim por diante.

Adicionando o código do botão Pesquisar:
Dê um duplo clique sobre o botão Pesquisar para chamar o evento “OnClick”;
if edtTexto.Text = '' then //se não houver texto para pesquisa
begin
Application.MessageBox('Informe o texto da pesquisa.','Erro',mb_IconError+mb_Ok);
ActiveControl:= edtTexto; //foco no Edit
exit; //sai do procedimento de pesquisa
end
else //senão existe texto para pesquisa
if rgOpcao.ItemIndex = 0 then //se a sigla estiver selecionada como opção de pesquisa
begin
DMFuncionarios.qryPesquisas.Active:= False; //fecha a query de pesquisa
DMFuncionarios.qryPesquisas.Sql.Clear; //limpa o conteúdo da propriedade SQL
DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Estado');
DMFuncionarios.qryPesquisas.Sql.Add('where EST_SIGLA starting with '''+edtTexto.Text+'''');
DMFuncionarios.qryPesquisas.Active:= True; //abre a query
if DMFuncionarios.qryPesquisas.RecordCount = 0 then //verifica a qtde de registros da pesquisa
Application.MessageBox('Sigla não encontrada.','Erro',mb_IconError+mb_Ok);



end
else //senão ItemIndex = 1, ou seja, a opção de pesquisa é pela descrição
begin
DMFuncionarios.qryPesquisas.Active:= False; //fecha a query de pesquisa
DMFuncionarios.qryPesquisas.Sql.Clear; //limpa o conteúdo da propriedade SQL
DMFuncionarios.qryPesquisas.Sql.Add('where EST_DESCRICAO starting with '''+edtTexto.Text+'''');
DMFuncionarios.qryPesquisas.Active:= True; //abre a query
if DMFuncionarios.qryPesquisas.RecordCount = 0 then //verifica a qtde de registros da pesquisa
Application.MessageBox('Descrição não encontrada.','Erro',mb_IconError+mb_Ok);
end;

Código do botão Sair:
Dê um duplo clique no botão Sair;
if DMFuncionarios.qryPesquisas.RecordCount <> 0 then //verifica a qtde de registros da pesquisa
DMFuncionarios.Tb_Estado.Locate('EST_SIGLA',DMFuncionarios.qryPesquisas.fieldByName('EST_SIGLA').Value
,[ ]);
DMFuncionarios.qryPesquisas.Active:= False; //fecha a query

O procedimento para fechar o formulário possui uma condição que verifica se existem
registros na query através da propriedade RecordCount. Se não houver registro, ou seja, a
consulta não foi bem sucedida, a query e o formulário são fechados, porém, se existir
registros, através da função Locate posiciona-se no registro da Tabela Estado que seja igual ao
registro selecionado na grid do formulário.

Chamando o formulário de Pesquisa:
O próximo passo é chamar o formulário de Pesquisa através do botão Pesquisar. Para
isso será necessário alguns passos:
Visualize o Formulário de Cadastro de Estados (FC_Estados) (Shift+F12);
No menu File, escolha a opção “Use Unit...”;
Selecione o formulário de pesquisa (UFP_Estados) e clique no botão Ok;
Dê um duplo clique no botão Pesquisar (btnPesquisar);

Application.CreateForm(TFP_Estados,FP_Estados);//aloca memória para o formulário
FP_Estados.ShowModal; //mostra o formulário
finally //executa a linha abaixo se ocorrer algum erro
FP_Estados.Release; //libera o formulário da memória
end; //end finally

No menu Project, selecione “Options...”;
Na aba Forms, localize o formulário de Pesquisa de Estado (FP_Estados) que se encontra
na caixa de listagem Auto-create Forms e mova-o para a caixa de listagem Available Forms
utilizando o botão com sinal de maior (>);
Clique no botão Ok.



O que foi feito?
Código do botão:
Application.CreateForm: usado em Application.CreateForm(TFP_Estados,FP_Estados);
permite a criação de formulário em tempo de execução, precisa de dois parâmetros
(separados por vírgula): 1º Nome do formulário antecedido da letra “T” (parâmetro de
classe) e, 2º nome do formulário (variável de referência). Nesta linha apenas é alocada
memória para o formulário;
ShowModal: mostra o formulário;
Release: libera o formulário da memória quando o mesmo for fechado através do método
Close.

Project|Options:
Toda vez que um formulário é adicionado ao projeto, o Delphi automaticamente assume
a “responsabilidade” de alocar memória para este formulário e, quando a aplicação é executada
todos os formulários são criados na memória (criados, porém não visualizados). Isto pode
incorrer em um problema: se uma aplicação contiver “n” formulários, quando for executada a
aplicação, todos os formulários serão alocados na memória podendo ocorrer falta de memória.
Para resolver esta situação devemos assumir a responsabilidade de criação e destruição de
formulários. Para isso, é necessário criar o formulário em tempo de execução, ou seja, somente
vamos criar o formulário (alocar memória) quando o formulário for necessário e, isto é
realizado através do código sugerido para o botão Pesquisar. Toda vez que houver a
necessidade de criar um formulário, pode-se utilizar o mesmo código mudando apenas os
parâmetros de criação. Entretanto, uma vez utilizado este código, é necessário tirar a
“responsabilidade” do Delphi em alocar memória para o formulário, uma vez que a tomamos
através do código sugerido no botão Pesquisar. Isto é feito através da opção Project|Options
na aba Forms quando mudamos o formulário da caixa de listagem Auto-create Forms para
listagem Available Forms, com isso assumimos a responsabilidade de criar, mostrar e liberar o
formulário da memória. Um benefício imediato é que a aplicação ficará mais leve, uma vez que
não será alocada memória para diversos formulários quando a aplicação for executada.

Chamando o Cadastro de Estados pelo Menu Principal:
Visualize o formulário Menu Principal (FPrincipal) (Shift+F12);
No menu Cadastros, dê um clique no subitem Estados;
try
Application.CreateForm(TFC_Estados,FC_Estados); //aloca memória para o formulário
FC_Estados.ShowModal; //mostra o formulário
finally
FC_Estados.Release; //libera da memória
end;
Na aba Forms, localize o formulário de Estado (FC_Estados) que se encontra na caixa de
listagem Auto-create forms e mova-o para a caixa de listagem Available forms utilizando o
botão com sinal de maior (>);



3.11 Construindo formulários modelo (Repositório)
Os próximos formulários de cadastros seguirão o mesmo padrão do formulário de
Cadastro de Estados com algumas modificações. Para acelerar o processo de desenvolvimento
de um aplicativo, o Delphi dispõe de recursos que agilizam a programação através do
reaproveitamento de código. No caso dos formulários, podemos utilizar um formulário já
construído para implementar outros formulários que possuirão as mesmas características (o
mesmo código com algumas modificações).

3.11.1 Adicionando o formulário de Cadastro de Estados ao Repositório
Visualize o Formulário de Cadastro de Estados (FC_Estados) (Shift+F12);
Dê um clique com o botão direito do mouse sobre o formulário;
No menu suspenso, selecione a opção “Add to Repository...”;
Na janela Add To Repository, modifique os seguintes campos:
Title: Modelo de Cadastro;
Description: Modelo para cadastro;
Page: selecione Forms;
Author: digite seu nome;
Clique no botão Ok;

3.11.2 Adicionando o formulário de Pesquisa de Estados ao Repositório
Visualize o Formulário de Pesquisa de Estados (FP_Estados) (Shift+F12);
Dê um clique com o botão direito do mouse sobre o formulário;
No menu suspenso, selecione a opção “Add to Repository...”;
Na janela Add To Repository, modifique os seguintes campos:
Title: Modelo de Pesquisa;
Description: Modelo para pesquisa;
Page: selecione Forms;
Author: digite seu nome;
Clique no botão Ok;

3.12 Cadastro de Departamento
Os demais formulários terão basicamente as mesmas características. Entretanto,
vamos reaproveitar o código definido no Cadastro de Estados e, com algumas alterações, vamos
construir os demais formulários economizando tempo. Nas seções anteriores, adicionamos o
formulário de Estados ao repositório do Delphi e, através deste recurso, será reaproveitado o
formulário na construção dos demais.



Figura 16 – Formulário de Cadastro de Departamentos

No menu File, escolha “New”
Escolha a opção “Other...”
Na janela New Items, escolha a aba Forms;
Localize o ícone com o título “Modelo de Cadastro”;
Certifique-se de que o botão de opção “Copy” (na parte inferior), esteja selecionado;

Neste exato momento, uma cópia do formulário Modelo de Cadastro deve estar visível.
Agora é só efetuar algumas alterações para que o Cadastro de Departamento esteja pronto em
pouco tempo.

Propriedades do formulário que devem ser alteradas:
Caption: Cadastro de Departamentos;
Name: FC_Departamentos.

No menu File, escolha “Save”;
Certifique-se de estar apontando para o diretório c:AplicativoFontes;
Nome do arquivo: UFC_Departamentos;

Modificando os componentes do formulário:
Delete os dois componentes DBEdit e Label;
Clique sobre a grid e, no Object Inspector, na propriedade DataSource, escolha:
DMFuncionarios.dsDepartamento;
Dê um duplo clique sobre a tabela Departamento (Tb_Departamento);
Arraste a janela Fields Editor para o canto direito superior do vídeo;
Visualize o formulário de Cadastro de Departamentos (FC_Departamentos) (Shift+F12);
Na janela Fields Editor, selecione e arraste o primeiro campo (DPT_CODIGO) para o
formulário e solte na posição desejada (veja Figura 16);
Na janela Fields Editor, selecione e arraste o segundo campo (DPT_DESCRICAO) para o



Modificando o código fonte:
Pressione a tecla F12 para visualizar o editor de código fonte;
Posicione o cursor na primeira linha do código fonte;
No menu Search, escolha “Replace...”;
Na caixa de edição “Text to find”, digite: Tb_Estado;
Na caixa de edição “Replace with”, digite: Tb_Departamento;
Clique no botão “Replace All”;
A medida que o texto procurado é localizado, uma caixa de mensagem pedirá confirmação
para a substituição do texto;

Localize o corpo da procedure ValidaChave;
Substitua a linha:
DMFuncionarios.qryValidaPk.SQL.Add('Select EST_SIGLA from Tb_Estado where EST_SIGLA='''+
chave+'''');
Por:
DMFuncionarios.qryValidaPk.SQL.Add('Select DPT_CODIGO from Tb_Departamento where DPT_CODIGO='''+
chave+'''');
Substitua a linha:
Por:
Application.MessageBox('Este departamento já está cadastrado.','Erro',mb_IconError+mb_Ok);
Substitua na linha:
DMFuncionarios.Tb_Departamento.Locate('EST_SIGLA', chave, []);
Por:
DMFuncionarios.Tb_Departamento.Locate('DPT_CODIGO', chave, []);

3.12.1 Pesquisa do Cadastro de Departamentos
Também vamos reaproveitar o formulário de Pesquisa de Estados que adicionamos ao
repositório para construir o formulário de Pesquisa de Departamentos.

Figura 17 – Formulário de Pesquisa de Departamentos
No menu File, escolha “New | Other...”
Na janela New Item, escolha a aba Forms;
Localize o ícone com o título “Modelo de Pesquisa”;
Certifique-se de que o botão de opção “Copy” (na parte inferior), esteja selecionada;



Caption: Pesquisa de Departamentos;
Name: FP_Departamentos.

Nome do arquivo: UFP_Departamentos;

Clique sobre o componente RadioGroup (rgOpcao);
Items: substitua a linha Sigla por Código.

Dê um duplo clique sobre o botão Pesquisar;
Substitua a linha:
Por:
DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Departamento');
Substitua a linha:
Por:
DMFuncionarios.qryPesquisas.Sql.Add('where DPT_CODIGO starting with '''+edtTexto.Text+'''');
Substitua a linha:
Por:
Application.MessageBox('Código não encontrado.','Erro',mb_IconError+mb_Ok);
Substitua a linha:
Por:
DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Departamento');
Substitua a linha:
Por:
DMFuncionarios.qryPesquisas.Sql.Add('where DPT_DESCRICAO starting with '''+edtTexto.Text+'''');
Visualize o formulário de Pesquisa de Departamento (F12);
Dê um duplo clique sobre o botão Sair;
Substitua a linha:
DMFuncionarios.Tb_Estado.Locate('EST_SIGLA',DMFuncionarios.qryPesquisas.fieldByName('EST_SIGLA').Value,[]);
Por:
DMFuncionarios.Tb_Departamento.Locate('DPT_CODIGO',DMFuncionarios.qryPesquisas.fieldByName('DPT_CODIGO').Value,[]);

Alterando o código do botão pesquisar do formulário de Cadastro de Departamentos:
Visualize o formulário de Cadastro de Departamentos (FC_Departamentos);
Dê um duplo clique no botão Pesquisar;
Substitua as linhas:



try
Application.CreateForm(TFP_Estados,FP_Estados);
FP_Estados.ShowModal;
Finally
FP_Estados.Release;
end;
Por:
try
Application.CreateForm(TFP_Departamentos, FP_Departamentos);
FP_Departamentos.ShowModal;
Finally
FP_Departamentos.Release;
end;
No menu File, escolha Use Unit...;
Escolha “UFP_Departamentos” e clique no botão Ok;

Na aba Forms, localize o formulário de Pesquisa de Departamentos (FP_Departamentos)
que se encontra na caixa de listagem Auto-create forms e mova-o para a caixa de listagem
Available forms utilizando o botão com sinal de maior (>);

Chamando o Cadastro de Departamentos pelo Menu Principal:

No menu Cadastros, dê um clique no subitem Departamentos;
try
Application.CreateForm(TFC_Departamentos, FC_Departamentos); //aloca memória para o formulário
FC_Departamentos.ShowModal; //mostra o formulário
finally
FC_Departamentos.Release; //libera da memória
end;
Na aba Forms, localize o formulário de Cadastro de Departamentos (FC_Departamentos)
que se encontra na caixa de listagem Auto-create forms e mova-o para a caixa de listagem
Available forms utilizando o botão com sinal de maior (>);
No menu File, escolha Use Unit...;
Escolha “UFC_Departamentos” e clique no botão Ok;

3.13 Cadastro de Funcionários
A próxima etapa é a construção do Cadastro de Funcionários que será elaborado
através do modelo adicionado ao repositório do Delphi.



Figura 18 – Formulário de Cadastro de Funcionários


Caption: Cadastro de Funcionários;
Name: FC_Funcionarios.

Nome do arquivo: UFC_Funcionarios;

DMFuncionarios.dsFuncionario;
Dê um duplo clique sobre a Tabela Funcionário (Tb_Funcionario);
Visualize o formulário de Cadastro de Funcionários (FC_Funcionarios) (Shift+F12);
Aumente o formulário na altura e comprimento pois serão adicionados vários campos e
precisamos de maior espaço (veja Figura 18);
Na janela Fields Editor, selecione e arraste o primeiro campo (FUN_CODIGO) para o
formulário e solte na posição desejada;
Faça este mesmo procedimento para os outros campos, na ordem apresentada a seguir
(oriente-se pela Figura 18):



FUN_NOME;
FUN_DDDRESIDENCIAL;
FUN_FONERESIDENCIAL;
FUN_DATANASCIMENTO;
Departamento (Campo Lookup) e não DPT_CODIGO;
FUN_SALARIO;
FUN_RUA;
FUN_COMPLEMENTO;
FUN_BAIRRO;
FUN_CEP;
FUN_CIDADE e;
Estado (Campo Lookup) e não EST_SIGLA;
Clique sobre o painel de botões (pnlBarraBotao), e não sobre os botões;
Modifique a propriedade Align de “alBottom” para “alNone”;
Clique sobre o componente grid (grdDados) e pressione a combinação de teclas Ctrl+X para
recortar a grid;
Selecione a paleta de componentes Win32, adicione o componente PageControl (segundo
componente) no local onde estava posicionado a grid;
Modifique as seguintes propriedades do componente PageControl:
Align: alBottom;
Name: pcFuncionario.
Clique com o botão direito do mouse sobre o componente PageControl e selecione a opção
“New Page” do menu suspenso;
Name: tsFuncionarios.
Clique com o botão direito do mouse sobre o componente PageControl e selecione a opção
“New Page” do menu suspenso;
Caption: Dependentes;
Name: tsDependentes.
Clique sobre o painel de botões (pnlBarraBotão), e não sobre os botões;
Modifique a propriedade Align de “alNone” para “alBottom”;
Clique no centro da aba Funcionários do componente Page Control para selecionar o
componente TabSheet Funcionários (tsFuncionarios);
Se você não copiou nada na memória, pressione a combinação de teclas Ctrl+V para colar a
grid;
Clique sobre o componente grid e modifique a propriedade Align para “alClient”;
Clique na aba Dependentes do componente PageControl;
Clique no centro da aba Dependentes para selecionar o componente TabSheet Dependentes
(tsDependentes);
Se você não copiou nada na memória, pressione a combinação de teclas Ctrl+V para colar a
grid;
Clique sobre o componente grid e modifique as propriedades:
Align: “alClient”;
DataSource: DMFuncionarios.dsDependentes;



Name: grdDependentes.

Na caixa de edição “Replace with”, digite: Tb_Funcionario;
Substitua a linha:
DMFuncionarios.qryValidaPk.SQL.Add('Select EST_SIGLA from Tb_Funcionario where EST_SIGLA = '''+
chave+'''');
Por:
DMFuncionarios.qryValidaPk.SQL.Add('Select FUN_CODIGO from Tb_Funcionario where FUN_CODIGO = '''+
chave+'''');
Substitua a linha:
Por:
Application.MessageBox('Este Funcionário já está cadastrado.','Erro',mb_IconError+mb_Ok);
Substitua na linha:
DMFuncionarios.Tb_Funcionario.Locate('EST_SIGLA', chave, []);
Por:
DMFuncionarios.Tb_Funcionario.Locate('FUN_CODIGO', chave, []);

3.13.1 Pesquisa do Cadastro de Funcionários

Figura 19 – Formulário de Pesquisa de Funcionários

Localize o ícone com o título “Modelo de Pesquisa”;




Caption: Pesquisa de Funcionários;
Name: FP_Funcionarios.

Nome do arquivo: UFP_Funcionarios;

Modificando componentes do formulário:
Clique sobre o componente RadioGroup (rgOpcao);
Items: substitua a linha Sigla por Código.
Items: substitua a linha Descrição por Nome.

Dê um duplo clique sobre o botão Pesquisar;
Substitua a linha:
Por:
DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Funcionario');
Substitua a linha:
Por:
DMFuncionarios.qryPesquisas.Sql.Add('where FUN_CODIGO starting with '''+edtTexto.Text+'''');
Substitua a linha:
Por:
Application.MessageBox('Código não encontrado.','Erro',mb_IconError+mb_Ok);
Substitua a linha:
Por:
DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Funcionario');
Substitua a linha:
Por:
DMFuncionarios.qryPesquisas.Sql.Add('where FUN_NOME starting with '''+edtTexto.Text+'''');
Substitua a linha:
Application.MessageBox('Descrição não encontrada.','Erro',mb_IconError+mb_Ok);
Por:
Application.MessageBox('Nome não encontrado.','Erro',mb_IconError+mb_Ok);
Visualize o formulário de Pesquisa de Funcionários (F12);
Dê um duplo clique sobre o botão Sair;



Apague as linhas de código e adicione as linhas abaixo:
if DMFuncionarios.qryPesquisas.RecordCount <> 0 then //verifica a qtde de registros da pesquisa
{posiciona no registro da tabela estado que seja igual ao registro selecionado no gride}
DMFuncionarios.Tb_Funcionario.Locate('FUN_NOME',DMFuncionarios.qryPesquisas.fieldByName('FUN_NOME').Value,[]);
DMFuncionarios.qryPesquisas.Active:= False; //fecha a query

Alterando o código do botão pesquisar do formulário de Cadastro de Funcionários:
Visualize o formulário de Cadastro de Funcionários (FC_Funcionarios) (Shift+F12);
Dê um duplo clique no botão Pesquisar;
Substitua as linhas:
try
Application.CreateForm(TFP_Estados,FP_Estados);
FP_Estados.ShowModal;
Finally
FP_Estados.Release;
end;
Por:
try
Application.CreateForm(TFP_Funcionarios, FP_Funcionarios);
FP_Funcionarios.ShowModal;
Finally
FP_Funcionarios.Release;
end;
No menu File, escolha Use unit...;
Escolha “UFP_Funcionarios” e clique no botão Ok;

Na aba Forms, localize o formulário de Pesquisa de Funcionários (FP_Funcionarios) que se
encontra na caixa de listagem Auto-create Forms e mova-o para a caixa de listagem
Available Forms utilizando o botão com sinal de maior (>);

Chamando o Cadastro de Funcionários pelo Menu Principal:
No menu Cadastros, dê um clique no subitem Departamentos;
try
Application.CreateForm(TFC_Funcionarios, FC_Funcionarios); //aloca memória para o formulário
FC_Funcionarios.ShowModal; //mostra o formulário
finally
FC_Funcionarios.Release; //libera da memória
end;
Na aba Forms, localize o formulário de Cadastro de Funcionários (FC_Funcionarios) que se



No menu File, escolha Use unit...;
Escolha “UFC_Funcionarios” e clique no botão Ok;

3.14 Cadastro de Dependentes
Finalmente vamos construir o Cadastro de Dependentes.

Figura 20 – Cadastro de Dependentes


Caption: Cadastro de Dependentes;
Name: FC_Dependentes.

Nome do arquivo: UFC_Dependentes;

DMFuncionarios.dsDependentes;
Dê um duplo clique sobre a tabela Dependentes (Tb_Dependentes);
Visualize o formulário de Cadastro de Dependentes (FC_Dependentes) (Shift+F12);
Na janela Fields Editor, selecione e arraste o terceiro campo (DEP_NOME) para o



Na janela Fields Editor, selecione e arraste o quarto campo (DEP_DATANASCIMENTO)
para o formulário e solte na posição desejada;
Não adicione os campos: FUN_CODIGO, DEP_CODIGO e DEP_PARENTESCO;
Escolha na paleta de componentes Data Controls, o componente DBRadioGroup e adicione-o
ao formulário. Ajuste o tamanho do formulário se for preciso (veja Figura 20);
Caption: Parentesco:
Columns: 2;
DataSource: selecione DMFuncionarios.dsDependentes;
DataField: selecione DEP_PARENTESCO;
Items: adicione a lista abaixo, para cada item uma linha:
Pai
Mãe
Esposa
Filho(a)
Irmão(ã)
Values: adicione a lista abaixo, para cada item uma linha:
Pai
Mãe
Esposa
Filho(a)
Irmão(ã)

Na caixa de edição “Replace with”, digite: Tb_Dependentes;

Apague todas as linhas (cabeçalho e corpo);
Na seção public, apague o cabeçalho da procedure;

Adicionando código auto incremental para dependentes:
Dê um duplo clique sobre o botão Novo (btnNovo);
Faça a inserção das linhas em destaque abaixo à procedure Novo (não se esqueça de
declarar a variável ultimo):

procedure TFC_Dependentes.btnNovoClick(Sender: TObject);
var ultimo : integer;
begin
DMFuncionarios.Tb_Dependentes.Last; //vai para o último registro
{Atribui o valor do campo dep_codigo do último registro da tabela dependentes para a variável último}
ultimo := DMFuncionarios.Tb_Dependentes.FieldByName('DEP_CODIGO').AsInteger;
DMFuncionarios.Tb_Dependentes.Insert; //Coloca a tabela em modo de inserção



{soma 1 a variável último e atribui ao campo dep_codigo que está sendo inserido}
DMFuncionarios.Tb_Dependentes.FieldByName('DEP_CODIGO').AsInteger:= ultimo + 1;
ActiveControl := DBEdit1; // coloca o foco no DBEedit1
except
begin //inicio tratamento caso ocorra erros
Application.MessageBox('Erro ao inserir. Operação Cancelada.','Erro',mb_IconError+mb_Ok); //mensagem
DMFuncionarios.Tb_Dependentes.Cancel; //cancela a inserção caso ocorra algum erro
end; //end do try
end;

Visualize o formulário de Dependentes e dê um duplo clique sobre o botão Pesquisar;
Exclua as linhas entre o begin e end da procedure;
Visualize o formulário de Dependentes e delete o botão Pesquisar;
Localize a procedure HabilitaBotao e exclua a linha onde consta uma referência ao botão
Pesquisar;
Ajuste o botão Sair na barra de botões.

3.14.1 Definindo a tabela Dependente como detalhe da tabela Funcionário
Certamente seria interessante que somente os dependentes do funcionário atualmente
selecionado fossem visualizados. Assim, quando os dados do funcionário “X” estiverem visíveis,
ao clicarmos na aba onde está presente a grid de dependentes, somente apareceriam os
dependentes do funcionário “X”.
Este tipo de visão de dados é chamado de mestre-detalhe, onde mestre é a tabela
Funcionário (cardinalidade do lado 1) e detalhe é a tabela Dependentes (cardinalidade do lado
n).

3.14.2 Quando posso aplicar o recurso mestre-detalhe ?

O recurso mestre-detalhe somente pode ser aplicado para tabelas que possuam
relacionamento entre si. Analise a cardinalidade abaixo:

1 N
Funcionário Dependente

“Um funcionário possui n dependentes”.

Quem é a tabela mestre?
A tabela mestre sempre será o lado da cardinalidade igual a 1, portanto, neste
relacionamento, mestre é funcionário. Logo, detalhe é a tabela do relacionamento onde a
cardinalidade é igual a n. As tabelas detalhe (Dependente) sempre receberão a chave primária
(FUN_CODIGO) da tabela mestre (Funcionário). Na tabela detalhe, essa chave será chamada
de chave estrangeira (lembre-se: chave estrangeira sempre do lado n).
Relacionamentos mestre-detalhe nem sempre são aplicados, mesmo que as condições
expostas acima sejam satisfeitas. Por exemplo: O relacionamento entre Estados e Funcionários
caracteriza uma relação onde pode-se aplicar o recurso mestre-detalhe, onde mestre seria



Estado e detalhe seria Funcionário (1 estado está contido em n funcionários). Entretanto, se
aplicássemos este recurso neste relacionamento, só veríamos funcionários por estado, ou seja,
quando posicionarmos no Estado “X”, somente veríamos os funcionários daquele estado. Neste
caso, não seria muito interessante aplicar este recurso, porém, cada caso é um caso.
Definindo relações mestre-detalhe:
Dê um clique sobre a tabela detalhe (Tb_Dependentes);
No Object Inspector, localize a propriedade MasterSource (“Fonte mestre”);
Selecione o Data Source mestre (dsFuncionario);
Localize a propriedade MasterFields e clique no botão com reticências;
Na janela “Field Link Designer” faça o seguinte:
Selecione a chave estrangeira (FUN_CODIGO) presente na tabela Dependentes na
caixa de seleção “Detail Fields”;
Selecione a chave primária (FUN_CODIGO) presente na tabela Funcionários na caixa
de seleção “Master Fields”;
Dê um clique no botão Add;
Dê um clique no botão Ok para finalizar.

Pronto, agora somente serão visíveis os dependentes por funcionários.

Chamando o cadastro de Dependentes através do Formulário de Funcionários:
Visualize o cadastro de Funcionários;
Adicione um novo botão na barra de botões;
Caption: &Dependentes;
Glyph: escolha uma nova figura para o botão;
Hint: Cadastro de Dependentes;
Name: btnDependente;
Width: 100.
Dê um duplo clique sobre o botão btnDependente;
Adicione as seguintes linhas de código entre o begin e end da procedure:
Application.CreateForm(TFC_Dependentes,FC_Dependentes);//aloca memória para o formulário
FC_Dependentes.ShowModal; //mostra o formulário
Finally //executa a linha abaixo se ocorrer algum erro
FC_Dependentes.Release; //libera o formulário da memória
end; //end finally
No menu File, escolha “Use Unit...”;
Selecione o formulário “UFC_Dependentes” e clique no botão OK.
Na aba Forms, localize o formulário de Cadastro de Dependentes (FC_Dependentes) que se



4 RELATÓRIOS

O objetivo deste capítulo é a construção de relatórios contendo os dados das tabelas
definidas neste curso. Para tanto, serão abordados diversos tipos de relatórios com a
finalidade de mostrar alguns dos recursos possíveis.
Para tanto, será utilizado os componentes da paleta QReport (Quick Report®) que é um
conjunto de componentes destinados para a elaboração de relatórios. Vale lembrar ainda que
existem diversos gerados de relatórios que podem ser utilizados para esta tarefa. Para
habilitar o Quick Report no Delphi 7 faça o seguinte:
- No menu Component... selecione Install Packages.
- Na janela Design Packages, clique no botão Add...
- Vá até a pasta Delphi7Bin e selecione o arquivo dclqrt70.bpl e clique em abrir.

4.1 Elaborando relatório simples (Relatório de Estados)
Elaborar relatórios pode se tornar uma atividade muito complexa, dependendo do tipo
de visão que se quer dos dados. Para relatórios simples, ou seja, relatórios que mostram apenas
os dados já cadastrados esta tarefa é fácil. Para ilustrar esta situação vamos construir um
relatório que vai listar todos os Estados cadastrados.

Figura 21 – Relatório de Estados

No menu File, escolha “New Form”;
Caption: Relatório de Estados;
Name: FR_Estados;
Certifique-se de estar apontando para o diretório “C:AplicativoFontes”;
Nome do arquivo: UFR_Estados;

Adicionando os componentes de relatório:
Na paleta de componentes QReport, selecione o componente QuickRep e adicione-o ao
formulário;
No menu File, escolha a opção “Use Unit”;



Na janela “Use Unit”, escolha o Data Module UDM_Funcionarios;
DataSet: escolha DMFuncionarios.Tb_Estado;
Name: QREstados;
ReportTitle: Relatório de Estados;
Dê um clique no sinal de + (mais) da propriedade Bands para visualizar as sub
propriedades, modifique as seguintes sub propriedades:
HasColumnHeader: True;
HasDetail: True;
HasPageFooter: True;
HasTitle: True.

Modificando as bandas Title (Título):
Dê um clique na primeira banda (Title);
Propriedade Height: 50;
Dê um clique no sinal de + (mais) da propriedade Frame e modifique as seguintes sub
propriedades:
DrawBottom: True;
Width: 2.

Dê um clique na segunda banda (Column Header);
propriedades:
DrawBottom: True;
Width: 2.

Dê um clique na terceira banda (Detail);
Propriedade Height: 20.

Dê um clique na última banda (PageFooter);
propriedades:
DrawTop: True;
Width: 2.

Definindo o título do relatório de Estados:
Na paleta de componentes QReport, selecione o componente QRLabel e adicione-o em cima
da prima banda (Title);
Modifique as seguintes propriedades do componente QRLabel:
Alignment: taCenter;
AlignToBand: True;
Caption: Relatório de Estados;
Font: tamanho 20, em negrito, Fonte: Comic Sans MS;
Top: 5.



Definindo os cabeçalhos das colunas:
Na paleta de componentes QReport, selecione o dois (2) componentes QRLabel e adicione-
os em cima da banda Column Header (segunda banda);
Modifique as seguintes propriedades da primeira QRLabel:
Caption: Sigla;
Font: tamanho 12 em negrito;
Left: 15;
Top: 4.
Modifique as seguintes propriedades da segunda QRLabel:
Caption: Descrição;
Left: 100;
Top: 4.

Definindo os dados que serão listados no relatório:
Na paleta de componentes QReport, selecione o dois (2) componentes QRDBText e
adicione-os em cima da banda Detail (terceira banda);
Modifique as seguintes propriedades da primeira QRDBText:
DataSet: selecione DMFuncionarios.Tb_Estado;
DataField: selecione EST_SIGLA;
Left: 15;
Top: 2.
Modifique as seguintes propriedades da segunda QRDBText:
DataSet: selecione DMFuncionarios.Tb_Estado;
DataField: selecione EST_DESCRICAO;
Left: 100;
Top: 2.

Definindo o Rodapé:
Na paleta de componentes QReport, selecione o dois (2) componentes QRSysData e
adicione-os em cima da banda Page Footer (última banda);
Modifique as seguintes propriedades da primeira QRSysData:
Data: qrsDateTime;
Left: 15;
Text: Data/Hora: ; (deixe um espaço em branco após os dois pontos “:”)
Top: 8.
Modifique as seguintes propriedades da segunda QRSysData:
Data: qrsPageNumber;
Left: 600;
Text: Página: ; (deixe um espaço em branco após os dois pontos “:”)
Top: 8.

Visualizando o relatório:
É possível visualizar o relatório de Estados em tempo de projeto.
Dê um clique com o botão direito do mouse sobre o componente QuickRep (não pode ser em
cima de nenhuma banda) e selecione a opção Preview do menu suspenso.



Se tudo ocorreu bem, os dados do relatório serão listados.

Executando o relatório pelo formulário Menu Principal:

Visualize o formulário Principal (FPrincipal) (Shift+F12);
Dê um clique no menu Relatórios e selecione o item de menu Estados para chamar o evento
OnClick;
try
Application.CreateForm(TFR_Estados,FR_Estados); //aloca memória para o formulário
FR_Estados.QREstados.Preview; //mostra o relatório
finally
FR_Estados.Release; //libera da memória
end;
No menu File, escolha “Use unit...”;
Na janela Use Unit, escolha “UFR_Estados” e clique no botão Ok;

Na aba Forms, localize o formulário de Relatório de Estados (FR_Estados) que se encontra
na caixa de listagem Auto-create Forms e mova-o para a caixa de listagem Available Forms
utilizando o botão com sinal de maior (>);

4.2 Elaborando relatório mestre-detalhe (Funcionário e seus Dependentes)
Elaborar relatórios onde são listados mais de uma tabela são freqüentes no
desenvolvimento de software. Exemplo seria um relatório que listaria todos os funcionários e,
para cada funcionário, os seus dependentes. Estes tipos de relatórios são chamados de
relatórios mestre-detalhe.

Figura 22 – Relatório de Funcionários e Dependentes

Caption: Relatório de Funcionários e Dependentes;



Name: FR_FuncionarioDependente;
Nome do arquivo: UFR_FuncionarioDependente;

formulário;
Modifique as seguintes propriedades do componente QuickRep:
DataSet: escolha DMFuncionarios.Tb_Funcionario;
Name: QRFuncDependente;
ReportTitle: Relatório de Funcionários e Dependentes;
HasDetail: True;
HasTitle: True.

Adicionando a banda detalhe (onde aparecerão os dependentes):
Na paleta de componentes QReport, selecione o componente QRSubDetail e adicione-o em
cima do componente QuickRep (QRFuncDependente);
Se tudo ocorreu bem, a banda QRSubDetail ficou abaixo da banda Detail.
Modifique as seguintes propriedades da banda QRSubDetail:
DataSet: DMFuncionarios.Tb_Dependentes;
Verifique se a propriedade Master está apontando para o componente
QRFuncDependente, senão, selecione-o;
Height: 20.

propriedades:
DrawBottom: True;
Width: 2.

propriedades:
DrawBottom: True;
Width: 2.



Color: clSilver;
Height: 20;
propriedades:
DrawBottom: True.

propriedades:
DrawTop: True;
Width: 2.

AlignToBand: True;
Caption: Relatório de Funcionário e Dependentes;
Top: 5.

Caption: Código;
Left: 15;
Top: 4.
Caption: Nome do funcionário;
Left: 100;
Top: 4.

Definindo os dados que serão listados dos funcionários no relatório:
Color: selecione clSilver;
DataSet: selecione DMFuncionarios.Tb_Funcionario;
DataField: selecione FUN_CODIGO;



Left: 15;
Top: 2.
Color: selecione clSilver;
DataSet: selecione DMFuncionarios.Tb_Funcionario;
DataField: selecione FUN_NOME;
Left: 100;
Top: 2.

Definindo os dados que serão listados dos dependentes no relatório:
Na paleta de componentes QReport, selecione o três (3) componentes QRDBText e
adicione-os em cima da banda SubDetail (terceira banda);
DataSet: selecione DMFuncionarios.Tb_Dependentes;
DataField: selecione DEP_NOME;
Left: 15;
Top: 2.
DataField: selecione DEP_PARENTESCO;
Left: 300;
Top: 2.
Modifique as seguintes propriedades da terceira QRDBText:
DataField: selecione DEP_DATANASCIMENTO;
Left: 500;
Top: 2.

Data: qrsDateTime;
Left: 15;
Top: 8.
Left: 600;
Top: 8.






Dê um duplo clique no componente MainMenu para abrir o editor de menus;
Dê um clique no menu Relatórios;
Dê um clique no submenu funcionários;
Dê um clique com o botão direito do mouse sobre o menu Funcionários e selecione a opção
“Create Submenu”;
No submenu que aparece à direita do submenu Funcionários, modifique as seguintes
propriedades:
Caption: Dependentes;
Name: imRelDependentes.
Dê um duplo clique sobre o submenu Dependentes para chamar o evento OnClick;
try
Application.CreateForm(TFR_FuncionarioDependente,FR_FuncionarioDependente);
FR_FuncionarioDependente.QRFuncDependente. Preview; //mostra o relatório
finally
FR_FuncionarioDependente.Release; //libera da memória
end;
Na janela Use Unit, escolha “UFR_FuncionarioDependente” e clique no botão Ok;

Na aba Forms, localize o formulário de Relatório de funcionários e Dependentes
(FR_FuncionarioDependente) que se encontra na caixa de listagem Auto-create Forms e
mova-o para a caixa de listagem Available Forms utilizando o botão com sinal de maior (>);

4.3 Utilizando Query para elaborar relatório de Soma de Salários por Departamento
Existem situações onde é necessário gerar relatórios onde é necessário somar valores,
por exemplo. Esta situação será exemplificada através de um relatório onde serão listados
todos os departamentos e a soma de salários deste departamento.



Figura 23 – Relatório da soma de Salários por Departamento
Caption: Relatório de salários por departamento;
Name: FR_SalariosDepto;
Nome do arquivo: UFR_SalariosDepto;

formulário;
Modifique as seguintes propriedades do componente IBQuery:
DataBase: selecione DMFuncionarios.DBBanco;
Name: qrySomaSalarioDepto;
Sql: dê um clique no botão com reticências e digite a seguinte sentença sql no editor:
select Tb_Departamento.DPT_DESCRICAO, sum(Tb_Funcionario.FUN_SALARIO)
from Tb_Departamento, Tb_Funcionario
where Tb_Departamento.DPT_CODIGO = Tb_Funcionario.DPT_CODIGO
group by Tb_Departamento.DPT_DESCRICAO
Dê um clique no botão Ok;

formulário;
Modifique as seguintes propriedades do componente QuickRep:
DataSet: escolha qrySomaSalarioDpto;
Name: QRSomaSalario;
ReportTitle: Relatório de Salários por Departamento;



HasDetail: True;
HasTitle: True.

propriedades:
DrawBottom: True;
Width: 2.

propriedades:
DrawBottom: True;
Width: 2.

Height: 20;

propriedades:
DrawTop: True;
Width: 2.

AlignToBand: True;
Caption: Relatório de Salários por Departamento;
Top: 5.

Caption: Departamento;
Left: 15;



Top: 4.
Caption: Soma dos salários;
Left: 300;
Top: 4.

Definindo os dados que serão listados no relatório:
DataSet: selecione qrySomaSalarioDpto;
DataField: selecione DPT_DESCRICAO;
Left: 15;
Top: 2.
DataSet: selecione qrySomaSalarioDpto;
DataField: selecione SUM;
Left: 300;
Mask: R$ #.00
Top: 2.

Data: qrsDateTime;
Left: 15;
Top: 8.
Left: 600;
Top: 8.

Verifique se a propriedade active da Query está true;





Dê um duplo clique no componente MainMenu para abrir o editor de menus;
Dê um clique no menu Relatórios;
Dê um clique na linha em branco logo após o submenu Estados;
Caption: Departamentos;
Name: imDepartamento.
Dê um clique com o botão direito do mouse sobre o menu Departamento e selecione a opção
“Create Submenu”;
No submenu que aparece à direita do submenu Departamento, modifique as seguintes
propriedades:
Caption: Soma dos Salários por Departamento;
Name: imSomaSalario.
Dê um duplo clique sobre o submenu “Soma dos Salários por Departamento” para chamar o
evento OnClick;
try
Application.CreateForm(TFR_SalariosDepto,FR_SalariosDepto); //aloca memória para o formulário
FR_SalariosDepto.qrySomaSalarioDepto.Active:= False; //fecha a query
FR_SalariosDepto.qrySomaSalarioDepto.Active:= True; //abre a query para que seja atualizada
FR_SalariosDepto.QRSomaSalario.Preview; //mostra o relatório
finally
FR_SalariosDepto.Release; //libera da memória
end;
Na janela Use Unit, escolha “UFR_SalariosDpto” e clique no botão Ok;

Na aba Forms, localize o formulário de Relatório de Salários por Departamento
(FR_SalariosDpto) que se encontra na caixa de listagem Auto-create Forms e mova-o para
a caixa de listagem Available Forms utilizando o botão com sinal de maior (>);

Exercícios sugeridos:
Construa dois relatórios simples:
Um contendo todos os dados dos funcionários e,
Outro contendo todos os dados de Departamentos.


Material Delphi diego

Mais conteúdo relacionado

Mais procurados

Semelhante a Material Delphi diego

Último

Material Delphi diego