1. Í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. 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
Prof. Eduardo Cotrin Teixeira

3. 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
Prof. Eduardo Cotrin Teixeira

4. Í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
Prof. Eduardo Cotrin Teixeira

5. 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

6. 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}
Prof. Eduardo Cotrin Teixeira

7. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 3
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
Prof. Eduardo Cotrin Teixeira

8. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 4
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
Prof. Eduardo Cotrin Teixeira

9. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 5
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
Prof. Eduardo Cotrin Teixeira

10. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 6
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).
Prof. Eduardo Cotrin Teixeira

11. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 7
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
Prof. Eduardo Cotrin Teixeira

12. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 8
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.
Prof. Eduardo Cotrin Teixeira

13. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 9
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
Prof. Eduardo Cotrin Teixeira

14. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 10
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.
Prof. Eduardo Cotrin Teixeira

15. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 11
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.
Prof. Eduardo Cotrin Teixeira

16. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 12
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.
Prof. Eduardo Cotrin Teixeira

17. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 13
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
Prof. Eduardo Cotrin Teixeira

18. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 14
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;
Prof. Eduardo Cotrin Teixeira

19. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 15
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).
Prof. Eduardo Cotrin Teixeira

20. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 16
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.
Prof. Eduardo Cotrin Teixeira

21. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 17
☺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.
Prof. Eduardo Cotrin Teixeira

22. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 18
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.
Prof. Eduardo Cotrin Teixeira

23. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 19
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
Prof. Eduardo Cotrin Teixeira

24. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 20
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
Codigo_Cliente Nome Telefone Cidade Cpf
1 José 999999-99 Cornélio Procópio 999.999.999-99
É 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
Codigo_Cliente Nome Telefone Cidade Cpf
1 José 999999-99 Cornélio Procópio 999.999.999-99
4 José 666666-66 Santa Mariana 666.666.666-66
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:
Prof. Eduardo Cotrin Teixeira

25. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 21
Select *
From Cliente
Where Cidade = “Cornélio Procópio”
Resultado
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
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
Codigo_Cliente Nome Telefone Cidade Cpf
4 José 666666-66 Santa Mariana 666.666.666-66
3 Saulo 777777-77 Londrina 777.777.777-77
2 Rafaela 888888-88 Cornélio Procópio 888.888.888.-88
1 José 999999-99 Cornélio Procópio 999.999.999-99
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
Prof. Eduardo Cotrin Teixeira

26. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 22
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
Codigo_Cliente Nome Telefone Cidade Cpf
1 José 999999-99 Cornélio Procópio 999.999.999-99
4 José 666666-66 Santa Mariana 666.666.666-66
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.
Prof. Eduardo Cotrin Teixeira

27. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 23
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
Prof. Eduardo Cotrin Teixeira

28. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 24
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
Prof. Eduardo Cotrin Teixeira

29. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 25
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)
);
Prof. Eduardo Cotrin Teixeira

30. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 26
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
);
Prof. Eduardo Cotrin Teixeira

31. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 27
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
Prof. Eduardo Cotrin Teixeira

32. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 28
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;
Clique no botão Salvar;
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.
Prof. Eduardo Cotrin Teixeira

33. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 29
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:
Prof. Eduardo Cotrin Teixeira

34. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 30
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:
Modifique as seguintes propriedades:
Caption: Estados (UF);
Name: imEstados;
ShortCut: escolha Ctrl+E.
Clique sobre o item de menu em branco logo abaixo de Estados:
Modifique as seguintes propriedades:
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;
Modifique as seguintes propriedades:
Caption: &Relatórios;
Name: imRelatorios.
Prof. Eduardo Cotrin Teixeira

35. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 31
Clique sobre o item de menu Relatórios;
Clique sobre o item de menu em branco logo abaixo do item Relatórios;
Modifique as seguintes propriedades:
Caption: Funcionários;
Name: imRelFuncionarios.
Clique sobre o item de menu em branco logo abaixo do item Funcionários;
Modifique as seguintes propriedades:
Caption: Estados;
Name: imRelEstados.
Clique sobre o item de menu em branco do lado direito do item Relatórios;
Modifique as seguintes propriedades:
Caption: &Ajuda;
Name: imAjuda.
Clique sobre o item de menu Ajuda;
Clique sobre o item de menu em branco logo abaixo do item Ajuda;
Modifique as seguintes propriedades:
Caption: Ajuda do Sistema;
Name: imAjudaSistema.
Clique sobre o item de menu em branco logo abaixo do item Ajuda do Sistema;
Modifique a propriedade:
Caption: - (hífen).
Clique sobre o item de menu em branco logo abaixo da linha divisória;
Modifique as seguintes propriedades:
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
Prof. Eduardo Cotrin Teixeira

36. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 32
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;
Modifique a propriedade:
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;
Prof. Eduardo Cotrin Teixeira

37. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 33
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;
Prof. Eduardo Cotrin Teixeira

38. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 34
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.
Na paleta de componentes, selecione a paleta Interbase;
Selecione o componente IBTransaction (5º componente) e adicione-o ao Data Module
DMFuncionarios;
Modifique as seguintes propriedades:
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
Na paleta de componentes, selecione a paleta Interbase;
Prof. Eduardo Cotrin Teixeira

39. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 35
Selecione o componente IBTable (1º componente) e adicione-o ao Data Module
DMFuncionarios;
Modifique as seguintes propriedades:
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;
Modifique as seguintes propriedades:
AutoEdit: False;
DataSet: Selecione Tb_Departamento;
Name: dsDepartamento;
3.7.2 Conectando a tabela Dependentes
Na paleta de componentes, selecione a paleta Interbase;
Selecione o componente IBTable (1º componente) e adicione-o ao Data Module
DMFuncionarios;
Modifique as seguintes propriedades:
Database: selecione DBBanco;
TableName: selecione TB_DEPENDENTES;
Name: Tb_Dependentes;
Active: True;
Na paleta de componentes, selecione a paleta Data Access;
Selecione o componente DataSource (1º componente) e adicione-o ao Data Module
DMFuncionarios;
Modifique as seguintes propriedades:
AutoEdit: False;
DataSet: Tb_Dependentes;
Name: dsDependentes;
3.7.3 Conectando a tabela Estados
Na paleta de componentes, selecione a paleta Interbase;
Selecione o componente IBTable (1º componente) e adicione-o ao Data Module
DMFuncionarios;
Modifique as seguintes propriedades:
Database: selecione DBBanco;
TableName: selecione TB_ ESTADO;
Name: Tb_ Estado;
Active: True;
Prof. Eduardo Cotrin Teixeira

40. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 36
Na paleta de componentes, selecione a paleta Data Access;
Selecione o componente DataSource (1º componente) e adicione-o ao Data Module
DMFuncionarios;
Modifique as seguintes propriedades:
AutoEdit: False;
DataSet: Tb_ Estado;
Name: dsEstado;
3.7.4 Conectando a tabela Funcionários
Na paleta de componentes, selecione a paleta Interbase;
Selecione o componente IBTable (1º componente) e adicione-o ao Data Module
DMFuncionarios;
Modifique as seguintes propriedades:
Database: selecione DBBanco;
TableName: selecione TB_FUNCIONARIO;
Name: Tb_Funcionario;
Active: True;
Na paleta de componentes, selecione a paleta Data Access;
Selecione o componente DataSource (1º componente) e adicione-o ao Data Module
DMFuncionarios;
Modifique as seguintes propriedades:
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.
Prof. Eduardo Cotrin Teixeira

41. Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 37
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);
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 (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;_
Prof. Eduardo Cotrin Teixeira