Delphi 7 - SQL Server 2000

Introdução .................................................................................................... 2

Módulo 1: Introdução aos Sistemas Gerenciadores de Banco de Dados .................. 4 Conhecendo o SQL Server 2000 .............................................................. 5 Modelagem de Dados ............................................................................. 14 Instrução SELECT .................................................................................. 27 Instrução INSERT .................................................................................. 47 Instrução UPDATE ................................................................................. 51 Instrução DELETE .................................................................................. 54

Módulo 2: Conectando o Delphi ao SQL Server ................................................... 61 Componentes de Acesso a Dados ............................................................. 62 Recuperando e exibindo dados ................................................................ 65 Inserindo dados .................................................................................... 82 Atualizando dados ................................................................................. 93 Excluindo dados .................................................................................... 99 Tratando erros de banco de dados ........................................................... 103

Módulo 3: Projetando uma Aplicação de Banco de Dados ..................................... 115 Planejando a aplicação: “Gerenciador de Cursos de Informática” ............ 116 Criando um Diagrama de Funcionalidades ................................................. 118 Projetando o banco de dados .................................................................. 121 Criando as tabelas ................................................................................. 126 Iniciando a programação ........................................................................ 140

Módulo 4: Criando o Controle de Acesso ............................................................ 145 Criando a tela de Splash ......................................................................... 146 Programando o processo de autenticação no Servidor ................................ 150 Configurando a tela de Logon .................................................................. 155 Criando o mecanismo de verificação de usuários e permissões .................... 163 Montando o cadastro de usuários e permissões ......................................... 167

Módulo 5: Criando as Funcionalidades da Aplicação ............................................. 187 Cadastro de Cursos ............................................................................... 188 Cadastro de Instrutores .......................................................................... 198 Cadastro de Turmas .............................................................................. 210 Cadastro de Alunos ................................................................................ 231 Cadastro de Matrículas ........................................................................... 236 Criando o Lançamento de Aulas ............................................................... 251 Criando o Lançamento de Presença .......................................................... 256 Montando o Pagamento de Instrutores ..................................................... 262

Módulo 6: Criando os Relatórios ....................................................................... 285 Relação de Cursos ................................................................................. 286 Relação de Turmas por Curso .................................................................. 296 Relação de Alunos por Turma .................................................................. 305 Relatório de Faltas dos Alunos ................................................................. 314 Relatório de Aulas por Instrutor ............................................................... 323

Conclusão ..................................................................................................... 332

Índice

Delphi com Banco de Dados Cliente/Servidor

Introdução

Atualmente existem diversos paradigmas de programação, vários são os conceitos e

metodologias adotadas para o desenvolvimento de aplicações. Ouve-se muito sobre

“Desenvolvimento em Camadas” e “Desenvolvimento para a Internet”. Todos os grandes

sistemas construídos recentemente seguem esta nova onda. Entretanto, não podemos fechar

os olhos para o que já existe.

Muito dos sistemas que revolucionaram o mercado de desenvolvimento foram

programados seguindo o modelo Cliente/Servidor. Nos primórdios da programação, o que

reinava eram os computadores de Grande Porte que com grande poder de processamento

ficavam responsáveis por todo o trabalho. Os poderosos Mainframes possuíam terminais

“burros” que apenas contavam com um monitor e um teclado sem qualquer processamento

local. Mas apesar de jurássicos, os sistemas em COBOL (linguagem de programação mais

comum para Mainframe) ainda respondem pelas principais operações de grandes organizações

como bancos e instituições financeiras.

Com o surgimento e popularização dos microcomputadores, surgiu o modelo de

desenvolvimento Cliente/Servidor. Este modelo veio para “substituir” os antigos Mainframes,

pois oferecia uma grande facilidade para construção de aplicações baseadas em redes de

microcomputadores. O modelo Cliente/Servidor trouxe várias ferramentas para

desenvolvimento nesta plataforma que proporcionavam um alto índice de produtividade e um

produto final mais bonito e amigável ao usuário através da interface gráfica. Mesmo com todos

os benefícios oferecidos, o modelo Cliente/Servidor não fez com que os grandes sistemas em

COBOL fossem exterminados. A “explicação” é simples: Por que trocar tudo o que já funciona

por algo novo só porque está na moda? Seria um absurdo abandonar todo um legado de

sistemas que atendem perfeitamente às necessidades por um novo modelo de programação

com a justificativa de que é o que há de mais moderno no mercado. Este mesmo

entendimento se aplica ao combate Cliente/Servidor X Web. Muitos sistemas foram

desenvolvidos com o modelo Cliente/Servidor e ainda hoje continuam funcionando! Então por

que jogar tudo fora e fazer de novo em ambiente Web?

Sem sombra de dúvidas, o avanço da tecnologia é algo muito importante para o

aperfeiçoamento da programação. É óbvio que os novos sistemas devem utilizar as novas

tecnologias de desenvolvimento de aplicações. Não podemos ser hipócritas e negar os

benefícios de cada novo lançamento nesta área, porém, temos que ter o amadurecimento para

não esquecer de tudo o que já foi feito e saber reconhecer que ainda precisamos dos sistemas

que estão rodando por aí. Afinal, quando algum sistema Cliente/Servidor precisar de uma

manutenção, teremos que realiza-la ou alguém ainda acha que é melhor escrever tudo de

novo para a internet do que corrigir algumas linhas de código?

Este material foi desenvolvido com o objetivo de elucidar os interessados na

programação Cliente/Servidor.

2 de 332


Aqui você obterá conhecimentos suficientes para o desenvolvimento de aplicações

Cliente/Servidor com Delphi. Além do aprendizado na linguagem de programação, você

também aprenderá como trabalhar com um SGBD (Sistema Gerenciador de Banco de Dados).

O SGBD escolhido é o Microsoft SQL Server 2000, um poderoso banco de dados que possui

uma grande aceitação no mercado de trabalho.

Os assuntos serão mencionados numa ordem natural para um bom entendimento de

todo o curso. Primeiro iremos entender o que é o modelo Cliente/Servidor e como desenvolver

aplicações seguindo este modelo de programação. Em seguida, conheceremos o SQL Server

2000. Veremos as ferramentas para manipulação do banco de dados e como nos conectar a

ele. A linguagem SQL é o próximo assunto a ser mencionado. Veremos como recuperar os

dados através do comando SELECT e como modifica-los através das instruções INSERT,

UPDATE e DELETE.

Após sabermos como trabalhar com o SQL Server (no nível de desenvolvedor), iremos

ver os componentes que o Delphi disponibiliza para a manipulação de banco de dados. Além

dos objetos de interação com o banco de dados, aprenderemos como prevenir e como tratar

os erros de banco de dados.

Depois de aprendermos como trabalhar com o SQL Server e como interagir com ele

através do Delphi, iremos criar uma aplicação de banco de dados Cliente/Servidor completa.

Este projeto simulará um sistema para administração de cursos de informática. Mas antes de

desenvolver a aplicação, faremos todo o planejamento da mesma. Criaremos um diagrama da

funcionalidade do sistema, elaboraremos o modelo de dados e então criaremos as tabelas no

SQL Server.

Ao término da fase de projeto, partiremos para a programação do sistema em Delphi.

Criaremos o controle de acesso e todas as funcionalidades da aplicação com todos os cadastros

e movimentações envolvidas no contexto do sistema. Ao final do projeto criaremos os

relatórios da aplicação.

3 de 332


Módulo 1:

Introdução aos Sistemas Gerenciadores

de Banco de Dados

este módulo iremos conhecer o modelo Cliente/Servidor e um Banco

de Dados que trabalha nesta plataforma: o Microsoft SQL Server

2000. Veremos como nos conectar a ele através do Enterprise

Manager e do Query Analyzer que são as principais ferramentas de interação

com o Banco de Dados. Em seguida aprenderemos um pouco sobre

modelagem de dados. Apesar da modelagem de dados não ser o foco deste

livro, este assunto será abordado, pois é muito importante que o

desenvolvedor conheça o modelo relacional e saiba trabalhar com ele.

Continuando nossa jornada no mundo dos SGBD’s, conheceremos a linguagem

SQL (Structured Query Language ou Linguagem de Consulta Estruturada) a

qual permitirá que recuperemos e modifiquemos as informações contidas em

um banco de dados.

N

4 de 332


Conhecendo o SQL Server 2000

O SQL Server 2000 é o principal produto da linha de sistemas de banco de dados da

Microsoft. O Microsoft SQL Server ou simplesmente MSSQL é o mecanismo de banco de dados

principal na indústria de computação para a plataforma Windows NT/2000/XP/2003. O MSSQL

é um Sistema Gerenciador de Banco de Dados que, como tantos outros, opera voltado para o

Ambiente Cliente/Servidor. Antes de ver mais de perto o SQL Server e aprender a utilizá-lo,

vamos entender o que é e como funciona o modelo Cliente/Servidor.

Antigamente os sistemas rodavam em uma única máquina, um computador com grande

poder de processamento conhecido como Mainframe. Neste computador ficavam o banco de

dados e a aplicação ao mesmo tempo. Os usuários utilizavam os sistemas através de terminais

“burros” que eram compostos apenas por um monitor e um teclado. Todo o processamento era

executado no mainframe e os terminais apenas serviam para exibir o resultado disso. Veja a

figura abaixo para um melhor entendimento:

Com o surgimento dos microcomputadores e das redes de microcomputadores, nasceu

o modelo Cliente/Servidor. Diferentemente de um terminal de mainframe, um

microcomputador possui “vida própria”, ou seja, ele possui poder de processamento. Sendo

assim, ele não depende de um outro computador para executar suas tarefas podendo ele

mesmo processar localmente tudo o que precisar. Com isto, os desenvolvedores de sistemas

resolveram utilizar o processamento dos microcomputadores tirando do servidor a

responsabilidade de executar a aplicação. Apenas o banco de dados continuou no servidor já

que é preciso que os dados estejam centralizados num único lugar de forma que todos os

usuários tenham acesso às informações consolidadas.

Nasce então o modelo Cliente/Servidor, onde temos basicamente dois elementos neste

ambiente: o cliente, encarregado de executar a aplicação e o servidor de banco de dados,

5 de 332


responsável por armazenar as informações do sistema. Veja a figura abaixo que representa o

ambiente Cliente/Servidor:

Resumindo, um sistema Cliente/Servidor é dividido em duas partes: uma que excuta

em um servidor e uma que executa em estações de trabalho. O lado do servidor fornece

segurança, tolerância a falhas, desempenho, concorrência e backups confiáveis. O lado do

cliente fornece a interface com o usuário que possui os relatórios, as consultas e os

formulários. O SQL Server é a parte do servidor onde vários clientes podem se conectar a ele.

Em computação Cliente/Servidor, quando uma consulta é executada, o servidor

pesquisa o banco de dados e envia apenas as linhas que correspondem à pesquisa do cliente.

Esse processo não somente poupa tráfego na rede como também pode ser mais rápido do que

ter as estações realizando as consultas.

Para ter acesso ao SQL Server, existem um conjunto de ferramentas disponíveis no

grupo de programas do Menu Iniciar. Para vê-las, clique em Iniciar > Programas >

Microsoft SQL Server.

6 de 332


Dentre as ferramentas disponíveis para utilização do SQL Server 2000, iremos utilizar

apenas duas, as mais importantes: o Enterprise Manager e o Query Analyzer.

O Enterprise Manager é a interface gráfica administrativa do SQL Server. Através dela é

possível visualizar todos os banco de dados criados no servidor e fazer praticamente tudo

como criar tabelas, consultar e inserir registros, administrar usuários e fazer backup.

O SQL Server 2000 possui vários bancos de dados que são criados durante a instalação.

Dentre eles, existem os bancos de dados de sistema, que são utilizados pelo SQL Server 2000

e os bancos de dados de exemplos. Os bancos de dados de sistema são: master, model,

msdb e tempdb. Cada um deles possui uma função específica para o funcionamento do SQL

Server e não podem ser excluídos! Existem também dois bancos de dados de exemplo:

Northwind e pubs. Estes bancos de dados são apenas amostras para ajudar no aprendizado

do SQL Server e podem ser excluídos sem problemas.

Além dos bancos de dados padrão do SQL Server, você pode criar seus próprios bancos

de dados e certamente faremos isto durante este curso.

7 de 332


Para exemplificarmos o uso do Enterprise Manager, vamos consultar as informações

contidas em uma tabela do banco de dados Northwind. Para isso, navegue até a opção

“Tables” do banco de dados Northwind e clique com o botão direito do mouse sobre a tabela

“Categories”. Na caixa de diálogo que aparecerá, clique em Open Table > Return all rows.

Então serão exibidos todos os registros contidos nesta tabela.

Para voltar à tela anterior feche a janela de visualização dos dados da tabela.

8 de 332


Além dos dados contidos na tabela, podemos verificar a estrutura dela, ou seja, as

colunas com seus tipos de dados e tamanhos. Para isso, clique com o botão direito do mouse

sobre a tabela “Categories”. Na caixa de diálogo que aparecerá, clique em Design Table.

Então será exibida a estrutura da tabela “Categories”.

9 de 332


A outra ferramenta que iremos utilizar é o Query Analyzer, ele é a interface que permite

a entrada de comandos Transact-SQL. O Transact-SQL ou apenas T-SQL é a linguagem

utilizada pelo SQL Server. O T-SQL é uma extensão da linguagem SQL, ou seja, um conjunto

de comandos adicionados à linguagem SQL que é padrão para todos os bancos de dados

relacionais. No próximo capítulo falaremos mais sobre o T-SQL e a linguagem SQL.

Para abrir o Query Analyzer é preciso fornecer as credencias de logon, ou seja, informar

qual o servidor que deseja conectar e passar o usuário e a senha. Indique o nome ou o IP do

servidor onde está instalado o SQL Server. Caso o SQL Server esteja instalado localmente (na

mesma máquina que você está utilizando) não é necessário informar o nome do servidor.

Após efetuar o logon, o Query Analyzer irá se conectar ao servidor informado e ao

banco de dados default (geralmente é o master). Para conectar em outro banco de dados do

servidor, basta selecionar o banco desejado na caixa de seleção presente na parte superior da

tela. Observe a figura a seguir onde está sendo selecionado o banco de dados Northwind.

10 de 332


Na barra de títulos da janela de conexão do Query Analyzer você pode observar em que

servidor/banco de dados/usuário está em uso no momento.

Em nosso exemplo, estamos conectados no servidor “RODRIGO”, no banco de dados

“Northwind” e usando o usuário “sa”. O usuário sa é o usuário administrador do SQL Server,

o nome “sa” quer dizer “system administrator” ou “administrador do sistema”.

11 de 332


Para exemplificarmos o uso do Query Analyzer, vamos consultar as informações

contidas em na tabela do “Categories” do banco de dados Northwind como fizemos com o

Enterprise Manager. Para isso, digite o seguinte comando sem as aspas: “select * from

categories”. Em seguida clique em Execute Query ou pressione F5 no teclado para executar

o comando digitado.

Após executar o comando, serão exibidos os registros contidos na tabela Categories do

banco Northwind.

Para verificar a estrutura da tabela Categories através do Query Analyzer, digite o

comando “sp_help categories”. Não é preciso apagar o comando anterior, basta você

selecionar o comando que deseja executar e pressionar F5 ou clicar em Execute Query que o

Query Analyzer vai executar apenas o comando que estiver selecionado. Observe a figura

abaixo para visualizar a estrutura da tabela obtida através do comando executado.

12 de 332


Existem muitas outras coisas que podemos fazer através das ferramentas do SQL

Server 2000, no entanto este curso não tem o objetivo de dominar o SQL Server, mas apenas

ensinar o suficiente para a criação de uma aplicação de banco de dados com Delphi e SQL

Server. Para um conhecimento mais aprofundado do Microsoft SQL Server 2000, sugerimos o

livro de SQL Server 2000 do Júlio Battisti.

13 de 332


Modelagem de Dados

O SQL Server utiliza um tipo de banco de dados denominado banco de dados

relacional. Em bancos de dados relacionais, os dados são organizados na forma de

tabelas. As tabelas são organizadas agrupando dados sobre o mesmo assunto e contêm

colunas e linhas de informações. As tabelas então são relacionadas entre si pelo mecanismo de

banco de dados. Em geral, pode-se considerar um banco de dados como um conjunto de

dados relacionados. Antigamente, um banco de dados era normalmente apenas um arquivo,

por exemplo: “funcionarios.dbf, que continha uma única tabela de dados. Dentro do arquivo

funcionarios.dbf estavam colunas relacionando dados de funcionários como salário, data de

admissão, nome, cpf, matrícula e assim por diante. O arquivo continha uma linha para cada

pessoa na empresa, com valores correspondentes nas colunas apropriadas. Os índices,

utilizados para aumentar a velocidade dos dados, estavam em um arquivo separado.

No SQL Server, um banco de dados não está necessariamente associado a um arquivo

– ele é mais um conceito lógico baseado em uma coleção de objetos relacionados. Por

exemplo, um banco de dados no MSSQL não contém somente os dados, ele também contém a

estrutura do banco de dados, quaisquer índices, a segurança do banco e talvez outros objetos

como views e stored procedures.

Como podemos perceber, um banco de dados relacional é composto de diferentes tipos

de objetos. Alguns dos objetos mais comuns são os seguintes:

Tabelas: são os objetos que contêm os tipos de dados e os dados reais;

Colunas: são as partes da tabela que armazenam os dados. Cada coluna possui

um tipo de dado e estas devem ter um nome único.

Tipos de dados: são o tipo de armazenamento básico de seus dados. Existem

vários tipos de dados, como caractere, data e numérico.

Linhas: são os registros da tabela, ou seja, são as ocorrências dos dados. Cada

linha é composta pelas colunas da tabela.

Chaves primárias: embora não sejam objetos propriamente ditos, são

essenciais para os bancos de dados relacionais. Elas impõem a unicidade entre

linhas, fornecendo uma maneira de identificar unicamente cada item

armazenado na tabela.

Chaves estrangeiras: são uma ou mais colunas que referenciam a chave

primária de outras tabelas. O MSSQL utiliza chaves primárias e estrangeiras para

relacionar dados entre si a partir de tabelas separadas quando as consultas são

realizadas.

Veja o diagrama a seguir para entender melhor estes conceitos:

14 de 332


Acima estão representadas duas tabelas: Departamentos e Funcionarios. Cada

tabela possui um conjunto de colunas e cada coluna possui um tipo de dados.

A tabela Departamentos possui duas colunas: codigo_departamento e nome. A

coluna codigo_departamento é do tipo int (int é o tipo de dados para armazenar valores

numéricos inteiros no SQL Server). A coluna nome é do tipo varchar (varchar é o tipo de

dados para armazenar caracteres no SQL Server) e possui um tamanho máximo de 30

caracteres, ou seja, se alguém tentar inserir um departamento cujo nome tenha mais de 30

letras ou números não irá conseguir. No diagrama também podemos perceber que a coluna

codigo_departamento da tabela Departamentos está destacada, isto significa que esta coluna é

a chave primária desta tabela. Esta chave primária garantirá que não existirão

departamentos com o mesmo código.

A tabela Funcionarios também possui colunas de diversos tipos de dados, como por

exemplo, a coluna salario que é do tipo money (money é o tipo de dados para armazenar

valores monetários no SQL Server). A chave primária da tabela Funcionarios é a coluna

matricula que servirá para identificar unicamente cada funcionário.

Observe que existe um relacionamento entre as tabelas Departamentos e Funcionarios,

pois cada funcionário deve pertencer a um departamento. Este relacionamento ocorre através

da coluna codigo_departamento que está na tabela Funcionarios. Esta coluna diz a que

departamento o funcionário pertence, ou seja, ela é uma referência à coluna

codigo_departamento da tabela Departamentos. Sendo assim, podemos afirmar que a coluna

codigo_departamento da tabela Funcionarios é uma chave estrangeira. A chave estrangeira

garantirá que não existirão funcionários sem departamentos, ou o que chamamos de registros

órfãos. Este relacionamento é do tipo 1 para N (ou um-para-muitos), pois cada departamento

pode possuir 1 ou mais funcionários e cada funcionário só pode pertencer a 1 departamento.

A modelagem de dados consiste basicamente em organizar os dados em tabelas

relacionadas. É muito importante definir e criar um diagrama ou modelo de dados para que

você possa projetar e identificar possíveis falhas em sua estrutura de armazenamento de

dados. Evidentemente, tabelas bem projetadas são essenciais para o sucesso dos bancos de

dados.

15 de 332


A título de exercício, imagine a seguinte situação: Em uma determinada rodoviária

existem diversas empresas de ônibus. Todos os ônibus possuem um motorista e um trajeto

diferente. O administrador desta rodoviária precisa de um sistema que cadastre as empresas,

os ônibus e os motoristas. Este sistema deve armazenar o nome e o código de cada empresa,

o número, a empresa, o motorista e o trajeto de cada ônibus e o nome, número, idade, sexo e

salário de cada motorista.

Com base nas informações acima, iremos criar um modelo de dados que atenda às

necessidades da rodoviária.

Antes de iniciar o desenho do diagrama, precisamos identificar as entidades, os

atributos e os relacionamentos envolvidos no contexto do sistema.

As entidades são as pessoas, objetos, bens, produtos ou serviços que fazem parte do

negócio da aplicação. Podemos então perceber que as entidades neste caso serão: as

empresas, os ônibus e os motoristas.

Os atributos são as informações ou características de cada entidade. Por exemplo, os

atributos da entidade empresas são: código e nome; enquanto os atributos da entidade

motorista são: nome, número, idade, sexo e salário.

Os relacionamentos, como o próprio nome diz, são as relações entre entidades. Por

exemplo, precisamos saber qual é o motorista de cada ônibus e a que empresa o ônibus

pertence. Estes relacionamentos dão origem a novos atributos que identificam a dependência

de uma entidade. No caso da entidade ônibus, será preciso dois novos atributos, um para

identificar o motorista e outro para identificar a empresa. Com isto, para cadastrar um ônibus

será necessário primeiro cadastrar a empresa e o motorista.

As entidades serão as tabelas e os atributos serão as colunas das tabelas. Os

relacionamentos serão as colunas que impõem a relação entre as tabelas e consequentemente

a integridade dos dados.

Sendo assim, criamos o seguinte modelo de dados:

Como em quase tudo, o planejamento e o projeto são a parte mais chata. Entretanto,

esta fase é fundamental para o sucesso de uma boa aplicação.

16 de 332


Vamos agora implementar o modelo de dados que acabamos de construir, ou seja,

vamos criar fisicamente as tabelas em um banco de dados do SQL Server. Abra o Enterprise

Manager para podermos criar nossas tabelas. Vamos criar um novo Banco de Dados

exclusivamente para este “sistema” da rodoviária. Para isto, expanda o ícone do servidor e

clique com o botão direito do mouse sobre a opção Databases. Na caixa de diálogo que

surgirá, clique em New Database...

Em seguida, será exibida a janela Database Properties. Preencha a caixa de texto

Name com o nome do novo banco de dados, em nosso caso: “Rodoviaria” (sem aspas). Clique

em OK para criar o novo Banco de Dados.

Obs.: O nome de um banco de dados, assim como de tabelas, colunas e outros objetos

do SQL Server, não deve possuir caracteres especiais, acentos ou espaços.

17 de 332


Após criar o banco de dados Rodoviaria, acesse a seção Tables para criarmos as

tabelas do modelo de dados. Você perceberá que já existirão outras tabelas criadas no Banco

de Dados Rodoviaria. Estas tabelas “sys_alguma_coisa” são para uso exclusivo do SQL Server,

portanto, ignore-as. Clique com o botão direito sobre a opção Tables e em seguida em New

Table...

Será exibida uma tela para criarmos a estrutura da nova tabela. Vamos criar primeiro a

tabela “Empresas”, para isso basta seguir as especificações do modelo que criamos

anteriormente. Digite o nome da primeira coluna da tabela Empresas que, segundo nosso

modelo, é “cod_empresa”. Em Data Type escolha o tipo de dado “int” e em seguida clique no

ícone que possui a figura de uma chave para especificar que esta coluna é a chave primária

desta tabela.

O tamanho de uma coluna do tipo int é por padrão igual a 4 e não pode ser alterado.

Este 4 não representa a quantidade de algarismos que poderão ser armazenados e sim a

quantidade de bytes em disco que esta coluna pode ocupar. O tipo int suporta números

inteiros positivos ou negativos que vão de -2.147.483.657 à +2.147.483.657, ou seja, dá para

armazenar muitos números nesta coluna.

Preencha agora o nome da segunda coluna da tabela Empresas: “nome”. Em Data

Type selecione o tipo varchar e defina o tamanho máximo de 30 caracteres em Length.

Diferentemente do tipo int, o tamanho de uma coluna do tipo varchar especifica a quantidade

máxima de caracteres permitidos nesta coluna. Desmarque a opção Allow Nulls (Permitir

nulo) da coluna “nome”, pois esta coluna deve ter preenchimento obrigatório. A coluna

“cod_empresa” também é obrigatória, mais como já definimos que ela é chave primária,

18 de 332


automaticamente o SQL Server desmarca a opção Allow Nulls, pois a chave primária sempre

é obrigatória. Com isto, criamos a estrutura da tabela “Empresas” de acordo com o que foi

especificado no modelo de dados.

Só falta definir o nome da tabela, para isto clique sobre o ícone que possui a figura de

um disquete. Esta opção serve para salvar as alterações feitas e para definir o nome da tabela

quando isto ainda não foi feito. Obviamente, salve a tabela com o nome: Empresas.

Pronto, a tabela foi criada! Feche a janela de edição e você verá a nova tabela na lista

de tabelas do banco de dados Rodoviaria.

Caso você precise alterar ou corrigir alguma coisa na estrutura da tabela, basta clicar

sobre ela com o botão direito e em seguida clicar em Design Table.

19 de 332


Você deve ter percebido que fica um pouco confuso visualizar nossa tabela entre um

monte de tabelas de sistema do SQL Server. Caso você deseje que estas tabelas do SQL

Server não sejam exibidas, faça o seguinte:

Clique com o botão direito do mouse sobre a opção que representa seu servidor e

depois clique em “Edit SQL Server Registration properties...”.

Na janela de propriedades, desmarque a opção: “Show system databases and

system objects” e clique em OK. Isto fará com que todos os databases e objetos de sistema

do SQL Server não sejam exibidos no Enterprise Manager tornando a tela bem mais “limpa”.

Prosseguindo com a construção das tabelas de nosso modelo de dados, vamos agora

criar a tabela “Motoristas”.

20 de 332


Clique com o botão direito sobre a opção Tables do banco de dados Rodoviaria e em

seguida em New Table...

Crie a estrutura da tabela “Motoristas” seguindo as especificações do modelo de dados

assim como fizemos com a tabela “Empresas”. Preencha corretamente os nomes das colunas e

selecione os respectivos tipos de dados. Não esqueça de definir o tamanho de 40 caracteres

para a coluna “nome” e de especificar a coluna “num_motorista” como chave primária da

tabela. A coluna “sexo” possui um tamanho máximo de 1 caractere, pois iremos armazenar

apenas “M” ou “F”. Após criar a estrutura, salve a tabela como nome “Motoristas”.

A próxima (e última) tabela que iremos criar é a tabela “Onibus”. Deixamos esta tabela

por último pelo simples fato dela “depender” das outras duas, ou seja, ela possui chave

estrangeira para as tabelas “Empresas” e “Onibus”. Nós poderíamos ter criado ela antes das

outras, só que depois teríamos que editá-la para referenciar as chaves estrangeiras. Assim,

com as outras tabelas já criadas, iremos fazer tudo de uma vez.

Novamente clique com o botão direito sobre a opção Tables do banco de dados

Rodoviaria e em seguida em New Table... Preencha os campos de acordo com o modelo de

dados.

Após preencher os campos, salve a tabela como “Onibus”, mas deixe a janela de edição

aberta para que possamos configurar as chaves estrangeiras. Clique sobre a opção “Table and

Index Properties” que está representada através de um ícone com uma figura de uma mão

segurando um pedaço de papel.

Na janela que surgirá, selecione a guia “Relationships” (Relacionamentos).

21 de 332


Nesta tela é que iremos criar nossas chaves estrangeiras. Só para lembrar: uma chave

estrangeira é uma coluna que “aponta” para outra coluna de uma outra tabela. A chave

estrangeira somente pode apontar para uma coluna que seja chave primária ou que possua

uma chave única (este conceito não será abordado neste curso). O termo “Chave Primária” é

mais conhecido como “Primary Key” ou apenas “PK” e o termo “Chave Estrangeira” é

conhecido como “Foreign Key” ou simplesmente “FK”.

Para criar nossa primeira chave estrangeira, clique sobre o botão “New”. Na caixa de

seleção “Primary key table”, selecione a tabela Empresas e logo abaixo selecione a coluna

“cod_empresa”. Na caixa de seleção “Foreign key table”, selecione a tabela “Onibus” e em

seguida selecione a coluna “cod_empresa”. O que acabamos de fazer foi: dizer para o SQL

Server que a coluna “cod_empresa” da tabela Onibus está ligada à coluna “cod_empresa” da

tabela “Empresas”.

Veja abaixo como ficou a tela após a configuração:

22 de 332


Agora vamos criar a chave estrangeira para a tabela “Motoristas”. Clique novamente

sobre o botão “New” e repita o procedimento apontando a coluna “num_motorista” da tabela

“Onibus” para a coluna “num_motorista” da coluna “Motoristas”.

23 de 332


Clique sobre o botão “Fechar” e depois salve as alterações clicando sobre o botão com o

ícone de um disquete. O SQL Server informará que as alterações efetuadas afetarão outras

tabelas.

Clique em “Yes” e Pronto! As chaves estrangeiras foram configuradas com sucesso!

Nós podemos ter certeza de que os relacionamentos foram criados corretamente

através da opção Diagrams do banco de dados Rodoviaria. Nesta opção podemos criar

diagramas com as tabelas existentes no banco de dados. Neste diagrama o SQL Server exibe o

relacionamento existente entre as tabelas. Clique com o botão direito do mouse sobre a opção

Diagrams do banco de dados Rodoviaria e em seguida clique sobre a opção New Database

Diagram...

Será exibida a tela do assistente de criação de diagramas do SQL Server.

24 de 332


Clique em Avançar para exibir a próxima tela onde iremos selecionar as tabelas que

farão parte do nosso diagrama.

Selecione todas as tabelas e clique no botão “Add >”. Em seguida, clique em Avançar e

na tela seguinte em Concluir. Então o SQL Server montará o diagrama com as tabelas e seus

respectivos relacionamentos.

25 de 332


Com base no diagrama montado pelo SQL Server podemos concluir que criamos as

tabelas e os relacionamentos corretamente de acordo com nosso modelo de dados.

Modelo de dados

Diagrama gerado pelo SQL Server

26 de 332


Instrução SELECT

No capítulo anterior aprendemos um pouco sobre modelagem de dados e vimos como

criar tabelas e relacionamento. Agora iremos aprender como recuperar dados de uma tabela

ou de várias tabelas através da famosa instrução SELECT.

O comando SELECT faz parte da linguagem SQL (Structured Query Language ou

Linguagem de Consulta Estruturada) que é o “idioma” padrão para todos os Sistemas

Gerenciadores de Banco de Dados (SGBD’s), ou seja, é a língua falada por todos os bancos de

dados. Não confunda “SQL” com “SQL Server”, pois “SQL” é a linguagem dos bancos de dados

em geral, enquanto “SQL Server” é o software da Microsoft. A linguagem SQL é utilizada por

todos os SGBD’s do mercado como Oracle, DB2, SYBASE, Interbase, MySQL, Postgree e é

claro, o SQL Server.

Entretanto, cada um destes softwares adiciona à linguagem SQL um conjunto de

funcionalidades que lhe são particulares. Em virtude disso, cada empresa cria uma nova

linguagem a partir da linguagem SQL padrão. Por exemplo, a linguagem para manipulação de

banco de dados no SQL Server é o Transact-SQL ou simplesmente T-SQL, já a linguagem do

Oracle é o PL/SQL. Apenas para ilustrar esta situação, veja abaixo como seriam os comandos

para recuperar os primeiros 10 registros de uma tabela no SQL Server e no Oracle.

SQL Server (T-SQL): “SELECT TOP 10 * FROM TABELA”

Oracle (PL/SQL): “SELECT * FROM TABELA WHERE ROWNUM <= 10”

Se quiséssemos simplesmente recuperar todos os registros da tabela, o comando seria

o mesmo tanto para o SQL Server quanto para o Oracle, pois utilizaríamos apenas o SQL

padrão:

“SELECT * FROM TABELA”

De uma forma geral, se você conhecer bem a linguagem SQL padrão, não terá

dificuldades em utilizar um ou outro SGBD, você apenas precisará aprender as funções

específicas de cada software.

A principal ferramenta do SQL Server para trabalharmos com a linguagem SQL é o

Query Analyzer que conhecemos anteriormente neste curso. Portanto, execute-o para que

iniciemos nosso aprendizado em SQL.

A instrução SELECT é o comando utilizado para recuperar dados de uma ou mais

tabelas de um banco de dados. Através deste comando é que conseguimos visualizar tudo o

que está gravado no banco de dados.

27 de 332


Utilizaremos o banco de dados Rodoviaria (que acabamos de criar) como cobaia em

nossos estudos. Mas antes de começarmos, precisamos alimentar as tabelas do banco

Rodoviaria, pois as mesmas estão vazias e tabelas vazias não servem para muita coisa.

Selecione o banco de dados Rodoviaria na caixa de seleção de banco de dados e em

seguida digite as linhas abaixo:

INSERT INTO EMPRESAS VALUES (101,'FLORES');

INSERT INTO EMPRESAS VALUES (102,'REGINAS');

INSERT INTO EMPRESAS VALUES (103,'MASTER');

INSERT INTO EMPRESAS VALUES (104,'RUBANIL');

INSERT INTO EMPRESAS VALUES (105,'REAL');

INSERT INTO MOTORISTAS VALUES (341,'Paulo Roberto',35,'M',1200);

INSERT INTO MOTORISTAS VALUES (342,'Anderson Moraes',24,'M',1150);

INSERT INTO MOTORISTAS VALUES (343,'Fernando Santana',28,'M',1170);

INSERT INTO MOTORISTAS VALUES (344,'Carlos Paiva',40,'M',1320);

INSERT INTO MOTORISTAS VALUES (345,'Alberto Araújo',25,'M',890);

INSERT INTO MOTORISTAS VALUES (346,'Jorge Luiz',43,'M',1400);

INSERT INTO MOTORISTAS VALUES (347,'Maria Padilha',29,'F',900);

INSERT INTO MOTORISTAS VALUES (348,'Claudia da Silva',32,'F',1000);

INSERT INTO MOTORISTAS VALUES (349,'Jeferson Gomes',30,'M',1380);

INSERT INTO MOTORISTAS VALUES (350,'Felipe Castro',19,'M',650);

INSERT INTO ONIBUS VALUES (2451,101,341,'Nova Iguaçu x Caxias');

INSERT INTO ONIBUS VALUES (2452,101,342,'São João X Praça XV');

INSERT INTO ONIBUS VALUES (2453,101,343,'Mesquita X Praça Mauá');

INSERT INTO ONIBUS VALUES (4213,102,344,'Pavuna X Castelo');

INSERT INTO ONIBUS VALUES (4214,102,345,'Nova Iguaçu X Pavuna');

INSERT INTO ONIBUS VALUES (4215,102,346,'Caxias X São João');

INSERT INTO ONIBUS VALUES (4216,102,347,'Nilópolis X Caxias');

INSERT INTO ONIBUS VALUES (5987,103,348,'Queimados X Pavuna');

INSERT INTO ONIBUS VALUES (5988,103,349,'Campo Grande X Caxias');

INSERT INTO ONIBUS VALUES (1702,104,350,'São João X Itaguaí');

Digite todas as linhas mesmo sem entender o que está digitando. Estas linhas são

comandos de inserção de dados através da instrução INSERT que iremos aprender mais

adiante neste curso.

Após digitar os comandos acima, sua tela deve ficar semelhante à exibida na figura a

seguir:

28 de 332


Quando reunimos um conjunto de comandos SQL (como o que acabamos de fazer),

damos o nome de script. Um script de banco de dados nada mais é do que uma seqüência de

comandos SQL que serão executados todos de uma só vez.

Para executar os comandos que acabamos de digitar, basta clicar sobre o botão

“Execute” ou pressionar F5 no teclado.

Após executar o script, o Query Analyzer exibirá o painel de resultados. Se você digitou

corretamente as linhas acima, deverá ser exibido o texto “(1 row(s) affected)” para cada

INSERT realizado.

29 de 332


No Query Analyzer você pode salvar seu script em arquivo do tipo texto com a extensão

“.sql”. Para salvar o script recém criado, clique em File > Save.

Defina um nome para o arquivo e onde o mesmo será gravado, em seguida clique em

Salvar.

É muito interessante você salvar seus scripts, pois nunca se sabe quando vai precisar

deles novamente. Para abrir um script gravado, basta clicar em File > Open, selecionar o

arquivo desejado e clicar em Abrir.

30 de 332


O Query Analyzer também permite que você trabalhe com várias janelas

simultaneamente. Você pode abrir novas janelas através da opção New Query.

Vamos afinal, conhecer o comando SELECT. Feche a janela do script que executamos

para popular o banco de dados Rodoviaria e deixe apenas uma janela limpa aberta.

A sintaxe básica do comando SELECT é a seguinte:

Por exemplo, para recuperar o nome dos motoristas o comando seria:

SELECT NOME FROM MOTORISTAS

31 de 332


Digite o comando acima no Query Analyzer e clique em “Execute Query” ou pressione

F5 no teclado. Veja que o SQL Server retorna todos os nomes cadastrados na tabela

Motoristas.

OBS.: Os comandos SQL podem ser escritos em letras maiúsculas ou minúsculas, pois

o SQL Server não se importa com isso. Os comandos estão em letras maiúsculas neste livro

apenas por uma questão de preferência.

Para recuperar mais de uma coluna da tabela você deve digitar o nome de cada coluna

separado por vírgula. Por exemplo, para obter o nome, a idade e o sexo dos motoristas, o

comando seria o seguinte:

SELECT NOME,IDADE,SEXO FROM MOTORISTAS

O resultado do comando acima é apresentado abaixo:

32 de 332


Como podemos perceber, o comando SELECT é muito fácil de entender. Você

praticamente escreve (em inglês) o que você quer e o SQL Server te entrega. Desta forma, o

comando que acabamos de executar “SELECT NOME,IDADE,SEXO FROM MOTORISTAS” pode

facilmente ser lido assim: “Selecione as colunas nome, idade e sexo da tabela motoristas”.

Para selecionar todas as colunas de uma tabela, você pode digitar o nome de cada uma

delas separado por vírgula ou simplesmente colocar um asterisco “*” no lugar dos nomes das

colunas. Por exemplo, para obter todas as colunas da tabela Motoristas, o comando seria o

seguinte:

SELECT NUM_MOTORISTA, NOME, IDADE, SEXO, SALARIO FROM MOTORISTAS

Entretanto, poderíamos obter o mesmo resultado com o seguinte comando:

SELECT * FROM MOTORISTAS

O símbolo asterisco (*) representa todas as colunas de uma tabela, sendo assim,

sempre que quiser obter todas as colunas de uma tabela basta colocar um asterisco ao invés

de digitar o nome de todas as colunas.

Você pode atribuir um título para cada coluna retornada em sua consulta caso não

deseje que título seja o próprio nome da coluna. Por exemplo, se ao invés de aparecer

“num_motorista” você quiser que apareça “Número do Motorista”, você então deverá utilizar

um apelido. Exemplo:

33 de 332


SELECT NUM_MOTORISTA AS 'NÚMERO DO MOTORISTA', NOME FROM MOTORISTAS

Você pode atribuir um apelido para cada coluna da consulta, isto é bem interessante

para gerar relatórios com títulos de coluna mais descritivos. Abaixo mais um exemplo de

utilização de apelidos.

34 de 332


Além da sintaxe básica da instrução SELECT que recupera todos os registros de uma

tabela, podemos utilizar a cláusula WHERE para restringir o resultado desejado. Por exemplo,

o comando “SELECT NOME FROM MOTORISTAS” devolve a coluna nome de todos os registros

existentes na tabela Motoristas e se quiséssemos obter somente o nome dos motoristas que

são do sexo Masculino, o comando seria:

SELECT NOME FROM MOTORISTAS WHERE SEXO = 'M'

O comando acima pode ser lido desta forma: “Obtenha o nome dos motoristas onde o

sexo seja igual a ‘M’”. Para obter o nome dos motoristas que sejam do sexo Feminino basta

alterar o valor M para F:

SELECT NOME FROM MOTORISTAS WHERE SEXO = 'F'

35 de 332


Na cláusula WHERE podemos restringir o resultado desejado impondo uma condição

para o SQL Server onde ele só trará os registros que atendam à condição imposta. Caso não

existam registros que atendam à condição imposta na cláusula WHERE o resultado será nulo.

Exemplo: Execute o comando abaixo que tenta obter o nome dos motoristas que possuem

sexo igual a B. Obviamente, não existe sexo igual a B e portanto o SQL Server não trará

resultado.

A cláusula WHERE permite que você defina mais de uma restrição, para isto basta

separar cada condição através do operador “AND”. Por exemplo, para obter os motoristas que

sejam do sexo masculino e tenham mais de 30 anos, o comando seria o seguinte:

SELECT * FROM MOTORISTAS WHERE SEXO = 'M' AND IDADE > 30

Você também pode restringir o resultado de uma consulta utilizando o operador LIKE.

Este operador permite que você crie uma condição parcial como aqueles casos em que não é

possível utilizar os operadores “=” (igual) ou “<>” (diferente). Por exemplo, obter os

motoristas cujos nomes comecem pela letra “A”. O operador LIKE é utilizado juntamente com

o operador “%” (percentagem). O comando então seria:

36 de 332


SELECT * FROM MOTORISTAS WHERE NOME LIKE 'A%'

Para obter os motoristas cujo último nome seja “Silva”, o comando seria:

SELECT * FROM MOTORISTAS WHERE NOME LIKE '%Silva'

Outro exemplo de utilização do operador LIKE: Obter os ônibus que possuam o texto

“São João” na coluna trajeto, ou seja, os ônibus que passam por São João. O comando seria:

SELECT * FROM ONIBUS WHERE TRAJETO LIKE '%São João%'

37 de 332


O SQL Server também permite que você ordene o resultado de uma consulta através da

cláusula ORDER BY. Para ordenar o resultado de consulta basta incluir a cláusula ORDER BY

e o nome da coluna no fim do comando SELECT. O ORDER BY sempre deve ser a última

cláusula de uma instrução SELECT. Por exemplo, para obter todos os motoristas ordenando o

resultado pelo nome:

SELECT * FROM MOTORISTAS ORDER BY NOME

A cláusula ORDER BY ordena o resultado por ordem alfabética caso a coluna seja do

tipo texto ou caractere, se a coluna for numérica, o ORDER BY ordenará do menor para o

maior. Você também pode definir se deseja ordenar em ordem ascendente ou descente, por

exemplo, ordenar os funcionários por nome em ordem descendente seria:

SELECT * FROM MOTORISTAS ORDER BY NOME DESC

Para ordenar em ordem ascendente seria:

SELECT * FROM MOTORISTAS ORDER BY NOME ASC

38 de 332


OBS.: Se você não informar os parâmetros DESC ou ASC para a cláusula ORDER BY, o

SQL Server assume o parâmetro ASC como padrão, ou seja, se você colocar ASC ou não

colocar nada, dá no mesmo.

Para exemplificar um pouco mais, imagine que você precise gerar uma relação de todos

os motoristas da Rodoviária ordenando-os do maior para o menor salário. O SELECT seria o

seguinte:

SELECT * FROM MOTORISTAS ORDER BY SALARIO DESC

Você também pode ordenar por mais de uma coluna, por exemplo, ordenar por sexo

em seguida por nome e depois por salário.

39 de 332


A linguagem SQL também fornece várias funções que são muito úteis no dia-a-dia do

desenvolvimento de aplicações. Aqui iremos conhecer apenas as que serão necessárias a este

curso.

Algumas funções SQL:

COUNT: Retorna a quantidade de registros;

MAX: Retorna o maior valor da coluna informada;

MIN: Retorna o menor valor da coluna informada;

SUM: Soma todos os valores da coluna informada;

AVG: Retorna a média de valores da coluna informada;

Vamos então exemplificar o uso de cada uma.

Exemplo COUNT - Quantidade de empresas da rodoviaria:

Exemplo COUNT - Quantidade de motoristas do sexo feminino:

40 de 332


Exemplo MAX - Maior salário dos motoristas:

Exemplo MAX - Maior idade dos motoristas:

Exemplo MIN - Menor idade e menor salário dos motoristas:

41 de 332


Exemplo SUM – Obter o somatório de todos os salários dos motoristas:

Exemplo AVG – Obter a média de idade dos motoristas:

Para ter um melhor aproveitamento das funções SQL disponíveis no SQL Server, é

importante conhecer a cláusula GROUP BY. A cláusula GROUP BY tem por finalidade agrupar o

resultado de um consulta. Vamos ver logo um exemplo de utilização do GROUP BY para ilustrar

sua funcionalidade. Imagine que você precisasse emitir um relatório que informasse a

quantidade de motoristas do sexo masculino e sexo feminino. Talvez você possa pensar que

com dois comandos SQL você teria esta informação, exemplo:

SELECT COUNT(*) AS 'HOMENS' FROM MOTORISTAS WHERE SEXO = 'M'

SELECT COUNT(*) AS 'MULHERES' FROM MOTORISTAS WHERE SEXO = 'F'

42 de 332


Os comandos acima irão trazer a quantidade de motoristas do sexo masculino e

feminino respectivamente. Entretanto existe uma maneira mais “inteligente” de fazer isso, e é

através do GROUP BY que permitirá trazer as informações desejadas num único SELECT.

Exemplo:

SELECT SEXO, COUNT(*) AS 'QTD' FROM MOTORISTAS GROUP BY SEXO

“Traduzindo” o comando acima: SELECIONE O SEXO E QUANTIDADE DE REGISTROS DA

TABELA MOTORISTAS AGRUPANDO O RESULTADO PELA COLUNA SEXO.

Outro exemplo de uso do GROUP BY: relatório de média salarial dos motoristas por

sexo, ou seja, queremos saber em média quem ganha mais: homem ou mulher?

No decorrer do curso veremos mais exemplos de utilização da cláusula GROUP BY.

43 de 332


Um outro assunto muito importante a ser abordado no aprendizado da instrução

SELECT é a correlação de dados, os famosos JOINS. No capítulo anterior vimos como criar

tabelas e seus relacionamentos, pois agora, vamos ver como recuperar dados de duas ou mais

tabelas usando os relacionamentos existentes entre elas. Quando relacionamos uma tabela

com outra numa instrução SELECT, dizemos que estamos fazendo um JOIN entre tabelas.

Para fazer JOINS de tabelas, você deve fazer uma comparação de uma ou mais colunas

de uma tabela com uma ou mais colunas de uma outra tabela. Para este trabalho usaremos a

instrução INNER JOIN. Vamos direto para a aplicação prática deste conceito.

Com base em nosso modelo de dados...

A coluna “cod_empresa” da tabela “Onibus” faz referência à coluna “cod_empresa” da

tabela “Empresas”. Então, para saber o nome da empresa à qual cada ônibus pertence,

precisaremos fazer um JOIN entre a tabela “Empresas” e a tabela “Ônibus”. O comando seria o

seguinte:

SELECT ONIBUS.NUM_ONIBUS AS 'ÔNIBUS', EMPRESAS.NOME AS 'EMPRESA'

FROM ONIBUS INNER JOIN EMPRESAS

ON ONIBUS.COD_EMPRESA = EMPRESAS.COD_EMPRESA

44 de 332


Traduzindo o comando acima: “SELECIONE A COLUNA NUM_ONIBUS DA TABELA

ONIBUS E A COLUNA NOME DA TABELA EMPRESAS FAZENDO JOIN DA TABELA ONIBUS COM A

TABELA EMPRESAS ONDE A COLUNA COD_EMPRESA DA TABELA ONIBUS SEJA IGUAL À

COLUNA COD_EMPRESA DA TABELA EMPRESAS”.

Você deve ter percebido que quando temos mais de uma tabela numa instrução

SELECT, devemos referenciar cada coluna dizendo à que tabela ela pertence, ou seja, devemos

informar a “tabela.coluna” que queremos que seja retornado no SELECT.

Um outro exemplo, para conhecer o nome do motorista de cada ônibus, o SELECT seria

o seguinte:

SELECT ONIBUS.NUM_ONIBUS AS 'ÔNIBUS', MOTORISTAS.NOME AS 'MOTORISTA'

FROM ONIBUS

INNER JOIN MOTORISTAS ON ONIBUS.NUM_MOTORISTA = MOTORISTAS.NUM_MOTORISTA

45 de 332


Já para recuperar o nome do motorista e o nome da empresa de cada ônibus, será

preciso fazer JOIN da tabela Onibus com as tabelas Motoristas e Empresas, comparando os

campos que implementam os relacionamentos. O SELECT seria:

SELECT ONIBUS.NUM_ONIBUS, MOTORISTAS.NOME AS 'MOTORISTA' ,EMPRESAS.NOME AS 'EMPRESA'

FROM ONIBUS

INNER JOIN MOTORISTAS ON ONIBUS.NUM_MOTORISTA = MOTORISTAS.NUM_MOTORISTA

INNER JOIN EMPRESAS ON ONIBUS.COD_EMPRESA = EMPRESAS.COD_EMPRESA

46 de 332


Instrução INSERT

A instrução INSERT, como seu próprio nome indica, tem a finalidade de inserir registros

em uma tabela. É através do comando INSERT que podemos cadastrar novos registros e

alimentar as tabelas de nosso banco de dados.

A sintaxe da instrução INSERT é a seguinte:

Entendo a sintaxe acima: as palavras INSERT e INTO são fixas, portanto você sempre

vai digitá-las. Em seguida vem o nome da tabela que você vai inserir um novo registro. Após o

nome da tabela, você deve especificar o nome de cada coluna que você vai preencher entre

parênteses “( )”. Caso você vá preencher todas as colunas da tabela e na mesma ordem em

que elas estão na tabela, então não é necessário digitar o nome das colunas, caso contrário

você deve digitar apenas o nome das colunas que você vai preencher. Após o nome das

colunas que serão preenchidas, vem outra palavra fixa: VALUES e em seguida você deve

digitar os valores que preencherão as colunas informadas na lista de colunas digitadas.

Exemplo de um comando INSERT para inserir um novo motorista na tabela Motoristas:

INSERT INTO MOTORISTAS (NUM_MOTORISTA, NOME, IDADE, SEXO, SALARIO)

VALUES (351,'José Antônio',32,'M',1150)

47 de 332


Traduzindo o comando acima: “INSIRA NA TABELA MOTORISTAS PARA OS CAMPOS

NUM_MOTORISTA, NOME, IDADE, SEXO E SALARIO OS SEGUINTES VALORES: 351, José

Antônio, 32, M e 115”.

OBS.: Assim como no Delphi, você deve colocar tudo o que for texto entre aspas

simples “ ‘ ”. Veja que as colunas nome e sexo que são do tipo varchar e por isso os valores

‘José Carlos’ e ‘M’ foram passadas entre aspas simples para que o SQL Server entenda que

estes valores são do tipo texto e não gere um erro de incompatibilidade de tipos de dados.

Como neste exemplo estamos preenchendo todas as colunas da tabela Motoristas,

também poderíamos inserir um novo registro sem precisar referenciar o nome das colunas,

bastando apenas passar todos os valores após a palavra VALUES.

Exemplo:

INSERT INTO MOTORISTAS VALUES (352,'Débora dos Santos',35,'F',1000)

Observe que no comando acima não referenciamos as colunas que seriam preenchidas

uma vez que iríamos preencher todas elas.

É importante analisar as tabelas antes de efetuar qualquer inserção para que não haja

erros de integridade de dados. Por exemplo, vamos tentar inserir um novo registro na tabela

Onibus. Digite o comando abaixo e em seguida execute-o:

INSERT INTO ONIBUS VALUES (6258,106,351,'Pavuna X Méier')

48 de 332


Após executar o comando INSERT, o SQL Server retorna um erro de integridade de

dados informando que a instrução conflita com o relacionamento existente entre a tabela

Onibus e a tabela Empresas. Isto ocorreu porque tentamos inserir um ônibus de uma empresa

(106) que não está cadastrada na tabela Empresas. Para evitar este tipo de erro, devemos

sempre analisar o modelo de dados e checar se existem dependências que devem ser

atendidas antes de inserir qualquer coisa em uma tabela.

Antes de cadastrar este ônibus devemos então cadastrar a empresa que possui o código

106 ou então verificar se ele pertence a alguma outra empresa que já esteja cadastrada.

Vamos cadastrar a empresa 106 de nome Nilopolitana:

INSERT INTO EMPRESAS VALUES (106,'Nilopolitana')

49 de 332


Pronto, já podemos cadastrar o novo ônibus, pois a empresa já está cadastrada e o

motorista (351) também (se não iria dar erro novamente).

INSERT INTO ONIBUS VALUES (6258,106,351,'Pavuna X Méier')

50 de 332


Instrução UPDATE

A instrução UPDATE é utilizada para atualizar o valor de uma ou mais colunas de uma

tabela. Este comando tem a finalidade de substituir o valor existente em uma coluna por um

novo valor. A sintaxe básica é a seguinte:

Exemplo:

UPDATE MOTORISTAS SET IDADE = 40 WHERE NUM_MOTORISTA = 352

Traduzindo o comando acima: “ATUALIZE A TABELA MOTORISTAS ALTERANDO A

COLUNA IDADE PARA 40 ONDE A COLUNA NUM_MOTORISTA FOR IGUAL A 352”. Em outras

palavras este comando está alterando a idade do motorista 352 para 40 anos.

Para atualizar mais de uma coluna, basta especificar cada coluna separado-as por

vírgula, por exemplo, suponhamos que o ônibus que faz o trajeto Nilópolis X Caxias tenha sido

vendido para uma outra empresa e consequentemente terá outro motorista. O comando seria

o seguinte:

UPDATE ONIBUS SET COD_EMPRESA = 106, NUM_MOTORISTA = 352

WHERE TRAJETO = 'Nilópolis X Caxias'

51 de 332


A instrução acima está alterando o ônibus que faz o trajeto Nilópolis X Caxias

atualizando a coluna cod_empresa para 106 e a coluna num_motorista para 352.

É importante especificar com bastante critério a condição ou as condições presentes na

cláusula WHERE, pois se mais de um registro atender a condição, todos serão atualizados, e se

nenhum atender a condição, nenhum registro será atualizado.

Caso você não especifique uma condição utilizando a cláusula WHERE, todos os

registros da tabela em questão sofrerão a atualização. Isto não é muito comum, mas pode ser

que você precise atualizar todos os registros de uma tabela sem qualquer restrição. Imagine

que você precise executar uma instrução UPDATE que aumente o salário de todos os

motoristas em 10%. O comando UPDATE para esta situação seria o seguinte:

UPDATE MOTORISTAS SET SALARIO = SALARIO * 1.10

Observe que não impomos nenhuma condição através da cláusula WHERE, pois

realmente queríamos que todos os registros fossem atualizados. Nesta instrução estamos

52 de 332


atualizando a coluna Salário com o seu próprio valor multiplicado por 1.10, ou seja, estamos

aumentando cada salário em 10%.

OBS.: O Asterisco presente no comando acima é apenas o operador de multiplicação e

nada tem a ver com o asterisco utilizado para obter todas as colunas de uma tabela através da

instrução SELECT.

No decorrer do curso veremos mais exemplos da instrução UPDATE.

53 de 332


Instrução DELETE

Antes de iniciarmos o aprendizado sobre o uso da instrução DELETE, é importante

aprendermos o conceito de “transação”. Uma transação de banco de dados é uma unidade de

trabalho em que todas as instruções são processadas com sucesso ou nenhuma das instruções

é processada. As transações garantem que o trabalho que está sendo realizado será bem-

sucedido ou falhará completamente. Durante uma transação, nenhuma outra transação pode

modificar os dados até que você decida que as modificações serão definitivas.

Decidimos falar sobre transação aqui neste capítulo que é destinado a instrução DELETE

apenas para que possamos excluir registros “à vontade” e depois consigamos reverter todas as

exclusões sem que seja necessário inserir tudo novamente. Embora estejamos conhecendo o

conceito de transações neste capítulo, ele vale para todas as operações de modificação de

dados (INSERT, UPDATE e DELETE).

Em cada instrução que executamos está ocorrendo uma transação, mesmo que não

tenhamos conhecimento disso. Por exemplo, quando executamos um INSERT, o SQL Server

inicia uma transação automaticamente e tenta efetuar a inserção, caso a inserção seja

realizada com sucesso, ele confirma a alteração tornando-a definitiva, caso contrário, o SQL

Server encerra a transação sem efetuar o INSERT.

No script fictício abaixo, cada instrução SQL é uma transação separada. Se qualquer

uma das instruções falhar, ela não afetará as outras. Cada instrução é bem-sucedida ou falha

por inteiro, independentemente das outras instruções no script.

INSERT INTO TABELA VALUES (‘VALOR1’,’VALOR2’)

UPDATE TABELA SET COLUNA1 = VALOR2 WHERE COLUNA1 > 0

DELETE FROM TABELA WHERE COLUNA1 = VALOR1

Se você pensar em operações que são realizadas apenas com uma instrução SQL, como

por exemplo excluir um funcionário da lista de empregados de uma empresa, pode achar que

não tem muita importância trabalhar com transações. Entretanto, quando estamos

trabalhando com operações mais complexas como, por exemplo, pagamento de funcionário, a

simples operação de pagamento pode ser composta por várias instruções SQL que fazem

vários INSERT’S e UPDATE’S em várias tabelas para que um simples pagamento seja

realizado. Desta forma, o pagamento só poderá ser efetivado se todas as alterações forem

efetuadas com sucesso, senão todas as alterações devem ser desfeitas para que não haja

inconsistências num banco de dados.

54 de 332


Você pode controlar transações no SQL Server através das instruções:

BEGIN TRANSACTION: Inicia uma transação;

COMMIT TRANSACTION: efetiva as alterações;

ROLLBACK TRANSACTION: cancela todas as alterações.

Abaixo está um outro script fictício que utiliza o conceito de transações:

BEGIN TRANSACTION

INSERT INTO TABELA VALUES (‘VALOR1’,’VALOR2’)

UPDATE TABELA SET COLUNA1 = VALOR2 WHERE COLUNA1 > 0

DELETE FROM TABELA WHERE COLUNA1 = VALOR1

SE TODAS AS ALTERAÇÕES OCORRERAM COM SUCESSO ENTÃO

COMMIT TRANSACTION

SENÃO

ROLLBACK TRANSACTION

Obviamente, o script acima é só uma ilustração de tratamento de transações. Durante o

curso, iremos ver na prática com isso funciona através de uma aplicação em Delphi. Por hora,

basta conhecermos os comandos que iniciam, confirmam e cancelam uma transação.

Para que possamos excluir registros sem a preocupação de depois ter de inserir tudo de

novo, execute o comando abaixo antes de começar a excluir:

BEGIN TRANSACTION

A partir de agora, todas as instruções de modificação de dados só serão efetivadas após

um COMMIT TRANSACTION ou descartadas após um ROLLBACK TRANSACTION. Você

55 de 332


pode apagar o comando BEGIN TRANSACTION que acabou de executar para poder digitar os

DELETE’S que serão exemplificados neste capítulo. Mais atente para um detalhe, você deve

continuar na mesma janela que executou o BEGIN TRANSACTION pois a transação só é válida

para uma sessão e cada janela do Query Analyzer é uma sessão diferente.

A instrução DELETE, como o próprio nome sugere, tem por finalidade excluir registros

de uma tabela. Sua sintaxe básica é a seguinte:

Através do comando DELETE é possível excluir um ou mais registros dependendo da

condição, ou pode não excluir registro algum caso nenhum deles se encaixe na condição

imposta.

Exemplo de um comando DELETE:

DELETE FROM MOTORISTAS WHERE NUM_MOTORISTA = 347

Traduzindo o comando acima: “EXCLUA O REGISTRO DA TABELA MOTORISTAS ONDE A

COLUNA NUM_MOTORISTA FOR IGUAL A 347”.

Você pode verificar se o registro foi realmente excluído executando o seguinte SELECT:

SELECT * FROM MOTORISTAS ORDER BY NUM_MOTORISTA

Veja se no resultado aparece o motorista de número 347.

56 de 332


Após analisar o resultado acima, podemos ver que o registro foi excluído, entretanto

esta exclusão ainda não foi efetivada no banco de dados, pois iniciamos uma transação quando

executamos o comando BEGIN TRANSACTION. Execute agora o seguinte comando:

ROLLBACK TRANSACTION

O comando que acabamos de executar encerrou a transação que tínhamos iniciado

descartando a exclusão que fizemos. Para constatar isto, execute novamente o comando:

SELECT * FROM MOTORISTAS ORDER BY NUM_MOTORISTA

57 de 332


Veja que o registro que tinha sido excluído voltou a aparecer. Isto ocorreu porque

iniciamos uma transação e, após fazer a exclusão, encerramos a transação revertendo o

DELETE através da instrução ROLLBACK TRANSACTION. Se ao invés do ROLLBACK tivéssemos

executado um COMMIT TRANSACTION, a exclusão seria definitiva. O DELETE também seria

definitivo se tivéssemos executado o DELETE sem iniciar uma transação, pois o SQL Server

executaria uma transação automática.

Sendo assim, inicie outra transação executando o comando BEGIN TRANSACTION

para que possamos excluir registros e depois reverter todas as exclusões.

Quando executamos um DELETE temos que verificar se existe alguma dependência de

chave estrangeira na tabela em questão. Por exemplo, vamos tentar excluir a Empresa

“FLORES”:

58 de 332


Veja que após executar o comando, o SQL Server gera um erro de chave estrangeira,

pois estamos tentando excluir uma empresa que possui ônibus ligados a ela, ou seja, não

podemos excluir um registro “mãe” que possui registros “filhos”. Para excluir um registro

“mãe” devemos primeiro excluir os registros “filhos”.

Vamos então excluir todos os ônibus que pertencem a empresa FLORES que possui o

código 101:

Agora que excluímos os ônibus da empresa FLORES podemos então excluí-la:

O comando DELETE também pode ser utilizado para limpar uma tabela, para isto basta

executar a instrução sem utilizar a cláusula WHERE. Exemplo:

DELETE FROM ONIBUS

59 de 332


O DELETE executado acima excluiu todos os registros da tabela Onibus sem filtrar

qualquer condição porque não utilizamos a cláusula WHERE, ou seja, o comando limpou a

tabela.

Pronto! Acabamos o capítulo sobre a instrução DELETE e para desfazer todas as

exclusões feitas, execute o comando ROLLBACK TRANSACTION.

60 de 332


Módulo 2:

Conectando o Delphi ao SQL Server

Delphi disponibiliza um conjunto de objetos para manipulação de

banco de dados. Aqui veremos todos os objetos que serão

necessários para a criação de uma aplicação baseada em um banco

de dados Cliente/Servidor. Veremos como fazer a conexão como o servidor,

recuperar informações e modificar os dados utilizando os comandos SQL

aprendidos no módulo anterior. Além disso, veremos como prevenir e tratar

erros de banco de dados para que a aplicação não aborte o processo e esteja

preparada para todos os possíveis erros.

O

61 de 332


Componentes de Acesso a Dados

O Delphi disponibiliza um conjunto de objetos para acesso e manipulação de banco de

dados. O suporte do Delphi a aplicativos de banco de dados é um dos principais recursos do

ambiente de programação. Nas primeiras versões do Delphi, somente era possível acessar um

banco de dados através do BDE (Borland Database Engine). A versão 7 que utilizamos neste

curso incluem o ADO, os componentes nativos do Interbase, a biblioteca dbExpress e ainda o

BDE. Abaixo segue uma breve descrição de cada uma destas tecnologias:

BDE: Essa era a tecnologia padrão de banco de dados nas primeiras versões do

Delphi, mas a Borland agora a considera obsoleta. Isso é particularmente

verdadeiro para o uso do BDE com servidores SQL, pois além do Client do banco

de dados, você deve instalar o BDE em cada estação de trabalho que usará o

sistema. Você pode visualizar os componentes do BDE através da guia BDE

presente na pela de componentes.

ADO: o ActiveX Data Objects é a interface de alto nível da Microsoft para acesso

a banco de dados. O ADO é implementado na tecnologia de acesso a dados OLE

DB da Microsoft, que fornece acesso a banco de dados relacionais, bem como a

sistemas de arquivos, email e objetos corporativos personalizados. O ADO é um

mecanismo com recursos muito interessantes como independência de servidor

de banco de dados. Sua configuração é simplificada e a instalação também, pois

o mecanismo já faz parte das versões atuais do Windows. Os objetos do ADO

estão disponíveis na guia ADO da paleta de componentes.

Interbase Express: O Delphi também disponibiliza um conjunto de

componentes de acesso a dados para o Interbase: o IBX (Interbase Express).

Estes componentes são específicos para o banco de dados Interbase que é

próprio da Borland. Os componentes IBX estão localizados na guia Interbase da

paleta de componentes.

62 de 332


dbExpress: Um dos novos recursos do Delphi nos últimos anos foi a introdução

da biblioteca de banco de dados dbExpress (DBX), disponível para Linux e

Windows. O DBX é uma biblioteca e não um mecanismo de acesso a dados,

porque usa uma estratégia leve e basicamente não exige nenhuma configuração

nas máquinas dos usuários finais. Comparado com outros mecanismos de banco

de dados, o dbExpress é muito limitado em termos de recursos. Ele pode

acessar apenas servidores SQL, não recurso de cachê e oferece apenas acesso

unidirecional aos dados. Acesse a guia dbExpress da paleta de componentes

para visualizar os componentes DBX.

Obviamente, devemos escolher que tecnologia de acesso a dados iremos utilizar. Não

cabe aqui dizermos qual é a melhor ou pior, devemos definir qual mecanismo utilizar

dependendo do ambiente que estamos trabalhando e das tecnologias envolvidas.

Neste curso iremos criar aplicações de banco de dados cliente/servidor para o sistema

operacional Windows utilizando o servidor de banco de dados SQL Server. Logo podemos

perceber que estamos num ambiente totalmente Microsoft, sendo assim, a melhor opção neste

caso é utilizar o mecanismo de acesso a dados ADO que é nativo da própria Microsoft e já está

presente em qualquer versão do Windows atualmente sendo desnecessário a instalação destes

componentes nas estações de trabalho.

Para criar nossas aplicações, precisaremos apenas de dois objetos da guia ADO: o

ADOConnection e o ADOQuery. O objeto ADOConnection é usado fazer a conexão com o banco

de dados e o objeto ADOQuery é usado para executar comandos SQL e para retornar dados

através da instrução SELECT. Mais adiante veremos como configurá-los.

Além dos componentes do mecanismo de acesso a dados, o Delphi disponibiliza outros

objetos que são utilizados para manipulação de banco de dados. Este objetos são utilizados em

conjunto com os componentes de acesso a dados independentemente da tecnologia adotada

63 de 332


(BDE, ADO, DBX...). Este componentes estão disponíveis nas através das guias Data Access e

Data Controls.

Da guia Data Access somente iremos utilizar o objeto DataSource. Este objeto faz o

intercâmbio entre os objetos do mecanismo de banco de dados (ADO, BDE, DBX...) o os

objetos de manipulação de dados que estão na guia Data Controls.

Os objetos da guia Data Controls são utilizados para manipulação dos dados. Por

exemplo, o objeto DbGrid pode ser utilizado para visualização e para edição dos dados, o

objeto DbEdit é semelhante ao objeto Edit da paleta Standard com a diferença de somente

ser utilizado quando ligado a uma coluna de uma tabela de banco de dados. Durante o curso

veremos a utilização dos objetos da guia Data Controls.

64 de 332


Recuperando e exibindo dados

Neste capítulo iremos ver como recuperar informações através de um programa Delphi

usando a instrução SELECT. Usaremos como exemplo o banco de dados “Rodoviaria” que tem

sido nosso objeto de estudo até agora.

Antes de qualquer coisa, crie uma pasta chamada “Projeto Rodoviária” para salvar os

arquivos que iremos criar. Em seguida abra o Delphi para começarmos!

Conforme sabemos, o Delphi ao ser iniciado já disponibiliza um novo projeto, selecione

então o Form1 e altere a propriedade Caption para “Menu Rodoviária” e a propriedade Name

para “Form_menu”.

Em seguida clique em Save All para salvarmos logo nosso projeto.

A primeira coisa que o Delphi vai pedir para salvar é a Unit do Form_menu, portanto

salve o arquivo como o nome “Unit_menu”. Lembre-se de salvar os arquivos na pasta que

criamos para este propósito.

65 de 332


Em seguida o Delphi pedirá que salve o arquivo do projeto, salve-o como nome

“Rodoviaria”.

66 de 332


Após salvar os arquivos, insira 4 objetos BitBtn ao Form_menu. Estes botões serão

utilizados para chamar as outras telas do programa e para fechar a aplicação.

Altere a propriedade Caption dos botões para “Empresas”, “Motoristas”, “Ônibus” e

“Fechar” respectivamente. Altere também a propriedade Name para “btn_empresas”,

“btn_mototristas”, “btn_onibus” e “btn_fechar” de cada botão correspondente. Se desejar

formate a fonte utilizada e redimensione os botões e o Form_menu como quiser. Organize os

botões conforme exibido abaixo:

Acesse o evento OnClick do botão btn_fechar e digite o comando

“Application.Terminate;”. Esta instrução fará com que a aplicação seja encerrada quando

alguém clicar no botão Fechar.

Vamos agora inserir um objeto ADOConnection ao Form_menu, este objeto fará a

conexão com o banco de dados.

67 de 332


Selecione o objeto ADOConnection que inserimos no Form_menu e altere sua

propriedade Name para “ConexaoBD” e a propriedade Login Prompt para “False”.

Em seguida, clique sobre o botão “...” da propriedade ConnectionString. A

propriedade ConnectionString é que define o banco de dados que iremos acessar. Aqui

definimos se vamos acessar um banco de dados Oracle, SQL Server ou Microsoft Access entre

outros, além disso, especificamos o nome do servidor, o usuário e a senha que será utilizada

para acessar o banco de dados. Na tela que surgiu após clicar sobre o botão “...”, clique sobre

o botão Build...

68 de 332


A primeira opção que devemos configurar é o software de banco de dados que iremos

acessar, em nosso caso, iremos acessar um servidor SQL Server, portanto selecione a opção

Microsoft OLE DB Provider for SQL Server. Clique em Avançar para continuar com a

configuração do objeto ConexaoDB.

Agora devemos informar o nome do servidor SQL Server que desejamos acessar. Você

também pode informar o endereço IP do servidor caso não saiba ou não queira usar o nome do

servidor.

A próxima opção é usuário e a senha utilizada para acessar o servidor. Digite um

usuário e a senha desejada. Sugerimos que você utilize o mesmo usuário/senha que usou para

se conectar no Query Analyzer. Marque a opção “Permitir salvamento de senha”. Iremos deixar

esta opção marcada temporariamente enquanto estamos programando para que não seja

necessário informar a senha toda hora.

A última opção a configurar é o banco de dados que iremos acessar. Como vimos

anteriormente neste curso, um servidor SQL Server possui vários banco de dados e aqui

podemos então selecionar qual deles iremos acessar. Selecione o banco de dados Rodoviaria.

69 de 332


Clique no botão Testar conexão para checar se está tudo Ok.

Vá clicando em OK até voltar ao Form_menu. Agora selecione o objeto ConexaoBD e

altere a propriedade Connected mudando o valor de False para True. Isto faz com que o

objeto estabeleça a conexão com o servidor de banco de dados.

Agora insira um novo Form ao projeto. Este novo Form será utilizado para o cadastro de

Empresas.

70 de 332


Configure as propriedades Name e Caption do novo Form como “Form_empresas” e

“Empresas” respectivamente. Em seguida clique novamente sobre o botão Save All para

salvar as alterações realizadas e novo Form inserido.

Salve a unit do Form_empresas como “Unit_empresas”.

71 de 332


Insira um objeto BitBtn ao Form_empresas, altere a propriedade Name dele para

“btn_fechar” e a propriedade Caption para “Fechar”. Acesse o evento OnClick e digite o

comando “Close;”. Este comando irá fechar o form_empresas quando o usuário clicar sobre o

botão Fechar.

A partir de agora até o final deste curso, toda vez que for solicitado a criação de um

botão Fechar, repita os procedimentos que acabamos de executar. Assim não precisaremos

ficar repetindo toda hora o que você já vai estar careca de saber!

OBS.: A instrução “Close;” não funciona como a instrução “Application.Terminate;”,

embora tenham funções semelhantes, cada uma tem uma finalidade diferente. O comando

“Close;” fecha apenas o Form em que ele foi executado enquanto o comando

“Application.Terminate;” encerra toda a aplicação independentemente de qual form a

instrução foi executada.

72 de 332


Vamos então recuperar as informações contidas no banco de dados. Como estamos

programando o cadastro de Empresas, vamos recuperar os registros da tabela “Empresas” que

está no banco de dados Rodoviária.

Insira um objeto ADOQuery ao form_empresas.

Altere a propriedade Name dele para “adoquery_empresas”. O objeto

adoquery_empresas será utilizada para recuperar os registros da tabela Empresas. Como já

sabemos, a instrução SQL para este caso é o comando SELECT. Acesse a propriedade SQL do

adoquery_empresas e clique sobre o botão “...”. Será exibida uma janela onde devemos

digitar a instrução SQL que será executada pelo adoquery_empresas. Digite então a seguinte

instrução: “SELECT * FROM EMPRESAS ORDER BY NOME”.

Clique em OK para fechar a janela de edição da propriedade SQL do objeto.

73 de 332


Além da propriedade SQL do objeto, devemos definir a conexão que o objeto utilizará

para executar a instrução SQL. A conexão a ser utilizada pelo adoquery_empresas e por todos

os outros objetos que iremos criar, foi configurada através do objeto conexaoBD que está no

form_menu. Sendo assim, devemos ligar o objeto adoquery_empresas ao objeto conexaoBD.

Como o objeto ConexaoBD está no form_menu, devemos informar ao Delphi que o

form_empresas terá acesso ao form_menu. Para isto, clique em File > Use Unit.

Na janela que surgirá, selecione a unit_menu e clique em OK.

Em seguida, salve as alterações clicando sobre o botão Save All.

74 de 332


Agora já podemos ligar o objeto adoquery_empresas (que está no form_empresas) ao

objeto ConexaoBD (que está no form_menu). Para isto, selecione o adoquery_empresas e

altere a propriedade Connection para ConexaoBD.

Para testar se configurou tudo corretamente e executar a instrução SQL, altere a

propriedade Active do adoquery_empresas para True. Quando colocamos True na propriedade

Active, o Delphi executa a instrução configurada na propriedade SQL do objeto. Entretanto,

visualmente parece que nada aconteceu. Para exibir o resultado do SELECT executado pelo

adoquery_empresas, vamos utilizar o componente DBGrid que tem a finalidade de exibir

informações de banco de dados. Então insira um objeto DBGrid (que está na guia Data

Controls da paleta de componentes) ao form_empresas.

O objeto DBGrid, assim como todos os objetos da guia Data Controls, não “fala”

diretamente com os objetos ADO, portanto será necessário mais um objeto que fará o

intercâmbio entre eles: o DataSource que está na guia Data Access.

Altere a propriedade Name do DBGrid para dbgrid_empresas e do DataSource para

ds_empresas. Organize-os conforme a figura abaixo:

75 de 332


Vamos então interligar os componentes. Como dito anteriormente, os objetos Data

Controls não falam diretamente com os objetos ADO, quem faz este trabalho é o Data Source.

Então vamos ligar o ds_empresas ao adoquery_empresas e o dbgrid_empresas ao

ds_empresas.

Selecione o objeto ds_empresas e altere a propriedade DataSet para

adoquery_empresas.

Selecione o objeto dbgrid_empresas e altere a propriedade DataSource para

ds_empresas.

76 de 332


Pronto, agora basta ativar o adoquery_empresas colocando True em sua propriedade

Active e os registros serão exibidos no dbgrid_empresas.

Não é muito interessante deixar o adoquery ativo, é sempre muito melhor ativá-lo

durante a execução do programa, pois assim ele sempre estará atualizado, portanto coloque

False na propriedade Active do adoquery_empresas. Vamos fazer o seguinte: ativar o

adoquery_empresas quando o form_empresas for exibido e desativá-lo quando o

form_empresas for fechado.O evento executado na exibição de um Form é OnShow e o

executado quando um form é fechado é OnClose.

Sendo assim, acesse o evento OnShow do form_empresas e digite:

“adoquery_empresas.Open;”

O método Open do objeto adoquery é o equivalente a colocar True na propriedade

Active.

Em seguida acesse o evento OnClose do form_empresas e digite:

“adoquery_empresas.close;”

77 de 332


O método Close do objeto adoquery é o equivalente a colocar False na propriedade

Active.

Devemos fazer a mesma coisa com o objeto ConexaoBD, estabelecer a conexão e

encerrá-la dinamicamente na execução do programa. Para isto, primeiro vá até o form_menu e

coloque False na propriedade Connected do objeto ConexaoBD. Em seguida, acesse o evento

OnShow do form_menu e digite “ConexaoBD.Open;”

No evento OnClose do form_menu digite “ConexaoBD.Close;”

Antes de executar a aplicação para testarmos se está tudo funcionando, devemos

programar o botão btn_empresas do form_menu para chamar o form_empresas. Para isto,

digite o seguinte no evento OnClick do botão btn_empresas “form_empresas.showmodal;”

78 de 332


Agora salve todas as alterações clicando em Save All e execute a aplicação. Quando

você clicar sobre o botão Run ou pressionar F9 para executar a aplicação o Delphi informará

que o form_menu está fazendo menção ao form_empresas e lhe questiona se deseja que ele

crie automaticamente esta referência no código. Clique em Yes e execute a aplicação.

79 de 332


Após testar a aplicação feche o projeto que está executando clicando sobre o botão

fechar que colocamos no form_menu. Vamos agora fazer o mesmo para Motoristas e Ônibus.

Repita os mesmos passos que fizemos para criar a tela de Empresas: Insira um novo Form,

altere Name e Caption, salve com o nome apropriado... Releia as páginas anteriores para

lembrar de todos os procedimentos.

O SELECT a ser usado para a tela de Motoristas será:

O SELECT para a tela de Ônibus será um pouco mais complicado, pois faremos JOIN

com as outras tabelas para poder exibir o nome da empresa e do motorista:

80 de 332


Pronto! Você já pode executar a aplicação. Se você seguiu corretamente os passos

descritos para a criação da tela de empresas, as telas de motoristas e ônibus deverão estar

funcionando corretamente. Não se esqueça de programar os botões da tela de menu para

chamar as novas telas criadas, do contrário eles não servirão para alguma coisa.

81 de 332


Inserindo Dados

No capítulo anterior vimos como recuperar informações de um banco de dados com o

Delphi através de seus componentes e da instrução SELECT. Neste capítulo iremos aprender

como inserir informações em banco de dados com o Delphi usando a instrução INSERT.

Vamos primeiro programar a tela do cadastro de Empresas e depois programamos as

telas de Motoristas e de Ônibus.

Para incluir informações em uma tabela, o usuário vai precisar de campos de entrada

de dados, portanto vamos incluir alguns objetos que permitirão o usuário digitar as

informações desejadas.

A tabela Empresas possui 2 colunas, e por isso precisaremos disponibilizar 2 campos

para o usuário preencher. Insira dois objetos Edit (guia Standard).

Renomeie os objetos através da propriedade Name para “edt_cod” e “edt_nome”

respectivamente. Limpe o conteúdo da propriedade Text de ambos os Edit’s, pois esta

propriedade é a responsável por armazenar o texto que foi digitado para o usuário e por isso

deve estar vazia para o usuário digitar o que desejar. Altere a propriedade MaxLength do

edt_cod para 10 e do edt_nome para 30. Esta propriedade define a quantidade máxima de

caracteres que podem ser digitados em um Edit. Insira também dois objetos Label (guia

Standard), um para cada Edit. Altere a propriedade Caption deles para “Código” e “Nome”

respectivamente.

Organize os objetos conforme exibido na figura abaixo.

82 de 332


Nós já temos um objeto ADOQuery que realiza o SELECT para visualização dos registros

existentes na tabela Empresas do banco de dados Rodoviaria, agora precisaremos de outro

objeto ADOQuery para executar a instrução INSERT e os demais comandos SQL (UPDATE e

DELETE) necessários para a funcionalidade desta tela. Insira então um objeto ADOQuery,

altere a propriedade Name dele para adoquery_aux (“aux” de auxiliar, pois vai nos auxiliar a

executar as instruções SQL) e selecione o objeto ConexaoDB na propriedade Connection para

ligá-lo ao objeto ADOConnection que está no form_menu.

Além dos objetos para entrada de dados e do adoquery, precisaremos de um botão

para disparar o comando INSERT. Insira um objeto BitBtn ao form_empresas, altere a

propriedade Name dele para “btn_inserir” e Caption para “Inserir”. No evento OnClick do

btn_inserir digite o código abaixo:

83 de 332


As linhas começadas com “//” são comentários e por isso não são executadas pelo

Delphi, elas servem para documentar o código e explicar o que ele está fazendo. Você pode

alterar as cores de letra e background dos comentários através do menu do Delphi Tools >

Editor Options.

84 de 332


Após digitar o código acima, salve todas as alterações clicando sobre o botão Save All.

Em seguida execute o projeto para testar a nova funcionalidade.

Insira mais alguns registros para testar a aplicação. Apenas certifique-se de que não vai

inserir uma empresa com um código que já esteja cadastrado, do contrário ocorrerá um erro

de violação de chave primária. Mais adiante neste curso veremos como tratar erros de banco

de dados.

85 de 332


Vamos agora programar a mesma funcionalidade para a tela de Motoristas. Repita os

mesmos procedimentos adotados para a tela de Empresas, obviamente aplicando as

particularidades da tabela Motoristas.

A tela deve ficar semelhante à exibida na figura abaixo:

No evento OnClick do botão Inserir digite o código exibido na imagem abaixo.

OBS.: Neste código retiramos os comentários para diminuir o tamanho da imagem e,

além disso, é praticamente idêntico ao código do botão Inserir da tela de Empresas, portanto

segue a mesma explicação.

86 de 332


Salve as alterações e execute a aplicação para testar a nova funcionalidade.

87 de 332


Agora criaremos a funcionalidade de Inclusão para o cadastro de Ônibus. Vamos incluir

os campos para entrada de dados da tabela Onibus do banco de dados Rodoviaria.

Insira dois objetos Edit ao form_onibus, um para o usuário digitar o número do ônibus e

o outro para o usuário digitar o trajeto do mesmo. Altere a propriedade Name deles para

“edt_num” e “edt_trajeto” respectivamente. Para os outros dois campos da tabela:

num_motorista e cod_empresa, usaremos o objeto ComboBox (guia Standard), pois como

estas informações já estão cadastradas, iremos exibir uma lista para que o usuário selecione a

que desejar. Insira dois objetos ComboBox, um para o motorista e o outro para a empresa.

Altere a propriedade Name deles para “cb_motorista” e “cb_empresa” respectivamente.

Também limpe a propriedade Text de ambos e insira objetos Label para todos os campos.

Insira um botão para inserir e um ADOQuery conforme fizemos para as outras telas, não se

esqueça de configurar suas propriedades. Organize os objetos conforme exibido na imagem

abaixo:

Esta tela não será tão simples como as outras, pois iremos exibir informações de outras

tabelas através dos objetos combobox o que exigirá uma programação mais elaborada. Vamos

88 de 332


alimentar os objetos ComboBox quando o a tela de ônibus for exibida, para isto adicione o

código abaixo no evento OnShow do form_menu:

//Limpa o combobox de motoristas

cb_motorista.Clear;

// Define o SELECT para obter o nome dos motoristas

adoquery_aux.SQL.Text:='SELECT NOME FROM MOTORISTAS ORDER BY NOME';

// Abre a query com o Select definido

adoquery_aux.Open;

// Enquanto não chegar ao final da query faça...

While Not ADOQuery_aux.Eof do

begin

// Adiciona ao combobox o nome do motorista do registro corrente

cb_motorista.Items.Add(adoquery_aux.fieldbyname('NOME').AsString);

// Passa para o próximo registro da query

adoquery_aux.Next;

end;

// Fecha a query de motoristas

adoquery_aux.close;

// Limpa o combobox de empresas

cb_empresa.Clear;

// Define o Select para obter o nome das empresas

adoquery_aux.SQL.Text:='SELECT NOME FROM EMPRESAS ORDER BY NOME';

// Abre a query com o Select definido

adoquery_aux.Open;

// Enquanto não chegar ao final da query faça...

While Not ADOQuery_aux.Eof do

begin

// Adiciona ao combobox o nome da empresa do registro corrente

cb_empresa.Items.Add(adoquery_aux.fieldbyname('NOME').AsString);

// Passa para o próximo registro da query

adoquery_aux.Next;

end;

// Fecha a query de empresas

adoquery_aux.Close;

Os objetos ComboBox irão exibir os nomes dos motoristas e das empresas, entretanto o

que deve ser gravado na tabela é o número do motorista e o código da empresa e não os

nomes. Sendo assim, vamos criar duas variáveis que servirão para armazenar estes valores.

89 de 332


Acesse a seção “Var” da unit_onibus que fica um pouco antes da seção

“implementation” e declare as seguintes variáveis: “num_motorista” e “cod_empresa” do

tipo integer.

Nós iremos alimentar estas variáveis quando o usuário selecionar o motorista e a

empresa nos combobox, ou seja, quando o usuário selecionar o nome de um motorista no

combobox, iremos obter o número dele no banco de dados e atribuir à variável. Faremos a

mesma coisa para a empresa. O evento executado quando o usuário seleciona uma opção no

combobox é o evento OnChange. Acesse o evento OnChange do cb_motorista e digite o

seguinte código:

No evento OnChange do objeto cb_empresa digite o seguinte código:

90 de 332


Agora só falta programar o botão “Inserir”. Para isto digite o código abaixo:

91 de 332


Pronto, execute a aplicação para testar a nova funcionalidade!

Insira mais alguns ônibus para verificar o funcionamento do programa.

92 de 332


Atualizando dados

Neste capítulo criaremos a funcionalidade de atualização de dados. Todo sistema deve

permitir que o usuário atualize as informações gravadas em um banco de dados, ou seja, deve

possibilitar que as informações sejam alteradas sem que seja necessário excluí-la para inserir

novamente. Esta nova funcionalidade será implementada da seguinte maneira: o usuário

seleciona no DBGrid o registro que deseja atualizar e clica em um botão chamado “Alterar”.

Neste momento a aplicação deverá preencher as caixas de entrada de dados com as

informações cadastradas na tabela para que o usuário altere somente o que ele precisa. Após

alterar as informações desejadas, o usuário clica em um botão chamado “Salvar” e o sistema

executa o UPDATE para atualizar as informações. Iremos criar esta programação na tela de

Empresas depois na tela de Motoristas e por último na tela de Ônibus seguindo a mesma

seqüência desde o inicio deste módulo.

Primeiro iremos configurar o DBGrid para que a marca de seleção destaque toda a linha

e não somente uma célula.

Para isto, expanda a propriedade Options do DBGrid e altere a opção dgRowSelect

para true. Isto é só para criar um efeito visual mais claro ao usuário, não é fundamental para

nossa programação.

93 de 332


Como o DBGrid está ligado ao adoquery_empresas (através do ds_empresas), quando o

usuário seleciona um registro no DBGrid o Delphi seleciona o mesmo registro no

adoquery_empresas, sendo assim, basta acessar a propriedade FieldbyName do

adoquery_empresas para obter os dados do registro selecionado pelo usuário.

Crie uma variável para armazenar o código da empresa que será atualizada. Nós

utilizaremos esta variável para saber que registro devemos atualizar, pois se o usuário alterar

o código da empresa que é a chave primária da tabela, não teríamos como saber que registro

deve ser atualizado.

Insira um objeto BitBtn ao Fom_empresas e altere a propriedade Name para

“btn_alterar” e a propriedade Caption para “Alterar”. Em seu evento OnClick, digite o código

abaixo:

O código acima irá guardar o código da empresa na variável e preencher as caixas de

texto com o registro selecionado para que o usuário altere o que quiser. Falta agora criar um

botão para salvar as alterações, ou seja, executar o comando UPDATE. Insira mais um objeto

BitBtn e altere a propriedade Name dele para “btn_salvar” e Caption para “Salvar Alterações”.

Sua tela deve ficar semelhante à exibida na imagem abaixo:

94 de 332


Digite o seguinte código no evento OnClick do objeto btn_salvar:

Salve as modificações clicando em Save All e em seguida execute a aplicação para

testar a nova funcionalidade.

95 de 332


Antes

Depois

Altere vários registros para se certificar de que fez tudo corretamente!

96 de 332


Faça o mesmo para a tela de motoristas (não esqueça de declarar a variável para

armazenara chave primária). O código do evento OnClick do botão Alterar será o seguinte:

O código do botão Salvar será:

97 de 332


Para a tela de Ônibus, repita mais uma vez os procedimentos. O código do evento

OnClick do botão Alterar será o seguinte:

O código do botão Salvar será:

Pronto! Salve as alterações e execute o projeto para testar a funcionalidade de

atualização de dados.

98 de 332


Excluindo Dados

Nos capítulos anteriores nós vimos como recuperar, inserir e atualizar informações de

um banco de dados através de uma aplicação Delphi usando as instruções SELECT, INSERT e

UPDATE. Agora veremos como excluir dados também através do Delphi usando a instrução

DELETE. Seguindo a mesma seqüência até aqui, vamos programar a tela de Empresas.

Insira mais um objeto BitBtn ao form_empresas e altere a propriedade Name para

“btn_excluir” e Caption para “Excluir”. Sua tela deve ficar semelhante à exibida abaixo:

Vamos utilizar a mesma idéia da atualização de dados: o usuário seleciona no DBgrid o

registro desejado e clica sobre o botão excluir, neste momento o programa obtém, através da

propriedade FieldByName do adoquery, o código da empresa que foi selecionada e usa-o para

executar o comando DELETE.

Acesse o evento OnClick do objeto btn_excluir e digite o código abaixo:

99 de 332


Após digitar o código acima, salve e execute a aplicação para testar a funcionalidade de

exclusão de dados.

Ao tentar excluir uma empresa qualquer, provavelmente o Delphi emitirá a seguinte

mensagem de erro:

A mensagem acima está notificando que ao tentarmos excluir a empresa, o SQL Server

gerou um erro de FK (FK_Onibus_Empresas), pois tentamos excluir uma empresa que possui

Ônibus ligados à ela, ou seja, precisaremos excluir os Ônibus desta empresa antes de deletá-

la. Com certeza esta mensagem não é muito clara ao usuário comum, por isso, no próximo

capítulo veremos como tratar os erros de banco de dados a fim de emitir uma mensagem mais

amigável ao usuário. Por enquanto, deixe como está, vamos prosseguir e programar a tela de

Motoristas.

Repita os procedimentos adotados para a tela de Empresas e no evento OnClick do

botão Excluir da tela de Motoristas digite o seguinte:

100 de 332



exclusão de Motoristas.

Ao tentar excluir um motorista qualquer, provavelmente o Delphi também emitirá a

mensagem de erro de Chave Estrangeira (FK_Onibus_Motoristas).

Já que para excluir Empresas e/ou Motoristas precisaremos excluir os Ônibus que por

ventura estejam ligados a eles, vamos criar a funcionalidade de exclusão para a tela de

Ônibus.

Acesse o Form_onibus e repita os passos de inserir um botão, renomeá-lo e etc. No

evento OnClick do btn_excluir do Form_onibus, digite o seguinte código:

101 de 332



exclusão de Ônibus.

Observe que ao excluir um ônibus qualquer, não recebemos nenhuma mensagem de

erro, pois a tabela Onibus ocupa a posição de “filho” na relação de dependência, ou seja, é

possível existir um Motorista ou uma Empresa sem Ônibus, mas o contrário não!

Exclua alguns Ônibus e em seguida tente excluir Motoristas e Empresas que não

possuam mais Ônibus ligados a eles.

102 de 332


Tratando erros de banco de dados

Nos capítulos anteriores nós aprendemos como modificar informações em um banco de

dados através de operações de inserção, atualização e exclusão de dados. Entretanto, fizemos

tudo isso sem nos preocuparmos com eventuais erros de banco que as operações executadas

podem ocasionar. Por exemplo, excluir um registro da tabela “Empresas” que possua um

registro relacionado na tabela “Onibus” geraria um erro de FK (Foreign Key ou Chave

Estrangeira) devido à restrição de integridade que impomos no momento da criação das

tabelas. Quando um programa não está preparado para tratar eventuais erros de banco de

dados, pode ser que ele aborte ou continue a execução de forma errada, pois como o erro não

foi previsto pelo programador, o programa não sabe o que fazer. Sendo assim, devemos

sempre que possível preparar o programa para possíveis erros de banco de dados de forma

que ele saiba como se comportar em cada situação.

Para o tratamento de erros no Delphi utilizamos a instrução: “try...except”. Exemplo

de código usando a instrução try...except:

AdoConnection.BeginTrans;

Adoquery.sql.text := ‘DELETE FROM EMPRESAS’;

Try

Adoquery.ExecSQL;

AdoConnection.CommitTrans;

Except

Showmessage(‘Ocorreu um erro nesta operação !’);

AdoConnection.RollbackTrans;

End;

O trecho de código acima está tentando excluir todos os registros da tabela “Empresas”,

caso ocorra algum erro na execução do comando SQL ou na confirmação da transação, o

Delphi irá executar os comandos que estão na seção Except.

Obs.: Quando ocorre algum erro durante a execução de um programa, dizemos que foi

levantada uma exception (exceção) e por isso o nome “try...except”.

Nós podemos armazenar a exception em um objeto e, desta forma, acessar suas

propriedades e métodos. Abaixo segue o código de exemplo onde armazenamos a exception

em um objeto e em seguida acessamos sua propriedade Message que é do tipo String.

103 de 332


AdoConnection.BeginTrans;

Adoquery.sql.text := ‘DELETE FROM EMPRESAS’;

Try

Adoquery.ExecSQL;

AdoConnection.CommitTrans;

Except

on E : Exception do

begin

Showmessage('Ocorreu o seguinte erro: '+ E.Message);

AdoConnection.RollbackTrans;

end;

End;

Isto é particularmente útil para obter a mensagem de erro gerada, assim podemos

“interpretá-la” e então exibir uma mensagem mais amigável ao usuário.

Por exemplo, ao invés de deixar o programa exibir a mensagem original do erro de FK,

exibiríamos uma mensagem que qualquer usuário conseguiria entender:

Mensagem de erro sem tratamento

Mensagem de erro amigável

Vamos aprender melhor como isto funciona na prática utilizando esta técnica para

tratar erros de banco de dados em nosso projeto Rodoviário. Nós iremos usar o try...except

nas operações de inserção, atualização e exclusão de dados primeiramente na tela de

Empresas.

Antes de começar a programar, temos que verificar quais são os possíveis erros de

banco de dados em cada operação. Por exemplo, na inserção de dados pode ser que ocorra um

erro de duplicação de PK (Primary Key ou Chave Primária) se o usuário tentar inserir uma nova

empresa com um código que já esteja cadastrado. Toda vez que ocorre um erro de violação da

104 de 332


restrição de dados, o SQL Server devolve na mensagem de erro o nome da restrição que foi

violada. Desta forma, basta verificarmos se o nome da restrição que queremos checar está na

mensagem de erro devolvida pelo SQL Server ao programa Delphi. Nós podemos ver o nome

de todas as restrições de dados (conhecidas como CONSTRAINTS) através do Enterprise

Manager. Por exemplo, para ver o nome da restrição de PK da tabela Empresas, clique com o

botão direito do mouse sobre a tabela e em seguida clique em “Design Table”.

Em seguida clique sobre o botão “Table and Index Properties”

Na janela que surgirá, acesse a guia Indexes/Keys e veja no campo “Index Name” o

nome da restrição de dados.

Uma vez conhecido o nome da violação, temos que alterar o código do programa para

verificar se este nome aparece na mensagem de erro. Se aparecer, então exibimos uma

105 de 332


mensagem clara para o usuário, do contrário, devemos exibir a mensagem original já que é

difícil imaginar que tipo de erro pode acontecer em uma operação de inserção que não seja o

erro de PK. Mas antes de alterar a código de inserção da tela de empresas, vamos criar uma

função para verificar se o nome da restrição está na mensagem de erro já que iremos precisar

fazer isto várias vezes. Esta função deve ficar na Unit do Form_menu porque precisaremos

dela em outros forms e o form_menu está na seção “Uses” de todos eles, pois compartilha o

objeto ConexaoBD.

Esta função irá receber dois parâmetros: a mensagem de erro e o nome da violação

que queremos verificar se está presente na mensagem. A função irá retornar ‘Sim’ se o texto

com o nome da violação estiver na mensagem e ‘Não’ caso contrário. Como no Delphi não

existe a função Like da linguagem SQL, devemos verificar a existência de um texto dentro de

outro texto da seguinte maneira:

1 – Saber a quantidade de caracteres que a mensagem possui;

2 – Saber a quantidade de caracteres que o texto a ser verificado possui;

3 – Ir comparando (do primeiro ao último caractere) pedaços da mensagem com o

texto pesquisado. Caso algum pedaço da mensagem seja igual ao texto pesquisado, então

paramos de comparar e retornamos o valor ‘Sim’. Caso terminemos de comparar e nenhum

pedaço seja igual ao texto pesquisado, então retornamos o valor ‘Não’.

Acesse a seção Public da unit do form_menu e declare o cabeçalho da função que

chamaremos de “ErroBD” conforme exibido abaixo:

Após declarar a função, pressione simultaneamente as teclas SHIFT+CTRL+C para criar

automaticamente o corpo da função na seção Implementation logo após a última procedure ou

função já existente.

106 de 332


Agora programe a função conforme exibido a seguir:

O código acima está fazendo exatamente o que foi descrito anteriormente quando

especificamos o seu funcionamento.

107 de 332


Pronto, já temos a função que irá fazer a verificação da mensagem para que possamos

interpretá-la durante o tratamento do erro. Vamos então programar o tratamento do possível

erro de PK na tela de Empresas.

Acesse a Unit do Form_empresas e altere o evento OnClick do botão “Inserir” de forma

que ele fique igual ao exibido abaixo:

if (trim(edt_cod.Text)='') or (trim(edt_nome.Text)='') then

begin

Showmessage('Preencha todos os campos !');

end

else

begin

Form_menu.ConexaoBD.BeginTrans;

adoquery_aux.SQL.Text:=' INSERT INTO EMPRESAS VALUES (' +

edt_cod.Text + ',' + QuotedStr(edt_nome.Text) + ')';

try

adoquery_aux.ExecSQL;

deu_erro := false;

except

on E : Exception do

begin

deu_erro := true;

//Se for erro de PK então

// exibe mensagem amigável

//Senão

// exibe a mensagem sem tratamento mesmo !

if Form_menu.ErroBD(E.Message,'PK_Empresas') = 'Sim' then

ShowMessage('Código já cadastrado!')

else

ShowMessage('Ocorreu o seguinte erro: ' + E.Message);

end;

end;

if deu_erro = false then

begin

Form_menu.ConexaoBD.CommitTrans;

ADOQuery_empresas.Close;

ADOQuery_empresas.Open;

Showmessage('Operação executada com sucesso !');

edt_cod.Clear;

edt_nome.Clear;

end

else

begin

Form_menu.ConexaoBD.RollbackTrans;

end;

end;

108 de 332


Observe que estamos fazendo uso de uma variável chamada deu_erro. Estamos

utilizando esta variável para fazer o controle se houve ou não erro e assim executar os

comandos de acordo com a situação.

Esta variável deve ser declarada na seção Var da Unit_empresas como do tipo boolean

(lógica). Veja o destaque na imagem abaixo:

Após fazer as alterações, salve e compile o projeto. Depois de compilar o projeto,

recomendamos que execute o programa por fora do Delphi, ou seja, executando diretamente o

arquivo “.exe” gerado na pasta onde o projeto foi salvo. Isto é importante para verificar o real

comportamento do programa durante a ocorrência de erros, pois quando executado por dentro

do Delphi, o compilador emite a mensagem de erro e paralisa a execução lhe obrigando a

pressionar novamente o botão Run (F9) para que então o programa continue a execução e

trate o erro.

Vamos então testar se o programa está se comportando como o esperado. Tente

cadastrar uma outra empresa com um código que já exista.

109 de 332


Se não tivéssemos programado o tratamento de erro, a mensagem seria a seguinte:

Podemos então concluir que o tratamento de erros de banco de dados é fundamental

para uma boa aplicação, pois torna o sistema mais robusto e inteligente além de muito mais

amigável ao usuário.

Vamos agora programar a operação de atualização de dados. Antes, devemos avaliar

que erros podem acontecer nesta operação. Como a tabela empresa possui relacionamento

com a tabela Ônibus, pode ser que ocorra um erro de FK se tentarmos alterar o código de uma

empresa que tenha Ônibus relacionados a ela. Para verificar o nome da FK responsável pelo

relacionamento entre as tabelas Empresas e Ônibus, usaremos o Enterprise Manager.

110 de 332


Acesse as propriedades da tabela assim como fizemos para ver o nome da restrição de

PK da tabela Empresas. Para ver os nomes das FK’s, acesse a guia Relationships e verifique

no campo “Relationship name” o nome da FK referente ao relacionamento.

Se houver alguma atualização de registro na tabela Empresas que viole a restrição de

integridade imposta pelo relacionamento entre Empresas e Ônibus, o texto

“FK_Onibus_Empresas” será exibido na mensagem de erro.

Analisando com mais cuidado a situação, percebemos que na operação de atualização

também pode ocorre um erro de PK se o usuário tentar alterar o código da empresa para um

outro que já esteja cadastrado. Sendo assim, devemos preparar o programa também para

este tipo de erro na atualização.

Para programar o tratamento de erros na atualização de dados na tela de Empresas,

altere o código do evento OnClick do botão “Salvar Alterações” de forma que fique igual ao

exibido abaixo:

111 de 332



adoquery_aux.SQL.Text:='UPDATE EMPRESAS SET ' +

' COD_EMPRESA = ' + edt_cod.Text + ',' +

' NOME = ' + QuotedStr(edt_nome.Text) +

' WHERE COD_EMPRESA = ' + cod_empresa;

try


deu_erro := false;

except

on E : Exception do

begin

deu_erro := true;

if Form_menu.ErroBD(E.Message,'FK_Onibus_Empresas') = 'Sim' then

ShowMessage('Impossível atualizar o código pois existem Ônibus ligados a esta Empresa!')

else if Form_menu.ErroBD(E.Message,'PK_Empresas') = 'Sim' then

ShowMessage('Código já cadastrado!')

else


end;

end;

if deu_erro = false then

begin


ADOQuery_empresas.Close;

ADOQuery_empresas.Open;

Showmessage('Operação executada com sucesso !');

edt_cod.Clear;

edt_nome.Clear;

end

else

begin

Form_menu.ConexaoBD.RollbackTrans;

end;

Após fazer as alterações, salve e compile o projeto. Depois de compilar, execute o

programa por fora do Delphi para testar seu comportamento.

112 de 332


Agora só falta fazer o mesmo tratamento para a operação de exclusão. Na exclusão o

único erro provável de ocorrer é o de FK caso o usuário tente excluir uma empresa que possua

ônibus cadastrados. Para fazer o tratamento, altere o código do evento OnClick do botão

“Excluir” de forma que ele fique conforme o código a seguir:

cod_empresa:=adoquery_empresas.fieldbyname('cod_empresa').AsString;


adoquery_aux.SQL.Text:=' DELETE FROM EMPRESAS'+

' WHERE COD_EMPRESA = ' + cod_empresa;

deu_erro := false;

try


except

on E: Exception do

begin

deu_erro := true;

if Form_menu.ErroBD(E.Message,'FK_Onibus_Empresas') = 'Sim' then

ShowMessage('Impossível excluir pois existem Ônibus ligados a esta Empresa!')

else


end;

end;

if deu_erro = true then

Form_menu.ConexaoBD.RollbackTrans

else

begin


adoquery_empresas.Close;

adoquery_empresas.Open;

showmessage('Empresa excluída com sucesso !');

end;

113 de 332


Após fazer as alterações, salve e compile o projeto. Depois de compilar, execute o

programa por fora do Delphi para testar seu comportamento.

Pronto, acabamos de programar o tratamento de erros de banco de dados para a tela

de Empresas. Agora, aplique os conhecimentos adquiridos aqui para fazer o tratamento de

erros de banco de dados nas telas de Motoristas e Ônibus.

114 de 332


Módulo 3:

Projetando uma Aplicação de Banco de

Dados Cliente/Servidor

ntes de iniciar qualquer desenvolvimento, é fundamental planejar e

projetar a aplicação que será construída. Afinal, como vamos construir

algo que não sabemos como vai ser? É extremamente importante

definir o escopo da aplicação, ou seja, especificar qual o objetivo do sistema

que vai ser criado. Devemos sempre projetar as funcionalidades que o sistema

vai possuir para então sair programando cada uma delas. Com este

pensamento, criamos este módulo que irá nos ajudar a planejar e a projetar a

aplicação que servirá de base para nosso aprendizado. Neste módulo iremos

definir o objetivo do sistema, criar um diagrama das funcionalidades da

aplicação, projetar o modelo de dados, criar as tabelas e iniciar o

desenvolvimento propriamente dito.

A

115 de 332


Planejando a aplicação: “Gerenciador de Cursos de Informática”

Nos módulos anteriores nós aprendemos sobre banco de dados e o modelo

Cliente/Servidor. Conhecemos a linguagem SQL e vimos como recuperar e modificar

informações em um banco de dados além de aprendermos como o Delphi interage com o SQL

Server. Agora chegou o momento de colocar em prática os conhecimentos adquiridos. Faremos

isto simulando o desenvolvimento de uma aplicação de banco de dados. Todos os módulos

seguintes abordarão aspectos importantes na construção de um sistema baseado em banco de

dados. Começaremos projetando a aplicação, ou seja, definindo o seu escopo.

O primeiro passo no desenvolvimento de qualquer sistema é definir o seu objetivo,

devemos saber qual a sua finalidade e para que ele servirá. Neste curso simularemos o

desenvolvimento de uma aplicação para uma escola de informática que oferece cursos básicos

de Windows, Office e Internet como centenas delas que existem pelo Brasil. Esta aplicação

será utilizada pela escola de informática para fazer o gerenciamento dos cursos de informática

oferecidos por ela. Sendo assim, chamaremos nosso sistema de Gerenciador de Cursos de

Informática.

Após definir o objetivo do sistema, vamos especificar suas funcionalidades.

O Gerenciador de Cursos de Informática será o responsável pelo controle de todos os

cursos, instrutores, turmas e alunos da escola. O sistema deverá cadastrar:

O código e o nome de cada curso;

O código, o nome, a idade, o telefone e o sexo de cada instrutor;

O código, o curso, o instrutor e o valor da aula de cada turma;

O código, o nome, a idade, o telefone e o sexo de cada aluno;

O código do curso e o código da turma são criados pela própria escola de informática,

na verdade, estes códigos são formados por um conjunto de caracteres que possui um

significado representativo para os funcionários da escola.

O código do curso é composto por 3 letras que identificam o curso, abaixo alguns

exemplos:

WIN : Curso de Windows

DOC : Curso de Word

XLS : Curso de Excel

HTM : Curso de Internet

116 de 332


O código da turma é composto pelo código do curso acrescido do ano e mês de início da

turma, por exemplo, o código de uma turma do Curso de Windows que tem início em Fevereiro

de 2005 seria: WIN200502 e o de uma turma de Excel com início em Março de 2005 seria:

XLS200503.

O código do instrutor e do aluno são números seqüenciais, portanto devem ser gerados

pelo sistema.

Além dos cadastros, o sistema deverá controlar todas as matrículas de alunos da

escola. A matrícula ocorre quando um aluno se matricula em um ou mais cursos. Para o

controle de matrículas deve-se armazenar o código do aluno e o código da turma.

O sistema deverá possuir um mecanismo que possibilite ao instrutor fazer o lançamento

de suas aulas. Para este controle, o sistema deverá guardar o código da turma em que o

instrutor está alocado e a data da aula. O instrutor irá lançar as aulas mediante o

acontecimento das mesmas não sendo possível cadastrá-las antecipadamente.

A aplicação também deverá fazer o controle de freqüência dos alunos. Para cada aula

lançada pelo instrutor o sistema deve registrar se o aluno faltou ou esteve presente na

mesma. Este controle se aplica a todos os alunos matriculados na turma sem exceção. Este

controle será usado pelos instrutores após o lançamento de cada aula.

O sistema ainda deve possuir uma ferramenta que permita ao responsável pela escola

de informática fazer o pagamento dos instrutores. Esta ferramenta deve contabilizar as aulas

dadas pelo instrutor em um determinado mês e gerar um demonstrativo com o valor total a

ser pago por elas. Após a geração do demonstrativo o sistema deve marcar cada aula como

paga.

Atenção: Todas as operações do sistema devem ter uma restrição de acesso para que

apenas as pessoas autorizadas possam acessá-las. O sistema deverá permitir que o

responsável pela escola de informática defina as funcionalidades que cada pessoa poderá

acessar na aplicação.

117 de 332


Criando um Diagrama de Funcionalidades

No capítulo anterior fizemos o planejamento da aplicação onde tivemos a oportunidade

de tomar conhecimento do sistema que deve ser construído, saber qual o objetivo da aplicação

e ainda recolher as especificações que irão orientar nosso desenvolvimento.

Após o planejamento inicial, é muito interessante fazer um diagrama que represente

toda a funcionalidade do sistema. A criação de um diagrama é importante para representar de

forma gráfica tudo o que foi levantado na especificação durante o planejamento. Além disso, o

diagrama permite ao programador organizar as idéias e criticar possíveis falhas no processo.

Esta é a fase de projeto, ou seja, é quando você irá definir o comportamento do programa.

Muitos programadores não gostam de projetar o sistema e partem logo para a codificação sem

ao menos analisar ou pensar antes de sair programando. Esta não é uma boa prática, pois

dificilmente uma aplicação que não foi projetada ou que teve um projeto ruim terá uma boa

qualidade. Geralmente quando isto acontece, o programador acaba levando muito mais tempo

para concluir o sistema, pois perde um bom tempo dando manutenção e corrigindo falhas do

que se tivesse planejado e projetado corretamente a aplicação.

Obs.: Neste curso não iremos apresentar uma metodologia específica. Nosso propósito

não é ensinar UML, análise estruturada, essencial, orientada a objetos ou qualquer outra

metodologia de desenvolvimento de software. Nós apenas queremos mostrar que a

representação gráfica do funcionamento de um sistema é muito útil aos profissionais que irão

construir a aplicação. O leitor não precisa utilizar o mesmo método adotado neste curso para a

criação de diagramas, você pode e deve utilizar a metodologia que quiser. O mais importante

neste aspecto é que você tenha a iniciativa de desenhar ou pelo menos rascunhar como será o

funcionamento da aplicação a ser desenvolvida.

Com base nas informações contidas no capítulo anterior, iremos construir um diagrama

(uma espécie de DFD - Diagrama de Fluxo de Dados) que representará cada processo do

sistema e quais operações ele executará, neste diagrama também representaremos os

depósitos de dados que serão utilizados por cada processo.

Abaixo segue o diagrama de funcionalidades da aplicação:

118 de 332


Diagrama de Funcionalidades da Aplicação

AlunosRealiza

Matrículas

ConsultaAluno

Aulas

Matrículas

CadastraMatrícula

LançaFrequências

ConsultaAula

ConsultaAlunos

Matriculados

GeraPagamentoInstrutores

ConsultaAulas

Cursos

RealizaCadastros

CadastraCurso

ConsultaCurso

InstrutoresConsultaInstrutor

CadastraInstrutor

LançaAulas

CadastraAula

ConsultaAula

Turmas

ConsultaTurma

CadastraTurma

ConsultaTurma

Frequências

CadastraFrequência

CadastraAluno

Na diagrama acima, os processos do sistema estão representados através dos círculos

amarelos. As setas azuis representam as operações de atualização de dados realizada pelos

processos e os databases representam os depósitos de dados utilizados pelos processos.

Observe que as setinhas indicam o sentido em que as informações estão sendo transportadas.

As setinhas apontadas para os databases indicam uma operação de gravação no depósito de

dados. As setinhas que apontam para os processos indicam uma operação de leitura do

depósito de dados. Também é importante ressaltar que os processos não se “falam”

diretamente, eles apenas se relacionam através dos depósitos de dados.

O diagrama acima é a representação lógica do sistema, a partir dele é que criaremos

nosso sistema no Delphi.

Cada processo (bolinha amarela) será uma ou mais telas do programa. Por exemplo, o

processo “Realiza Matrículas” será a tela de cadastro de matrícula do sistema e o processo

“Realiza Cadastros” será formado pelas telas de cadastro de cursos, cadastro de instrutores,

cadastro de turmas e cadastro de alunos.

119 de 332


Cada database será uma ou mais tabelas do banco de dados do sistema. Por exemplo,

o database “Cursos” será a tabela de cursos no banco de dados e o database “Aulas” será a

tabela de aulas.

As setinhas indicam que tabelas cada tela irá utilizar para leitura e/ou escrita.

Veja que um simples diagrama nos ajuda a entender o que devemos fazer. Com base

neste diagrama já podemos iniciar a codificação no Delphi, mas ainda não iremos fazer isso,

pois falta projetarmos o banco de dados da aplicação, ou seja, definir como serão as tabelas.

No próximo capítulo iremos criar o modelo de dados baseado no diagrama que

acabamos de criar e nas informações existentes no capítulo anterior.

120 de 332


Projetando o banco de dados

Este capítulo é destinado à criação do modelo de dados do Gerenciador de Cursos de

Informática. Partiremos logo para a especificação de cada tabela.

Conforme foi definido no capítulo de planejamento e especificação da aplicação, para o

cadastro de cursos o sistema deve armazenar o código e o nome de cada curso. O código é

composto por 3 letras, logo a coluna de código será do tipo varchar com um tamanho de 3

caracteres. O nome do curso também será do tipo varchar e como não foi especificado o

tamanho máximo do nome de um curso, assumiremos um tamanho de 20, pois acreditamos

que 20 caracteres sejam suficientes para armazenar o nome de um curso de informática.

Sendo assim, segue a tabela de cursos, a chave primária será a coluna do código da

curso:

Para o cadastro de instrutores, o sistema deve armazenar o código, o nome, a idade, o

telefone e o sexo de cada instrutor. O código será um número seqüencial, portanto será

utilizado o tipo int. Para o nome usaremos varchar com um tamanho de 30 caracteres. Para a

idade usaremos o tipo int por se tratar de valor numérico. Para o telefone usaremos o tipo

varchar com um tamanho de 14 caracteres, pois o usuário pode querer digitar parênteses,

espaços ou traços para organizar o número de telefone do instrutor.

Abaixo segue a tabela de Instrutores, a chave primária será a coluna do código do

instrutor:

Para o cadastro de turmas, o sistema deve armazenar o código, o curso, o instrutor e o

valor da aula de cada turma. O código da turma é composto pelas 3 letras do código do curso

acrescido do ano (com 4 dígitos) e mês (2 dígitos) de início da turma, sendo assim, usaremos

o tipo varchar com um tamanho de 9 caracteres. Para o curso usaremos a mesma definição do

código da tabela cursos. Para o instrutor usaremos a mesma definição do código da tabela

121 de 332


instrutores. Para o sexo usaremos o tipo varchar com o tamanho de 1 caracteres por razões

óbvias.

Abaixo segue a tabela de turma, a chave primária será a coluna do código da turma:

Para o cadastro de alunos, o sistema deve armazenar o código, o nome, a idade, o

telefone e o sexo de cada aluno. Usaremos as mesmas definições utilizadas para a tabela

instrutores.

Abaixo segue a tabela de alunos, a chave primária será a coluna do código do aluno:

Para o controle de matrículas, o sistema deve registrar o código do aluno e o código da

turma em que o aluno se matriculou. Sendo assim, basta utilizar as mesmas definições das

colunas de código do aluno e código da turma das respectivas tabelas.

Abaixo segue a tabela de matrículas, a chave primária será composta pelas duas

colunas, pois são necessárias ambas as colunas para identificar uma matrícula:

Para o registro de aulas, o sistema deve armazenar o código da turma e a data da aula.

O código da turma será do tipo varchar com o tamanho de 9 caracteres da mesma maneira

que na tabela de turmas. Para a data da aula usaremos o tipo datetime.

Sendo assim, segue a tabela de aulas, a chave primária será composta pelas duas

colunas, pois são necessárias ambas as colunas para identificar uma aula:

122 de 332


Para a o controle de freqüências, o sistema deve armazenar o registro de matrícula de

cada aluno que é composto pelo código da turma e pelo código do aluno, a data da aula e um

campo para gravar “P” ou “F” (presença ou falta). Com base nestas definições podemos criar a

tabela de freqüências. A chave primária será composta pelos campos que identificam a

matrícula e pela data da aula, pois são necessárias ambas as colunas para identificar a

freqüência.

Após definir cada tabela, já podemos montar o modelo de dados criando os

relacionamentos das tabelas através das chaves estrangeiras.

123 de 332


No capítulo de planejamento da aplicação foi especificado que todas as operações do

sistema devem possuir um controle de acesso. Este controle deve restringir o acesso ao

sistema à somente pessoas autorizadas. Para isto, criaremos um mecanismo de validação de

usuários, onde cada usuário precisará informar uma senha para poder entrar no sistema. Além

disso, cada usuário poderá ter acesso a apenas algumas funções do sistema. Por exemplo, o

usuário João somente poderá acessar o módulo de matrículas e a usuária Maria somente terá

acesso ao módulo de relatórios. Para fazer este controle, precisaremos de mais algumas

tabelas no banco de dados:

Uma tabela para armazenar os usuários e suas senhas;

Uma tabela para armazenar as funções do sistema;

Uma tabela para gravar as funções que cada usuário tem permissão de acesso.

Para registrar os usuários do sistema precisaremos gravar o login de usuário, a senha

do usuário e o nome do usuário. Sendo assim, criaremos a tabela abaixo, a chave primária

será o login do usuário:

O campo usuário irá armazenar o login de cada usuário, por exemplo, o login do usuário

Rodrigo Costa poderá ser rcosta e o login do usuário Sergio Ferreira poderá ser sferreira.

O campo nome, obviamente, irá armazenar o nome de cada usuário e o campo senha irá

armazenar o que você já sabe.

Embora o campo senha tenha sido definido com o tamanho de 30 caracteres, na

aplicação iremos restringir a senha ao no máximo 10 caracteres. Fizemos isto, pois iremos

armazenar a senha codificada no padrão ASCII. O padrão ASCII utiliza uma combinação de 3

números para representar cada caractere alfanumérico. Por exemplo, o código ASCII para o

caractere “a” é 097 e o código ASCII para o caractere “1” é 049. Sendo assim, caso o usuário

cadastre uma senha de 10 caracteres precisaremos de 30 posições para representá-la.

Obs.: Iremos armazenar a senha criptografada apenas para dar mais segurança e

confiabilidade ao sistema. Você não precisa obrigatoriamente criptografar as senhas dos

usuários, isto é apenas uma boa prática que costumamos adotar.

Para registrar as funções do sistema iremos armazenar o código e o nome da cada

função. Abaixo segue a tabela de funções:

124 de 332


Para o código da função utilizamos um campo varchar com 6 posições. Desta forma

podemos criar códigos mnemônicos que identifiquem facilmente a função. No campo nome

podemos cadastrar o nome ou uma pequena descrição da função. Por exemplo, a função de

cadastro de cursos poderia ser cadastrada da seguinte maneira:

cod_funcao: “CADCUR”

nome: “Cadastro de Cursos”

E por fim, para armazenar as permissões de cada usuário, iremos registrar o código da

função e o login do usuário:

Após definir cada tabela, já podemos montar o modelo de dados criando os

relacionamentos das tabelas através das chaves estrangeiras.

Atenção: Nós criamos as tabelas do controle de acesso separadas do modelo de dados

da aplicação porque elas não possuem qualquer ligação. Por isso criamos dois modelos de

dados. Além disso, o modelo de dados do controle de acesso pode ser aplicado em qualquer

sistema e não é uma particularidade apenas desta aplicação.

125 de 332


Criando as tabelas

Vamos agora implementar o modelo de dados que acabamos de construir, ou seja,

vamos criar fisicamente as tabelas em um banco de dados do SQL Server. Abra o Enterprise

Manager para podermos criar nossas tabelas. Vamos criar um novo Banco de Dados

exclusivamente para este sistema gerenciador de cursos de informática. Para isto, expanda o

ícone do servidor e clique com o botão direito do mouse sobre a opção Databases. Na caixa

de diálogo que surgirá, clique em New Database...

Em seguida, será exibida a janela Database Properties. Preencha a caixa de texto

Name com o nome do novo banco de dados, em nosso caso usaremos: “Academico” (sem

aspas). Clique em OK para criar o novo Banco de Dados.

126 de 332


Após criar o banco de dados Academico, acesse a seção Tables para criarmos as

tabelas do modelo de dados. Clique com o botão direito sobre a opção Tables e em seguida

em New Table...

Será exibida uma tela para criarmos a estrutura da nova tabela. Vamos criar primeiro a

tabela “Cursos”, para isso basta seguir as especificações do modelo que criamos

anteriormente. Digite o nome da primeira coluna da tabela Cursos que, segundo nosso

modelo, é “cod_curso”. Em Data Type escolha o tipo de dado “varchar” depois defina o

tamanho de 3 caracteres na opção Lenght. Em seguida clique no ícone que possui a figura de

uma chave para especificar que esta coluna é a chave primária desta tabela.

Preencha agora o nome da segunda coluna da tabela Cursos: “nome”. Em Data Type

selecione o tipo varchar e defina o tamanho máximo de 20 caracteres em Length.

Desmarque a opção Allow Nulls (Permitir nulo) da coluna “nome”, pois esta coluna deve ter

preenchimento obrigatório. A coluna “cod_curso” também é obrigatória, mais como já

definimos que ela é chave primária, automaticamente o SQL Server desmarca a opção Allow

Nulls, pois a chave primária sempre é obrigatória. Com isto, criamos a estrutura da tabela

“Cursos” de acordo com o que foi especificado no modelo de dados.

127 de 332


Só falta definir o nome da tabela, para isto clique sobre o ícone que possui a figura de

um disquete. Esta opção serve para salvar as alterações feitas e para definir o nome da tabela

quando isto ainda não foi feito. Obviamente, salve a tabela com o nome: Cursos.

Pronto, a tabela foi criada! Feche a janela de edição e você verá a nova tabela na lista

de tabelas do banco de dados Academico.

Caso você precise alterar ou corrigir alguma coisa na estrutura da tabela, basta clicar

sobre ela com o botão direito e em seguida clicar em Design Table.

Prosseguindo com a construção das tabelas de nosso modelo de dados, vamos agora

criar a tabela “Instrutores”. Clique com o botão direito sobre a opção Tables do banco de

dados Academico e em seguida em New Table...

Crie a estrutura da tabela “Instrutores” seguindo as especificações do modelo de dados

assim como fizemos com a tabela “Cursos”. Preencha corretamente os nomes das colunas e

selecione os respectivos tipos de dados. Não esqueça de especificar a coluna “cod_instrutor”

como chave primária da tabela.

128 de 332


Obs.: No capítulo referente ao planejamento foi especificado que o código do instrutor

deve ser um número seqüencial, portanto iremos configurar este campo de forma que o SQL

Server gere automaticamente os números à medida que os instrutores sejam cadastrados.

Para isto usaremos a propriedade Identity. Selecione a coluna cod_instrutor e defina a

propriedade Identity como “Yes” conforme a imagem abaixo.

A propriedade Identity, quando ativada, gera um número seqüencial para cada registro

que é inserido semelhantemente ao tipo de dados AutoNumeração do Access.

Após criar a estrutura, salve a tabela como nome “Motoristas”.

A próxima tabela que iremos criar é a tabela “Turmas”. Esta tabela “depende” das

outras duas, ou seja, ela possui chave estrangeira para as tabelas “Cursos” e “Instrutores”.

Nós poderíamos ter criado ela antes das outras, só que depois teríamos que editá-la para

referenciar as chaves estrangeiras. Assim, com as outras tabelas já criadas, iremos fazer tudo

de uma vez.

129 de 332


Novamente clique com o botão direito sobre a opção Tables do banco de dados

Academico e em seguida em New Table... Preencha os campos de acordo com o modelo de

dados.

Após preencher os campos, salve a tabela como “Turmas”, mas deixe a janela de edição

aberta para que possamos configurar as chaves estrangeiras. Clique sobre a opção “Table and

Index Properties” que está representada através de um ícone com uma figura de uma mão

segurando um pedaço de papel.

Na janela que surgirá, selecione a guia “Relationships” (Relacionamentos).

130 de 332


Nesta tela é que iremos criar nossas chaves estrangeiras. Só para lembrar: uma chave

estrangeira é uma coluna que “aponta” para outra coluna de uma outra tabela. A chave

estrangeira somente pode apontar para uma coluna que seja chave primária ou que possua

uma chave única (este conceito não será abordado neste curso). O termo “Chave Primária” é

mais conhecido como “Primary Key” ou apenas “PK” e o termo “Chave Estrangeira” é

conhecido como “Foreign Key” ou simplesmente “FK”.

Para criar nossa primeira chave estrangeira, clique sobre o botão “New”. Na caixa de

seleção “Primary key table”, selecione a tabela Cursos e logo abaixo selecione a coluna

“cod_curso”. Na caixa de seleção “Foreign key table”, selecione a tabela “Turmas” e em

seguida selecione a coluna “cod_curso”. O que acabamos de fazer foi: dizer para o SQL Server

que a coluna “cod_cuso” da tabela Turmas está ligada à coluna “cod_curso” da tabela

“Cursos”.

Veja abaixo como ficou a tela após a configuração:

131 de 332


Agora vamos criar a chave estrangeira para a tabela “Instrutores”. Clique novamente

sobre o botão “New” e repita o procedimento apontando a coluna “cod_instrutor” da tabela

“Turmas” para a coluna “cod_instrutor” da coluna “Instrutores”.

Clique sobre o botão “Fechar” e depois salve as alterações clicando sobre o botão com o

ícone de um disquete. O SQL Server informará que as alterações efetuadas afetarão outras

tabelas.

Clique em “Yes” e Pronto! As chaves estrangeiras foram configuradas com sucesso!

132 de 332


Agora criaremos a tabela de “Alunos”. Para isto siga os mesmos passos da criação da

tabela de Instrutores, pois elas são bem parecidas. Não se esqueça de configurar a

propriedade Identity para o campo cod_aluno.

A próxima tabela a ser criada é “Matriculas”. Nesta tabela, ambas as colunas serão

chave primária e chave estrangeira ao mesmo tempo. A coluna cod_turma se referencia à

coluna cod_turma da tabela Turmas e a coluna cod_aluno se referencia à coluna cod_aluno da

tabela Alunos. Crie a tabela e configure seus relacionamentos.

Criaremos agora a tabela “Aulas”. Crie a estrutura da tabela conforme o especificado no

modelo de dados. Nesta tabela, a chave primária é composta pelas colunas cod_turma e data.

A coluna cod_turma também é uma chave estrangeira que se referencia a tabela “Turmas”.

A última tabela a ser criada é a tabela de freqüências. Crie a tabela seguindo o modelo

de dados.

133 de 332


Esta tabela tem sua chave primária composta por 3 colunas: cod_turma, cod_aluno e

data. A coluna cod_turma, além de fazer parte da chave primária, ela será chave estrangeira

para duas tabelas ao mesmo tempo. A coluna cod_turma junto com a coluna cod_aluno se

referencia à tabela “Matriculas” e a coluna cod_turma junto com a coluna data se referencia à

tabela “Aulas”.

Neste caso, veja como ficarão as telas de relacionamento:

Relacionamento Freqüências X Matriculas

Relacionamento Freqüências X Aulas

134 de 332


Pronto! Acabamos de criar todas as tabelas, confira a lista de todas as tabelas que

acabamos de criar.

Nós podemos ter certeza de que os relacionamentos foram criados corretamente

através da opção Diagrams do banco de dados Academico. Nesta opção podemos criar

diagramas com as tabelas existentes no banco de dados. Neste diagrama o SQL Server exibe o

relacionamento existente entre as tabelas. Clique com o botão direito do mouse sobre a opção

Diagrams do banco de dados Academico e em seguida clique sobre a opção New Database

Diagram...

Será exibida a tela do assistente de criação de diagramas do SQL Server.

135 de 332


Clique em Avançar para exibir a próxima tela onde iremos selecionar as tabelas que

farão parte do nosso diagrama.

Selecione todas as tabelas e clique no botão “Add >”. Em seguida, clique em Avançar e

na tela seguinte em Concluir. Então o SQL Server montará o diagrama com as tabelas e seus

respectivos relacionamentos.

136 de 332


Com base no diagrama montado pelo SQL Server podemos concluir que criamos as

tabelas e os relacionamentos corretamente de acordo com nosso modelo de dados da

aplicação.

Modelo de dados da aplicação

Diagrama gerado pelo SQL Server

137 de 332


Após criar as tabelas do modelo de dados da aplicação, devemos criar as tabelas do

modelo de dados do controle de acesso. Elas também devem ser criadas no banco de dados

“Acadêmico”, deixamos para criá-las por último apenas por uma questão didática.

Seguindo os mesmos procedimentos para criação de tabelas, primeiro crie a tabela

“Usuarios”, em seguida a tabela “Funcoes” e por fim a tabela “Permissoes”. Não se esqueça de

configurar os relacionamentos da tabela “Permissoes”.

Uma vez terminada a criação das tabelas, criaremos um novo diagrama do SQL Server

apenas com as tabelas do controle de acesso. Lembramos que o diagrama do SQL Server é

uma ótima maneira de conferir se as tabelas e seus relacionamentos foram criados

corretamente.

138 de 332


Modelo de dados do controle de acesso

Diagrama do SQL Server

139 de 332


Iniciando a programação

Vamos agora dar início à programação do sistema. Antes de qualquer coisa, crie uma

pasta chamada “Gerenciador de Cursos” para salvar os arquivos que iremos criar. Em

seguida abra o Delphi para começarmos!

Conforme sabemos, o Delphi ao ser iniciado já disponibiliza um novo projeto, portanto

utilizá-lo-emos. A primeira tela que o sistema deverá exibir deve ser a tela de Logon onde o

usuário irá digitar o login de usuário e a senha. Então selecione o Form1 e altere a propriedade

Caption para “Logon” e a propriedade Name para “Form_logon”.

Em seguida clique em Save All para salvarmos logo nosso projeto.

A primeira coisa que o Delphi vai pedir para salvar é a Unit do Form_logon, portanto

salve o arquivo como o nome “Unit_logon”. Lembre-se de salvar os arquivos na pasta que

criamos para este propósito.

140 de 332


Em seguida o Delphi pedirá que salve o arquivo do projeto, salve-o com o nome

“Academico”.

Após salvar os arquivos iremos configurar algumas propriedades do Form_logon. Defina

a fonte do formulário como “Verdana” através da propriedade Font. Selecione a opção

“poScreenCenter” na propriedade Position para que o form sempre seja exibido no centro da

tela. Defina a propriedade BorderStyle como “bsSingle” para não permitir que o usuário

redimensione a tela descaracterizando-a. Em seguida acesse a propriedade BorderIcons e

coloque “False” nas opções biMaximize e biMinimize para desabilitar os botões Maximizar e

Minimizar da janela.

Atenção: Estas configurações devem ser aplicadas a todos os novos formulários que

serão criados para este sistema. Não se esqueça de fazer isto, pois senão a aplicação ficará

despadronizada.

141 de 332


Insira ao form_logon: 2 objetos Label, 2 objetos Edit e 2 objetos BitBtn. Organize-os

conforme a imagem abaixo:

Renomeie os objetos Edit como edt_usuario e edt_senha respectivamente e os objetos

BitBtn como btn_ok e btn_fechar. Você pode utilizar a propriedade Kind ou Glyph para

colocar uma figura nos objetos BitBtn. A propriedade Kind disponibiliza algumas opções pré-

definidas e a propriedade Glyph permite que você escolha a imagem que desejar. O próprio

Delphi tem um diretório cheio de imagens para serem utilizadas em botões do tipo BitBtn,

confira em C:\Arquivos de programas\Arquivos comuns\Borland

Shared\Images\Buttons

Após fazer as configurações do Form_logon clique em Save All para salvar as

alterações realizadas no projeto.

Após a tela de login, o sistema deve exibir a tela de Menu com todas as funções

disponíveis na aplicação, portanto vamos criar a tela de menu do sistema. Insira um novo

Form ao projeto.

Configure as propriedades Name e Caption do novo Form como “Form_menu” e “Menu

– Gerenciador de Cursos” respectivamente. Em seguida aplique as mesmas configurações

feitas para o form_logon.

142 de 332


Após realizar as configurações, clique novamente sobre o botão Save All para salvar as

alterações realizadas e novo Form inserido. Salve a unit do novo Form como “Unit_menu”.

Para compor a tela de Menu do sistema utilizaremos uma interface icônica, ou seja,

ícones que representam funções do sistema. Como esta aplicação não possui muitas funções,

fica desnecessária a utilização dos menus tradicionais. Por isto usaremos objetos BitBtn ao

invés do objeto MainMenu.

Insira 11 objetos BitBtn ao form_menu. Cada objeto servirá para chamar uma

determinada função, portanto altere as propriedades Name e Caption de cada um deles

seguindo a tabela abaixo:

Name Captionbtn_cadcursos Cadastro de Cursos btn_cadinstrutores Cadastro de Instrutores btn_cadturmas Cadastro de Turmas btn_cadalunos Cadastro de Alunos btn_matriculas Matrículas btn_aulas Lançamento de Aulas btn_frequencias Freqüências btn_paginstrutores Pagamento de Instrutores btn_relatorios Relatórios btn_controle Controle de Acesso btn_fechar Fechar

143 de 332


Você também pode colocar uma figura para cada BitBtn através da propriedade Glyph,

escolha a imagem que você achar que faça sentido com a função do objeto. Veja abaixo como

ficou a tela de Menu do sistema após a configuração dos botões:

Após fazer as configurações do Form_menu, clique em Save All para salvar as

alterações realizadas no projeto.

Pronto, terminamos a fase inicial do desenvolvimento! O próximo passo é criar o

controle de acesso, mas isto será feito no módulo seguinte.

144 de 332


Módulo 4:

Criando o Controle de Acesso

ma vez terminado a fase de projeto e a programação inicial, devemos

criar o mecanismo de controle de acesso. Este mecanismo será

responsável por controlar os usuários e suas respectivas permissões a

cada funcionalidade da aplicação. Já foi o tempo em que um sistema tinha um

único usuário e podia acessar todas as opções. Hoje em dia, qualquer sistema

decente é multiusuário, e portanto, deve exigir que cada usuário se identifique

através de uma tela de Logon onde deve informar um nome de usuário e uma

senha. Sendo assim, devemos programar a autenticação do sistema no

servidor de banco de dados e validação dos usuários junto à aplicação. Além

da validação dos usuários, devemos controlar as funcionalidades que cada

usuário tem acesso, habilitando somente as opções que o usuário tem

permissão. Neste módulo iremos criar toda esta parafernália necessária para a

segurança dos dados. Os conceitos aprendidos neste módulo podem ser

aplicados em qualquer outra aplicação que você venha criar em Delphi.

U

145 de 332


Criando a tela de Splash

O primeiro passo para a implementação de nosso controle de acesso será a criação da

tela de splash. A tela de splash é a tela de apresentação do programa, aquela que surge

rapidamente enquanto o programa está sendo carregado. Na verdade o controle de acesso não

depende da tela de splash e por sua vez a tela de splash também não depende do controle de

acesso, ou seja, ela pode ser criada independentemente se o sistema tem ou não um controle

de acesso. Nós a criaremos para dar um tom mais profissional ao sistema e aproveitaremos

para fazer a autenticação no servidor de banco de dados enquanto ela é exibida.

Caso o Delphi esteja fechado, execute-o e abra o projeto “Academico.dpr”.

Insira um novo Form ao projeto.

146 de 332


Configure as propriedades Name e Caption do novo Form como “Form_splash” e

“Splash” respectivamente. Apenas para este Form, não aplique as mesmas configurações

feitas para o form_logon, pois como será uma tela de apresentação, usaremos configurações

diferentes.

Configure a propriedade BorderStyle do form_splash como “bsDialog”, desta forma a

tela não terá uma moldura simplificada. Altere a propriedade Font para “Verdana”. Altere a

propriedade Color para “clWhite”.

Insira um objeto Label e altere a propriedade Caption dele para “Gerenciador de

Cursos”. Configure sua fonte para o tamanho 26 através da propriedade Font. Em seguida,

insira mais um objeto Label ao form_splash e altere sua propriedade Caption para “Aguarde,

carregando...”. Configure sua fonte para o tamanho 16 através da propriedade Font.

Redimensione o Form_splash e organize os objetos conforme a imagem abaixo:

Após fazer as configurações clique em Save All para salvar o form_splash. Salve-o

como “Unit_splash”.

147 de 332


Criamos o form_splash, mas até agora ele não passa de um form comum como os

demais. Para fazer com que ele seja realmente a apresentação do sistema precisaremos

alterar a Unit principal do projeto.

Clique sobre o botão View Unit ou pressione Ctrl+F12.

Será exibida a relação de Units do projeto, selecione a Unit “Academico”.

Então o Delphi mostrará o código da Unit “Academico”.

148 de 332


Observe que na unit “Academico” está o código que cria todos os forms quando a

aplicação é executada. A tela de splash deve ser a primeira a ser exibida e deve desaparecer

quando a aplicação terminar de criar todos os forms. Então vamos alterar o código da unit

“Academico” para isto aconteça. Faça as alterações de forma que a unit fique igual à exibida

na figura abaixo:

Pronto, configuramos nossa tela de Splash! Clique em Save All para salvar as

alterações.

Se você executar o projeto, verá a tela de splash surgindo e depois desaparecendo

antes de ser exibida a tela de Logon. Talvez não consiga perceber a tela de splash, pois ela

aparecerá e sumirá rapidamente. Isto porque o projeto tem apenas 2 forms por enquanto.

Depois que criarmos o processo de autenticação e à medida que a quantidade de forms for

aumentando, a exibição do splash durará mais tempo na tela.

149 de 332


Programando o processo de autenticação no Servidor

O processo de autenticação no servidor consiste em fazer o logon no servidor de banco

de dados. Não confunda o logon da aplicação no servidor com o logon dos usuários no sistema.

Aqui estamos falando de dois tipos de usuários: usuário do servidor de banco de dados e

usuário do sistema.

Usuários do Servidor Banco de Dados: São os usuários do software de banco

de dados, em nosso caso o Microsoft SQL Server 2000. São àqueles usados para

se conectar no Query Analyzer e no Enterprise Manager.

Usuários do Sistema: São os usuários da aplicação, àqueles que serão

cadastrados na tabela de usuários.

Para fazer logon no banco de dados, utilizaremos um único usuário. Ele será utilizado

para fazer as consultas e modificações no banco de dados. É interessante que a aplicação

tenha um usuário específico, portanto vamos criar um que seja para uso exclusivo do sistema.

Abra o Enterprise Manager e navegue até a opção “Logins” que está disponível na

seção Security. Clique sobre a opção “Logins” com o botão direito do mouse e em seguida

clique em New Login...

Obs.: Você deve está logado com uma conta com privilégios administrativos para poder

criar logins no SQL Server.

150 de 332


Na tela que surgirá, preencha o campo Name com “admin_academico”. Este será o

nome do usuário que será utilizado pela nossa aplicação. Na seção Authentication, selecione

a opção SQL Server Authentication e defina uma senha para o usuário.

Em seguida, acesse a guia Database Access para configurar as permissões de acesso

deste usuário. Marque o banco de dados “Academico” e em seguida marque o privilégio

db_owner. Desta maneira o usuário “admin_academico” terá acesso total ao banco de dados

Academico.

151 de 332


Após configurar o usuário, clique em OK para confirmar a operação. O SQL Server

solicitará que confirme a senha. Faça isso!

Após criar o novo usuário ele aparecerá na relação de usuários do SQL Server.

152 de 332


Feche o Enterprise Manager e volte ao Delphi. Vamos então criar uma função que fará a

autenticação no servidor utilizando o usuário recém-criado. Iremos criá-la na Unit do

Form_logon, portanto acesse-a. Esta função irá retornar “True” se conseguir autenticar ou

“False” se ocorrer algum erro.

Vá até a seção public da unit_logon e declare a função:

Após fazer a declaração, pressione Shit+Ctrl+C para o Delphi criar o corpo da function

na seção implementation.

Antes de programar a função, devemos inserir um objeto ADOConnection ao

form_logon, pois precisaremos dele para fazer o logon no SQL Server.

Altere a propriedade Name do ADOConnection para “CenexaoBD” e coloque “False” na

propriedade LoginPrompt.

153 de 332


Após inserir e configurar o objeto, volte para Unit e programe a função com o código

abaixo:

O código acima está configurando a string de conexão dinamicamente. Os parâmetros

configurados são os seguintes:

Provider: Driver do banco de dados

Initial Catalog: Nome do database

Data Source: Nome do Servidor

Após configurar os parâmetros da propriedade ConnectionString, tentamos abrir a

conexão passando o usuário e a senha. Se for tudo ok, então a função retorna True senão, a

função retorna False. Agora vamos chamar esta função durante a exibição da tela de Splash.

Para isto, basta chamá-la na Unit do projeto (unit Academico) após todos os forms terem sido

criados e antes de destruir a tela de Splash. Altere a unit conforme a imagem abaixo:

154 de 332


Configurando a tela de Logon

Após programar o processo de autenticação no servidor, vamos então configurar a tela

de Logon que fará a autenticação do usuário na aplicação. A autenticação no servidor é o

procedimento para estabelecer a conexão com o banco de dados, este processo é de total

desconhecimento das pessoas que utilizarão o sistema. Já a autenticação de usuários no

sistema será de conhecimento de todos, pois eles precisão informar um usuário e uma senha

para se conectar ao sistema. O que vamos fazer agora é criar o procedimento que irá verificar

se o usuário pode ou não entrar no sistema.

Vamos criar uma função na unit do form_logon que irá verificar se o usuário pode ou

não se logar no sistema.

Vá até a seção public da unit_logon e declare mais esta função:

Após fazer a declaração, pressione Shit+Ctrl+C para o Delphi criar o corpo da function

na seção implementation.

A função deverá, primeiramente, verificar se o usuário está cadastrado no sistema, se

estiver então deverá verificar se a senha está correta. Para fazer esta verificação teremos de

155 de 332


realizar uma consulta no banco de dados com o usuário informado. Para fazer consultas ou

para executar qualquer comandos SQL em banco de dados, precisaremos de um objeto

ADOQuery, portanto insira um objeto ADOQuery ao form_logon.

Altere a propriedade Name dele para “ADOQuery_aux” e a propriedade Connection

para “ConexaoBD”.

Após inserir e configurar o ADOQuery, volte para a Unit para programarmos a função de

validação dos usuários. Antes de escrever o código da função, declare duas variáveis

(“usuario_logado” e “senha_usuario” do tipo string) na seção public da unit_logon. Estas

variáveis serão alimentadas por esta função e utilizadas posteriormente em outras telas da

aplicação.

Voltando à função de validação, digite o código abaixo:

156 de 332


O código acima está fazendo o seguinte: Faz um SELECT na tabela de usuários de pegar

a senha que está cadastrada para o usuário passado como parâmetro à função. Se o

ADOQuery retornar vazio indica que o usuário não existe na tabela de usuários, então exibe

uma mensagem de erro e faz a função retorna False. Se o SELECT encontrar o usuário, então

verifica se a senha cadastrada na tabela é diferente da que foi passada como parâmetro à

função. Se as senhas forem diferentes, então exibe mensagem de erro e faz a função retornar

False, caso contrário alimenta a variável de usuário logado no sistema e faz a função retornar

True.

Atenção: Conforme previsto no projeto do banco de dados, a senha será gravada na

tabela de forma criptografada. Sendo assim, quando a função for verificar a senha digitada

pelo usuário, ela sempre será diferente do que está na tabela, ou seja, o usuário nunca

conseguirá entrar no sistema. Portanto, devemos descriptografar a senha cadastrada na tabela

antes de fazer a verificação.

Então, vamos logo criar a função para criptografar e para descriptografar.

Primeiro criaremos a função para criptografar.

157 de 332


Declare a função na seção public da unit_logon:

Após declarar a função, pressione Shift+Ctrl+C para criar o corpo da function:

Esta função irá obter o código ASCII de cada caractere da senha de trás para frente.

Por exemplo, para criptografar a palavra “teste”:

Código ASCII de cada caractere:

t = 116

e = 101

s = 115

t = 116

e = 101

Então, “teste” criptografado em ASCII de trás para frente será: “101116115101116”.

Digite o código da função que fará isto:

158 de 332


Agora vamos criar a função que irá descriptografar, ou seja, fazer o contrário da função

que criptografa. Declare a função na seção public da unit_logon:

Após declarar a função, pressione Shift+Ctrl+C para criar o corpo da function. Em

seguida digite o código abaixo:

159 de 332


Após criar as funções de criptografia, devemos alterar a função que faz a validação de

usuários para que descriptografe a senha cadastrada na tabela antes de fazer a verificação da

senha. Veja a alteração abaixo:

Vamos agora programar o evento OnClick do botão Ok de forma que ao pressionar este

botão, o sistema faça a validação de usuário.

160 de 332


Digite o seguinte no OnClick do botão OK:

Agora digite o seguinte no evento OnClick do botão Fechar:

Faltam só mais alguns ajustes ma tela de logon para concluí-la. Selecione o edt_senha

e altere a propriedade PasswordChar para * (asterisco). Isto é necessário para que apareça

asteriscos ao invés da senha digitada pelo usuário. Altere também a propriedade MaxLength

para 10, assim somente será permitido que o usuário digite 10 caracteres para a senha. Para o

edt_usuario defina a propriedade MaxLength como 30. Salve as alterações clicando em Save

All.

Para testar a validação de usuários, precisaremos inserir um registro na tabela de

usuários do banco de dados. Abra o Query Analyzer, faça logon com o usuário

admin_academico, selecione o banco de dados Academico e execute o seguinte comando:

161 de 332


O código (109101116115121115) que foi cadastrado, representa a palavra “system”,

ou seja, a senha do usuário administrador é “system”!

Agora volte ao Delphi e execute o projeto para testar a validação de usuários. Quando

você executar o projeto, o Delphi irá informar que o Fom_logon está fazendo menção do

Form_menu e lhe pergunta se deseja que ele crie esta referencia na cláusula Uses. Clique em

Yes. Assuma este procedimento como padrão para toda vez que o Delphi fizer esta pergunta.

Agora faça logon com o usuário “administrador” e com a senha “system” para testar o

sistema.

162 de 332


Criando o mecanismo de verificação de usuários e permissões

Agora vamos criar o mecanismo que irá verificar as permissões de cada usuário para

habilitar somente os botões do menu que o usuário logado tenha acesso. Antes de criar este

mecanismo, devemos cadastrar as funções do sistema no banco de dados.

Caso você o tenha fechado, abra o Query Analyzer, faça logon com o usuário

admin_academico, selecione o banco de dados Academico e execute os seguintes comandos

para cadastrar as funções do sistema:

Após executar os comandos acima, volte para o Delphi.

Mais uma vez precisaremos de um objeto ADOQuery para fazer as consultas no banco

de dados. Insira um ADOQuery e altere a propriedade Name dele para “ADOQuery_aux”. Ele

usará a conexão estabelecida pelo objeto ConexaoBD que está no form_logon, então acesse o

menu File > Use Unit... e clique na Unit_logon. Desta forma os objetos do form_logon

estarão disponíveis para o form_menu. Salve as alterações clicando em Save All. Agora altere

a propriedade Connection do ADOQuery_aux para “Form_logon.ConexaoBD”.

Criaremos uma procedure para fazer o trabalho de checagem e

habilitação/desabilitação de funções do menu do sistema. Acesse a unit do Form_menu e

declare a procedure na seção public da unit_menu:

163 de 332


Após declarar a procedure, pressione Shift+Ctrl+C para criar o corpo da mesma. Em

seguida digite o código abaixo:

ADOQuery_aux.SQL.Text := ' SELECT COD_FUNCAO FROM PERMISSOES ' +

' WHERE USUARIO = ' + QuotedStr(Form_logon.usuario_logado);

ADOQuery_aux.Open;

if ADOQuery_aux.Locate('COD_FUNCAO','CADCUR',[loCaseInsensitive]) then

btn_cadcurso.Enabled := True

else

btn_cadcurso.Enabled := False;

if ADOQuery_aux.Locate('COD_FUNCAO','CADINS',[loCaseInsensitive]) then

btn_cadinstrutores.Enabled := True

else

btn_cadinstrutores.Enabled := False;

if ADOQuery_aux.Locate('COD_FUNCAO','CADTUR',[loCaseInsensitive]) then

btn_cadturmas.Enabled := True

else

btn_cadturmas.Enabled := False;

if ADOQuery_aux.Locate('COD_FUNCAO','CADALU',[loCaseInsensitive]) then

btn_cadalunos.Enabled := True

else

btn_cadalunos.Enabled := False;

if ADOQuery_aux.Locate('COD_FUNCAO','CADMAT',[loCaseInsensitive]) then

btn_matriculas.Enabled := True

else

btn_matriculas.Enabled := False;

if ADOQuery_aux.Locate('COD_FUNCAO','LANAUL',[loCaseInsensitive]) then

btn_aulas.Enabled := True

164 de 332


else

btn_aulas.Enabled := False;

if ADOQuery_aux.Locate('COD_FUNCAO','LANFRE',[loCaseInsensitive]) then

btn_frequencias.Enabled := True

else

btn_frequencias.Enabled := False;

if ADOQuery_aux.Locate('COD_FUNCAO','PAGINS',[loCaseInsensitive]) then

btn_paginstrutores.Enabled := True

else

btn_paginstrutores.Enabled := False;

if ADOQuery_aux.Locate('COD_FUNCAO','RELATO',[loCaseInsensitive]) then

btn_relatorios.Enabled := True

else

btn_relatorios.Enabled := False;

if ADOQuery_aux.Locate('COD_FUNCAO','CONTRO',[loCaseInsensitive]) then

btn_controle.Enabled := True

else

btn_controle.Enabled := False;

ADOQuery_aux.Close;

Agora acesse o evento OnShow do form_menu e coloque a chamada à procedure para

que o sistema execute-a quando a tela de menu for exibida.

Clique em Save All para salvar todas as modificações feitas até aqui. Em seguida

execute o projeto para verificar o funcionamento da procedure de verificação de permissões de

usuários.

Observe que ao efetuar logon com o usuário administrador, o sistema desabilita todos

os botões do menu.

165 de 332


Isto aconteceu porque o usuário não tem nenhuma permissão cadastrada na tabela de

permissões. Faça o seguinte, execute os comandos abaixo no Query Analyzer e em seguida

execute novamente o projeto.

166 de 332


Montando o cadastro de usuários e permissões

Para que não seja necessário ficar cadastrando os usuários e suas respectivas

permissões “na mão” através de comandos SQL, vamos criar uma funcionalidade no sistema

com este objetivo.


Configure as propriedades Name e Caption do novo Form como “Form_usuarios” e

“Usuários” respectivamente. Aplique as mesmas configurações feitas para o form_logon para

manter o mesmo padrão. Após fazer as configurações, clique em Save All para salvar o novo

form. Salve-o como “Unit_usuarios”.

Insira 6 objetos BitBtn ao form_usuarios. Arrume-os lado-a-lado e altere as

propriedades Name e Caption de cada um deles conforme a tabela abaixo:

167 de 332


Name Caption

btn_novo Novo

btn_salvar Salvar

btn_alterar Alterar

btn_cancelar Cancelar

btn_excluir Excluir

btn_fechar Fechar

Se desejar, configure uma imagem para cada um dos botões. Seu form deve ficar

semelhante ao exibido a seguir:

Como você já deve ter percebido, estes botões serão responsáveis por executar as

operações de cadastro do form_usuarios. Vamos agora criar 2 procedures que irão

habilitar/desabilitar os botões dependendo da situação. Acesse a Unit do form_usuarios e

declare as duas procedures mostradas abaixo. Declare também a variável “operacao” que será

utilizada para sabermos que operação foi realizada pelo usuário.

168 de 332


Pressione Shift+Crtl+C para criar a estrutura das procedures na seção

implementation. Em seguida, digite o código das procedures que está exibido abaixo:

169 de 332


Após programar as procedures, insira ao form_usuarios 3 objetos do tipo Edit e 3

objetos do tipo Label. Organize-os conforme mostrado abaixo:

Renomeie os Edits para edt_usuario, edt_nome e edt_senha além de limpar o conteúdo

da propriedade Text de ambos. Configure a propriedade MaxLenght dos Edits para 30, 50 e 10

respectivamente. Altere também a propriedade Caption dos labels conforme exibido na

imagem acima. Em seguida, coloque um asterisco “*” na propriedade PasswordChar do

edt_senha. Vamos agora criar mais duas procedures que irão bloquear/bloquear os Edits para

edição dependendo da operação que o usuário estiver executando no form_usuarios. Estas

procedures irão ler todos os objetos do form e desabilitar e alterar a cor dos objetos que sejam

do tipo Edit, ou seja, irão alterar os objetos que pertencem à classe TEdit. Declare as

procedures na seção public da unit_usuarios.

Pressione Shift+Crtl+C para criar a estrutura das procedures na seção

implementation. Em seguida, digite o código das procedures que está exibido abaixo.

170 de 332


Procedure para bloquear os Edits:

Procedure para liberar os Edits:

Criaremos ainda mais uma procedure. Esta procedure irá limpar os campos da tela.

Declare-a na seção public, pressione Shift+Ctrl+C e digite seu código:

171 de 332


Pronto, criamos as procedures básicas que irão dar suporte as operações executadas

pelos usuários. Vamos agora iniciar a programação de banco de dados. A idéia é a seguinte, a

tela será inicialmente exibida vazia, ou seja, sem nenhum registro para edição. Desta forma, o

usuário poderá clicar em Novo para poder cadastrar um novo usuário ou então pesquisar um

usuário que já esteja cadastrado através de uma tela de pesquisa e então alterá-lo ou excluí-

lo.

Insira um objeto ADOQuery ao form_usuarios e altere a propriedade Name para

ADOQuery_aux. Usaremos este objeto para executar os comandos SQL no banco de dados,

porém, precisamos configurar a propriedade Connection do ADOQuery_aux.

O ADOQuery irá utilizar a conexão fornecida pelo objeto ConexaoBD que está no

form_logon, portanto, vá em File > Use Unit... e selecione a Unit_logon. Em seguida

selecione o objeto ConexaoBD na propriedade Connection do ADOQuery_aux.

Vamos então programar o vento do botão “Novo”. Antes, declare na seção public uma

variável chamada “pk” do tipo string. Usaremos esta variável para armazenar a chave primária

(primary key) do registro corrente.

Agora sim, acesse o evento OnClick do botão “Novo” e digite o código abaixo:

172 de 332


Após o usuário clicar em Novo e digitar as informações, ele provavelmente irá salvar o

novo usuário, então vamos programar este botão.

Atenção: O botão Salvar irá inserir o novo registro ou alterar um registro já

cadastrado. Em ambas as situações poderá ocorrer um erro de banco de dados, e como já

sabemos, os erros não são muito claros para os usuários. Portanto, devemos tratar estes erros

da mesma forma que tratamos no projeto “Rodoviária” criado no módulo 2 deste curso. Acesse

a unit do form_logon e declare a função que “traduz” erros de banco de dados. Iremos

declará-la na unit_logon, pois ela é comum a todos os forms e desta maneira não precisamos

escrevê-la mais de uma vez.

Em seguida pressione Shift+Crtl+C para criar o corpo da procedure e depois digite o

código abaixo:

173 de 332


Agora volte para o form_usuarios e digite o seguinte código no evento OnClick do botão

Salvar:

procedure TForm_usuarios.btn_salvarClick(Sender: TObject); var deuerro : boolean; senha : string; begin if (edt_usuario.Text='') or (edt_nome.Text='') or (edt_senha.Text='') then begin Showmessage('Preencha todos os campos !'); end else begin senha := Form_logon.criptografa(edt_senha.Text);

if operacao = 'novo' then adoquery_aux.SQL.Text := 'INSERT INTO USUARIOS VALUES '+ '('+ QuotedStr(edt_usuario.Text) + ','+ QuotedStr(edt_nome.Text) + ','+ QuotedStr(senha) + ')'

else if operacao = 'alterar' then adoquery_aux.SQL.Text := 'UPDATE USUARIOS SET '+ ' USUARIO ='+ QuotedStr(edt_usuario.Text) + ', NOME ='+ QuotedStr(edt_nome.Text) + ', SENHA'+ QuotedStr(senha) + ' WHERE USUARIO = '+ QuotedStr(pk);

Form_logon.ConexaoBD.BeginTrans; try ADOQuery_aux.ExecSQL; deuerro := false; except on E : Exception do begin deuerro := true; if Form_logon.ErroBD(E.Message,'PK_Usuarios') = 'Sim' then ShowMessage('Usuário já cadastrado!') else if Form_logon.ErroBD(E.Message,'FK_Permissoes_Usuarios') = 'Sim' then Showmessage('Existem permissões cadastradas para este usuário!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;

if deuerro = true then begin Form_logon.ConexaoBD.RollbackTrans; end else begin Form_logon.ConexaoBD.CommitTrans; pk := edt_usuario.Text; desabilita_salvar(sender); bloqueia_campos; end; end; end;

Além de inserir um novo usuário, a pessoa que estiver usando o sistema poderá alterar

um usuário já cadastrado. Para esta operação digite o código abaixo no evento OnClick do

botão Alterar:

174 de 332


Após clicar em “Novo” ou em “Alterar”, o usuário pode querer cancelar a edição do

registro. Para esta operação digite o código abaixo no evento OnClick do botão “Cancelar”.

Além de Inserir ou Alterar um registro, o usuário pode também excluir um registro.

Para esta operação digite o código abaixo no evento OnClick do botão “Excluir”.

175 de 332


procedure TForm_usuarios.btn_excluirClick(Sender: TObject);

var deuerro : boolean;

begin

if pk = '' then

Showmessage('Impossível excluir!')

else

begin

adoquery_aux.SQL.Text := ' DELETE FROM USUARIOS ' +

' WHERE USUARIO = ' + QuotedStr(pk);

Form_logon.ConexaoBD.BeginTrans;

try

ADOQuery_aux.ExecSQL;

deuerro := false;

except

on E : Exception do

begin

deuerro := true;

if Form_logon.ErroBD(E.Message,'FK_Permissoes_Usuarios') = 'Sim' then

Showmessage('Existem permissões cadastradas para este usuário!')

else


end;

end;

if deuerro = true then

begin

Form_logon.ConexaoBD.RollbackTrans;

end

else

begin

Form_logon.ConexaoBD.CommitTrans;

pk := '';

desabilita_salvar(sender);

limpa_campos;

bloqueia_campos;

end;

end;

end;

No evento OnClick do botão Fechar digite:

Close;

176 de 332


No evento OnShow do form_usuarios digite:

Clique em Save All para salvar todas as alterações.

Após programar todos os eventos acima descritos, falta apenas criar a funcionalidade

de pesquisa de usuários e de concessão de permissões. Iremos primeiro construir a tela de

pesquisa de usuários.

Visando o re-aproveitamento de código, iremos desenvolver uma tela de pesquisa que

também servirá para pesquisar outras entidades do sistema como Cursos, Instrutores e

Alunos.

Insira um novo Form ao projeto. Configure a propriedade Name do novo Form como

“Form_pesquisa”. Aplique as mesmas configurações feitas para o form_logon para manter o

mesmo padrão. Após fazer as configurações, clique em Save All para salvar o novo form.

Salve-o como “Unit_pesquisa”.

Insira ao form_pesquisa: 1 objeto Label, 1 objeto Edit, 1 objeto DBGrid e 4 objetos

BitBtn. Altere a propriedade Caption do Label para “Digite o nome ou parte do nome”. Altere

a propriedade Name do Edit para “edt_nome”. Altere a propriedade Name dos objetos BitBtn

para btn_pesquisar, btn_limpar, btn_selecionar e btn_cancelar. Altera a propriedade Caption

dos objetos BitBtn para “Pesquisar”, “Limpar”, “Selecionar” e “Cancelar”. Altere a propriedade

Name do DBGrid para “grid_pesquisa”, expanda a propriedade Options dele e altere a opção

dgRowSelect para true.

Insira também um ADOQuery e um DataSource ao form_pesquisa.

Organize os objetos do form_pesquisa conforme mostrado abaixo:

177 de 332


Altere a propriedade Name do ADOQuery para “ADOQuery_pesquisa” e configure a

propriedade Connection para Fom_logon.ConexaoBD. Mas antes vá em File > Use Unit... e

selecione a Unit_logon.

Altere a propriedade Name do DataSource para “ds_pesquisa” e configure a

propriedade DataSet para “ADOQuery_pesquisa”. Em seguida configure a propriedade

DataSource do DBgrid para “ds_pesquisa”.

Agora declare duas (chave e sql_pesquisa) variáveis do tipo string na seção public da

unit do form_pesquisa. A variável “chave” será utilizada para armazenar a chave primária do

registro que for selecionado e a variável “sql_pesquisa” será utilizada para montar o SELECT

de pesquisa.

Agora iremos programar os eventos desta tela.

178 de 332


OnShow do Form_pesquisa:

OnClick do botão “Pesquisar”:

OnClick do botão “Limpar”:

179 de 332


OnClick do botão “Selecionar”:

OnClick do botão “Cancelar”:

Pronto, o form_pesquisa já está concluído! Salve as alterações e volte ao

form_usuarios.

Estando no form_usuarios, insira um objeto BitBtn. Altere as propriedades Name e

Caption para btn_localizar e “Localizar” respectivamente. Arrume o objeto conforme mostrado

a seguir:

180 de 332


Este botão irá chamar o form_pesquisa, portanto vá em File > Use Unit... e selecione

a unit_pesquisa. Em seguida salve as alterações clicando em Save All.

No evento OnClick do objeto btn_localizar digite o seguinte código:

Pronto, a funcionalidade de pesquisa já está concluída! Vamos agora criar a

funcionalidade de concessão de permissões às funções do sistema.

Insira um novo Form ao projeto. Configure a propriedade Name do novo Form como

“Form_permissoes” e Caption como “Permissões”. Aplique as mesmas configurações feitas

para o form_logon para manter o mesmo padrão. Após fazer as configurações, clique em Save

All para salvar o novo form. Salve-o como “Unit_permissoes”.

Após salvar o form_permissoes, insira os seguintes objetos:

2 Label’s: Altere a propriedade Caption deles para “Funções do Sistema” e

“Permissões”.

181 de 332


1 ComboBox: Altere a propriedade Name para “cb_funcoes”, Style para

“csDropDownList” e apague o conteúdo da propriedade Text.

3 BitBtn’s: Altere Name para “btn_inserir”, “btn_retirar”, “btn_fechar” respectivamente.

Alltere Caption para “+”, “-”, “Fechar” respectivamente.

2 ADOQuery’s: Altere Name para “ADOQuery_permissoes”, “ADOQuery_aux”. Vá em

File > Use Unit... e selecione a unit_logon, em seguida configure a propriedade

Connection de ambos os objetos para “Form_logon.ConexaoBD”.

1 DataSource: Altere Name para “ds_permissoes” e DataSet para

“ADOQuery_permissoes”.

1 DBgrid: Altere Name para “grid_permissoes” e DataSource para “ds_permissoes”.

expanda a propriedade Options dele e altere a opção dgRowSelect para true.

Organize os objetos semelhantemente à figura abaixo:

Vamos agora programar os eventos desta tela.

Digite o seguinte código no evento OnShow do form_permissoes:

182 de 332


Digite o seguinte código no evento OnEnter do cb_funcoes:

Digite o seguinte código no evento OnClick do btn_inserir:

183 de 332


Digite o seguinte código no evento OnClick do btn_retirar:

Digite o seguinte código no evento OnClick do btn_fechar:

Pronto, o form_permissoes já está concluído! Salve as alterações e volte ao

form_usuarios.

Estando no form_usuarios, insira um objeto BitBtn. Altere as propriedades Name e

Caption para btn_permissoes e “Permissões” respectivamente. Arrume o objeto conforme

mostrado a seguir:

184 de 332


Este botão irá chamar o form_permissoes, portanto vá em File > Use Unit... e

selecione a unit_permissoes. Em seguida salve as alterações clicando em Save All.

No evento OnClick do objeto btn_permissoes digite o seguinte código:

Pronto, a funcionalidade de permissões já está concluída! Vamos agora alterar o

form_menu para chamar o form_usuarios. Acesse o form_menu e digite o seguinte no evento

OnClick do botão “Controle de Acesso”:

185 de 332


Aproveitando que estamos alterando o form_menu, digite o seguinte código no evento

OnClick do botão Fechar do menu:

Agora é só executar o projeto e testar tudo o que foi criado!

186 de 332


Módulo 5:

Criando as Funcionalidades da Aplicação

ste módulo é um dos mais importantes deste curso, pois aqui iremos

criar as funcionalidades da aplicação. Para o usuário, o que realmente

importa é o que o sistema faz. Ele não quer saber como foi

desenvolvido a aplicação e sim qual o trabalho que ela executa. Nesta parte do

curso, iremos construir as opções que serão utilizadas pelo usuário. Neste

módulo criaremos os cadastros de todos os elementos envolvidos no contexto

do sistema e todas as operações necessárias à movimentação de cada

elemento como a realização de matrículas de alunos, o lançamento de aulas e

o pagamento dos instrutores.

E

187 de 332


Cadastro de Cursos

O cadastro de cursos, como o próprio nome diz, consiste na funcionalidade que

permitirá ao usuário cadastrar os cursos que são oferecidos na escola de informática. Na

verdade, esta funcionalidade é a maneira interativa e amigável que o usuário irá dispor para

fazer a manutenção das informações contidas na tabela “Cursos” do banco de dados

“Academico”.


Configure as propriedades Name e Caption do novo Form como “Form_cursos” e

“Cursos” respectivamente. Aplique as mesmas configurações feitas para o form_logon para


form. Salve-o como “Unit_cursos”.

188 de 332


Insira 6 objetos BitBtn ao form_cursos. Arrume-os lado-a-lado e altere as propriedades

Name e Caption de cada um deles conforme a tabela abaixo:

Name Caption

btn_novo Novo

btn_salvar Salvar

btn_alterar Alterar


btn_excluir Excluir

btn_fechar Fechar

Seu form deve ficar semelhante ao exibido a seguir:

Vamos agora criar as procedures e variáveis que fazem o controle da tela, àquelas que

habilitam/desabilitam botões e os campos da tela conforme fizemos no cadastro de usuários.

Declare as variáveis e procedures conforme a imagem abaixo:

Em seguida pressione Shift+Ctrl+C para criar o corpo das procedures.

189 de 332


Agora digite o código de cada uma delas

Procedure “bloqueia_campos”:

190 de 332


Procedure “desabilita_salvar”:

Procedure “habilita_salvar”:

191 de 332


Procedure “libera_campos”:

Procedure “limpa_campos”:

Após programar as procedures, insira ao form_cursos 2 objetos do tipo Edit e 2 objetos

do tipo Label. Organize-os conforme mostrado abaixo:

192 de 332


Renomeie os Edits para edt_cod e edt_nome além de limpar o conteúdo da propriedade

Text de ambos. Configure a propriedade MaxLength dos Edits para 3 e 20 respectivamente.

Altere também a propriedade Caption dos labels conforme exibido na imagem acima.

Insira um objeto ADOQuery ao form_cursos e altere a propriedade Name para

ADOQuery_aux. Usaremos este objeto para executar os comandos SQL no banco de dados,

porém, precisamos configurar a propriedade Connection do ADOQuery_aux.

O ADOQuery irá utilizar a conexão fornecida pelo objeto ConexaoBD que está no

form_logon, portanto, vá em File > Use Unit... e selecione a Unit_logon. Em seguida


Agora vamos programar todos os eventos do form_cursos. Os códigos serão

praticamente os mesmos utilizados para o cadastro de usuários.

Código do evento OnShow do Form_cursos:

Código do evento OnClick do botão “Novo” do Form_cursos:

193 de 332


Código do evento OnClick do botão “Salvar” do Form_cursos:

procedure TForm_cursos.btn_salvarClick(Sender: TObject); var deuerro : boolean; begin if (edt_cod.Text='') or (edt_nome.Text='') then begin Showmessage('Preencha todos os campos !'); end else begin if operacao = 'novo' then adoquery_aux.SQL.Text := 'INSERT INTO CURSOS VALUES '+ '('+ QuotedStr(edt_cod.Text) + ','+ QuotedStr(edt_nome.Text) + ')'

else if operacao = 'alterar' then adoquery_aux.SQL.Text := 'UPDATE CURSOS SET '+ ' COD_CURSO ='+ QuotedStr(edt_cod.Text) + ', NOME ='+ QuotedStr(edt_nome.Text) + ' WHERE COD_CURSO = '+ QuotedStr(pk);

Form_logon.ConexaoBD.BeginTrans; try ADOQuery_aux.ExecSQL; deuerro := false; except on E : Exception do begin deuerro := true; if Form_logon.ErroBD(E.Message,'PK_Cursos') = 'Sim' then ShowMessage('Curso já cadastrado!') else if Form_logon.ErroBD(E.Message,'FK_Turmas_Cursos') = 'Sim' then Showmessage('Existem turmas cadastradas para este curso!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;

if deuerro = true then begin Form_logon.ConexaoBD.RollbackTrans; end else begin Form_logon.ConexaoBD.CommitTrans; pk := edt_cod.Text; desabilita_salvar(sender); bloqueia_campos; end; end; end;

Código do evento OnClick do botão “Alterar” do Form_cursos:

194 de 332


Código do evento OnClick do botão “Cancelar” do Form_cursos:

Código do evento OnClick do botão “Excluir” do Form_cursos:

procedure TForm_cursos.btn_excluirClick(Sender: TObject); var deuerro : boolean; begin if pk = '' then Showmessage('Impossível excluir!') else begin adoquery_aux.SQL.Text := ' DELETE FROM CURSOS ' + ' WHERE COD_CURSO = ' + QuotedStr(pk); Form_logon.ConexaoBD.BeginTrans;

try ADOQuery_aux.ExecSQL; deuerro := false; except on E : Exception do begin deuerro := true; if Form_logon.ErroBD(E.Message,'FK_Turmas_Cursos') = 'Sim' then Showmessage('Existem turmas cadastradas para este curso!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;

if deuerro = true then begin Form_logon.ConexaoBD.RollbackTrans; end else begin Form_logon.ConexaoBD.CommitTrans; pk := ''; desabilita_salvar(sender); limpa_campos; bloqueia_campos; end; end; end;

195 de 332


Código do evento OnClick do botão “Fechar” do Form_cursos:


de pesquisa de cursos. A tela de pesquisa criada durante a criação do cadastro de usuários foi

desenvolvida de forma genérica, ou seja, foi construída de maneira que seja possível utilizá-la

em outras situações. Iremos então utilizar o form_pesquisa também aqui no cadastro de

cursos. Portanto, insira um objeto BitBtn ao form_cursos e altere as propriedades Name e


a seguir:




196 de 332


Pronto, o cadastro de cursos já está concluído! Vamos agora alterar o form_menu para

chamar o form_cursos. Acesse o form_menu e digite o seguinte no evento OnClick do botão

“Cadastro de Cursos”:


197 de 332


Cadastro de Instrutores

O cadastro de instrutores, como o próprio nome diz, consiste na funcionalidade que

permitirá ao usuário cadastrar os instrutores que trabalham na escola de informática. Na

verdade, esta funcionalidade é a maneira interativa e amigável que o usuário irá dispor para

fazer a manutenção das informações contidas na tabela “Instrutores” do banco de dados

“Academico”.


Configure as propriedades Name e Caption do novo Form como “Form_instrutores” e

“Instrutores” respectivamente. Aplique as mesmas configurações feitas para o form_logon

para manter o mesmo padrão. Após fazer as configurações, clique em Save All para salvar o

novo form. Salve-o como “Unit_instrutores”.

198 de 332


Insira 6 objetos BitBtn ao form_instrutores. Arrume-os lado-a-lado e altere as


Name Caption

btn_novo Novo

btn_salvar Salvar

btn_alterar Alterar


btn_excluir Excluir

btn_fechar Fechar



habilitam/desabilitam botões e os campos da tela conforme fizemos no cadastro de usuários e

no cadastro de cursos. Declare as variáveis e procedures conforme a imagem abaixo:


199 de 332




200 de 332




201 de 332




Após programar as procedures, insira ao form_instrutores 5 objetos do tipo Edit e 5


202 de 332


Renomeie os Edits para edt_cod, edt_nome, edt_idade, edt_telefone e edt_sexo além

de limpar o conteúdo da propriedade Text de ambos. Configure a propriedade MaxLength dos

Edits para 10, 30, 3, 14 e 1 respectivamente. Altere também a propriedade Caption dos labels

conforme exibido na imagem acima.

Atenção: O código do instrutor é um número seqüencial gerado automaticamente pelo

SQL Server. Sendo assim, o usuário não poderá digitar no campo “Código Instrutor”, devemos

então alterar a procedure “libera_campos” para que ela não libere o objeto “edt_cod”. Acesse

a procedure libera_campos da unit_instrutores e faça a seguinte alteração:

Continuando a construção do cadastro de instrutores... insira um objeto ADOQuery ao

form_instrutores e altere a propriedade Name para ADOQuery_aux. Usaremos este objeto

para executar os comandos SQL no banco de dados, porém, precisamos configurar a

propriedade Connection do ADOQuery_aux. O ADOQuery irá utilizar a conexão fornecida pelo

203 de 332


objeto ConexaoBD que está no form_logon, portanto, vá em File > Use Unit... e selecione a

Unit_logon. Em seguida selecione o objeto ConexaoBD na propriedade Connection do

ADOQuery_aux.

Agora vamos programar todos os eventos do form_instrutores. Os códigos serão

praticamente os mesmos utilizados para os cadastros de usuários e cursos.

Código do evento OnShow do Form_instrutores:

Código do evento OnClick do botão “Novo” do Form_instrutores:

204 de 332


Código do evento OnClick do botão “Salvar” do Form_instrutores:

procedure TForm_instrutores.btn_salvarClick(Sender: TObject); var deuerro : boolean; begin if (edt_nome.Text='') or (edt_idade.Text='') or (edt_telefone.Text='') or (edt_sexo.Text='') then begin Showmessage('Preencha todos os campos !'); end else begin if operacao = 'novo' then adoquery_aux.SQL.Text := 'INSERT INTO INSTRUTORES ' + '(NOME, IDADE, TELEFONE, SEXO) VALUES '+ '('+ QuotedStr(edt_nome.Text) + ','+ edt_idade.Text + ','+ QuotedStr(edt_telefone.Text) + ','+ QuotedStr(edt_sexo.Text) + ')'

else if operacao = 'alterar' then adoquery_aux.SQL.Text := 'UPDATE INSTRUTORES SET '+ ' NOME ='+ QuotedStr(edt_nome.Text) + ', IDADE ='+ edt_idade.Text + ', TELEFONE ='+ QuotedStr(edt_telefone.Text) + ', SEXO ='+ QuotedStr(edt_sexo.Text) + ' WHERE COD_INSTRUTOR = '+ pk;

Form_logon.ConexaoBD.BeginTrans; try ADOQuery_aux.ExecSQL; deuerro := false; except on E : Exception do begin deuerro := true; if Form_logon.ErroBD(E.Message,'PK_Instrutores') = 'Sim' then ShowMessage('Instrutor já cadastrado!') else if Form_logon.ErroBD(E.Message,'FK_Turmas_Instrutores') = 'Sim' then Showmessage('Existem turmas cadastradas para este Instrutor!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;

if deuerro = true then begin Form_logon.ConexaoBD.RollbackTrans; end else begin Form_logon.ConexaoBD.CommitTrans; if operacao = 'novo' then begin ADOQuery_aux.SQL.Text:='SELECT COD_INSTRUTOR FROM INSTRUTORES ' + 'WHERE NOME = '+ QuotedStr(edt_nome.Text) + 'AND IDADE ='+ edt_idade.Text + 'AND TELEFONE ='+ QuotedStr(edt_telefone.Text) + 'AND SEXO ='+ QuotedStr(edt_sexo.Text); ADOQuery_aux.Open; pk := ADOQuery_aux.fieldbyname('COD_INSTRUTOR').AsString; ADOQuery_aux.Close; end; desabilita_salvar(sender); bloqueia_campos; edt_cod.Text := pk; end; end; end;

205 de 332


Código do evento OnClick do botão “Alterar” do Form_instrutores:

Código do evento OnClick do botão “Cancelar” do Form_instrutores:

206 de 332


Código do evento OnClick do botão “Excluir” do Form_instrutores:

procedure TForm_instrutores.btn_excluirClick(Sender: TObject); var deuerro : boolean; begin if pk = '' then Showmessage('Impossível excluir!') else begin adoquery_aux.SQL.Text := ' DELETE FROM INSTRUTORES ' + ' WHERE COD_INSTRUTOR = ' + pk; Form_logon.ConexaoBD.BeginTrans;

try ADOQuery_aux.ExecSQL; deuerro := false; except on E : Exception do begin deuerro := true; if Form_logon.ErroBD(E.Message,'FK_Turmas_Instrutores') = 'Sim' then Showmessage('Existem turmas cadastradas para este instrutor!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;


Código do evento OnClick do botão “Fechar” do Form_instrutores:


de pesquisa de instrutores. Iremos utilizar o form_pesquisa também aqui no cadastro de

instrutores. Portanto, insira um objeto BitBtn ao form_instrutores e altere as propriedades

Name e Caption para btn_localizar e “Localizar” respectivamente. Arrume o objeto conforme

mostrado a seguir:

207 de 332





Pronto, o cadastro de instrutores já está concluído! Vamos agora alterar o form_menu

para chamar o form_instrutores. Acesse o form_menu e digite o seguinte no evento OnClick do

botão “Cadastro de Instrutores”:

208 de 332



209 de 332


Cadastro de Turmas

O cadastro de turmas será bem semelhante aos cadastros já criados até aqui.

Entretanto, o cadastro de Turmas possui algumas particularidades em relação aos cadastros de

usuários, cursos e instrutores. O cadastro de turmas depende de registros de outras tabelas e,

desta forma, precisaremos manipular as tabelas de Cursos e Instrutores além da tabela

“Turmas” neste cadastro. Mãos à obra!


Configure as propriedades Name e Caption do novo Form como “Form_turmas” e

“Turmas” respectivamente. Aplique as mesmas configurações feitas para o form_logon para


form. Salve-o como “Unit_turmas”.

210 de 332


Insira 6 objetos BitBtn ao form_turmas. Arrume-os lado-a-lado e altere as propriedades

Name e Caption de cada um deles conforme a tabela abaixo:

Name Caption

btn_novo Novo

btn_salvar Salvar

btn_alterar Alterar


btn_excluir Excluir

btn_fechar Fechar



habilitam/desabilitam botões e os campos da tela conforme fizemos nos cadastros anteriores.

No cadastro de turmas teremos algumas variáveis a mais. Declare as variáveis e procedures

conforme a imagem abaixo:

211 de 332





212 de 332




213 de 332




Após programar as procedures, insira ao form_turmas 4 objetos do tipo Edit e 4 objetos

do tipo Label. Organize-os conforme mostrado abaixo:

214 de 332


Renomeie os Edits para edt_cod, edt_valor, edt_curso e edt_instrutor além de limpar o

conteúdo da propriedade Text de ambos. Configure a propriedade MaxLength dos Edits para

9, 6, 20 e 30 respectivamente. Altere também a propriedade Caption dos labels conforme

exibido na imagem acima.

Atenção: Os campos “Curso” e “Instrutor” não serão digitados pelo usuário. Eles serão

selecionados através de pesquisa. Sendo assim, o usuário não poderá digitar nestes campos e,

portanto, devemos alterar a procedure “libera_campos” para que ela não libere os objetos

“edt_curso” e “edt_instrutor”. Acesse a procedure libera_campos da unit_turmas e faça a

seguinte alteração:

215 de 332


Após fazer a alteração descrita acima, insira um objeto ADOQuery ao form_turmas e

altere a propriedade Name para ADOQuery_aux. Usaremos este objeto para executar os

comandos SQL no banco de dados, porém, precisamos configurar a propriedade Connection

do ADOQuery_aux. O ADOQuery irá utilizar a conexão fornecida pelo objeto ConexaoBD que

está no form_logon, portanto, vá em File > Use Unit... e selecione a Unit_logon. Em seguida


Para que o usuário possa selecionar o curso e o instrutor da turma que ele estiver

cadastrando ou alterando, iremos inserir 2 objetos BitBtn. Renomeie os objetos para

“btn_curso” e “btn_instrutor”, em seguida selecione uma imagem para os botões através da

propriedade Glyph. Organize estes novos botões conforme mostrado da imagem abaixo:

Estes novos botões só devem estar habilitados quando o form_turmas estiver em modo

de edição. Sendo assim, devemos alterar as procedures habilita_gravar e desabilita_gravar

contemplando os novos objetos.

216 de 332


Agora vamos programar todos os eventos do form_turmas começando pelos novos

botões. Estes novos botões farão uso do form_pesquisa e desta forma é necessário criar a

referência da unit_pesquisa na unit_turmas através da cláusula Uses. Para isto vá em File >

Use Unit... e selecione a unit_pesquisa.

Código do evento OnClick do objeto “btn_curso”:

217 de 332


Código do evento OnClick do objeto “btn_instrutor”:

Código do evento OnShow do Form_turmas:

Código do evento OnClick do botão “Novo” do Form_turmas:

218 de 332


Código do evento OnClick do botão “Salvar” do Form_turmas:

procedure TForm_turmas.btn_salvarClick(Sender: TObject); var deuerro : boolean; begin if (edt_cod.Text='') or (edt_valor.Text='') or (cod_curso='') or (cod_instrutor='') then begin Showmessage('Preencha todos os campos !'); end else begin if operacao = 'novo' then adoquery_aux.SQL.Text := 'INSERT INTO TURMAS VALUES ' + '('+ QuotedStr(edt_cod.Text) + ','+ QuotedStr(cod_curso) + ','+ cod_instrutor + ','+ edt_valor.Text + ')'

else if operacao = 'alterar' then adoquery_aux.SQL.Text := 'UPDATE TURMAS SET '+ ' COD_TURMA ='+ QuotedStr(edt_cod.Text) + ', COD_CURSO ='+ QuotedStr(cod_curso) + ', COD_INSTRUTOR ='+ cod_instrutor + ', VALOR_AULA ='+ edt_valor.Text + ' WHERE COD_TURMA = '+ QuotedStr(pk);

Form_logon.ConexaoBD.BeginTrans; try ADOQuery_aux.ExecSQL; deuerro := false; except on E : Exception do begin deuerro := true; if Form_logon.ErroBD(E.Message,'PK_Turmas') = 'Sim' then ShowMessage('Turma já cadastrada!') else if Form_logon.ErroBD(E.Message,'FK_Turmas_Cursos') = 'Sim' then Showmessage('Curso inválido!') else if Form_logon.ErroBD(E.Message,'FK_Turmas_Instrutores') = 'Sim' then Showmessage('Instrutor inválido!') else if Form_logon.ErroBD(E.Message,'FK_Matriculas_Turmas') = 'Sim' then Showmessage('Existem alunos matriculados nesta turma!') else if Form_logon.ErroBD(E.Message,'FK_Aulas_Turmas') = 'Sim' then Showmessage('Existem aulas cadastradas para esta turma!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;

if deuerro = true then begin Form_logon.ConexaoBD.RollbackTrans; end else begin Form_logon.ConexaoBD.CommitTrans; pk := edt_cod.Text; desabilita_salvar(sender); bloqueia_campos; end; end; end;

219 de 332


Código do evento OnClick do botão “Alterar” do Form_turmas:

Código do evento OnClick do botão “Cancelar” do Form_turmas:

220 de 332


Código do evento OnClick do botão “Excluir” do Form_turmas:

procedure TForm_turmas.btn_excluirClick(Sender: TObject); var deuerro : boolean; begin if pk = '' then Showmessage('Impossível excluir!') else begin adoquery_aux.SQL.Text := ' DELETE FROM TURMAS ' + ' WHERE COD_TURMA = ' + QuotedStr(pk); Form_logon.ConexaoBD.BeginTrans;

try ADOQuery_aux.ExecSQL; deuerro := false; except on E : Exception do begin deuerro := true; if Form_logon.ErroBD(E.Message,'FK_Matriculas_Turmas') = 'Sim' then Showmessage('Existem alunos matriculados nesta turma!') else if Form_logon.ErroBD(E.Message,'FK_Aulas_Turmas') = 'Sim' then Showmessage('Existem aulas cadastradas para esta turma!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;

if deuerro = true then begin Form_logon.ConexaoBD.RollbackTrans; end else begin Form_logon.ConexaoBD.CommitTrans; pk := ''; cod_curso := ''; cod_instrutor := ''; desabilita_salvar(sender); limpa_campos; bloqueia_campos; end; end; end;

Código do evento OnClick do botão “Fechar” do Form_turmas:

O que acabamos de fazer foi programar todos os eventos da tela de cadastro de

turmas. Entretanto nosso trabalho ainda não terminou, pois além de construir a funcionalidade

de pesquisa de turmas, devemos dar um tratamento especial ao campo “Valor de cada aula”.

221 de 332


O campo Valor de cada aula será utilizado para o usuário informar valores numéricos

e, portanto devemos formatá-lo de maneira apropriada. Devemos formatar este campo para

exibição na tela, edição do valor e para gravá-lo no banco, ou seja, este campo será formatado

de 3 maneiras diferentes dependendo da situação.

Para exibir o valor na tela devemos formatá-lo com os símbolos de casas decimais (,),

milhar (.) e monetário (R$). Quando o usuário for editar o valor, devemos retirar os símbolos

de milhar (.) e monetário (R$). Já para a gravação no banco de dados devemos trocar a

vírgula (,) por ponto (.), pois os gerenciadores de banco de dados (incluindo o SQL Server)

utilizam como símbolo decimal o ponto (.) seguindo o padrão americano. Além disso, também

devemos retirar os símbolos de milhar e monetário.

Vamos então criar uma função que faça as devidas formatações de acordo com a

situação. Declare uma função chamada “formata_valor” que receberá dois parâmetros: o valor

a ser formatado e o destino da formatação (Tela, Edição ou Banco de Dados). Esta função

retornará uma string com o valor formatado.

Após declarar a função, pressione a combinação de teclas Shift+Ctrl+C para o Delphi

criar a estrutura da função na seção implementation.

222 de 332


Agora digite o código da função que está exibido da imagem abaixo:

Com a função criada, iremos programar os eventos OnEnter e OnExit do edt_valor

além de alterar o evento OnClick do botão “Salvar”. O evento OnEnter de um objeto é

executado quando este objeto recebe o foco do cursor e o evento OnExit ocorre quando o

objeto perde o foco do cursor.

No evento OnEnter do edt_valor iremos executar a função para formatar o valor para

edição. No evento OnExit iremos executar a função para formatar o valor para exibição. Já no

OnClick do botão “Salvar” iremos executar a função para formatar o valor para gravação no

banco.

Veja a seguir o código destes eventos:

223 de 332


OnEnter do objeto edt_valor:

OnExit do objeto edt_valor:

Evento OnClick do botão “Salvar” (altere as linhas em destaque):

224 de 332



de pesquisa de turmas. Para este cadastro não iremos utilizar o form_pesquisa, pois

precisaremos de uma tela de pesquisa mais rebuscada e desta forma a tela genérica não nos

atende. Vamos criar uma tela de específica para pesquisa de turmas.


Configure a propriedade Name do novo Form como “Form_pesquisa_turmas” e

Caption como “Pesquisa Turma”. Aplique as mesmas configurações feitas para o form_logon


novo form. Salve-o como “Unit_pesquisa_turmas”.

Insira ao form_pesquisa_turmas: 2 objetos Label, 1 objeto ComboBox, 1 objeto Edit,

1 objeto DBGrid e 4 objetos BitBtn. Altere a propriedade Caption dos objetos Label para

“Campo da pesquisa:” e “Texto a ser pesquisado”. Altere a propriedade Name do ComboBox

para “cb_campo” e do Edit para “edt_texto”. Limpe as propriedades Text do Edit e do

ComboBox. Acesse a propriedade Items do ComboBox e digite as opções que serão listadas

para o usuário. Veja a imagem abaixo:

225 de 332


Altere a propriedade Name dos objetos BitBtn para btn_pesquisar, btn_limpar,

btn_selecionar e btn_cancelar. Altera a propriedade Caption dos objetos BitBtn para

“Pesquisar”, “Limpar”, “Selecionar” e “Cancelar”. Altere a propriedade Name do DBGrid para

“grid_pesquisa_turma”, expanda a propriedade Options dele e altere a opção dgRowSelect

para True.

Insira também um ADOQuery e um DataSource ao form_pesquisa_turma. Organize os

objetos do form_pesquisa_turma conforme mostrado abaixo:

Altere a propriedade Name do ADOQuery para “ADOQuery_pesquisa_turma” e

configure a propriedade Connection para Fom_logon.ConexaoBD. Mas antes vá em File >

Use Unit... e selecione a Unit_logon.

Altere a propriedade Name do DataSource para “ds_pesquisa_turma” e configure a

propriedade DataSet para “ADOQuery_pesquisa_turma”. Em seguida configure a propriedade

DataSource do DBgrid para “ds_pesquisa_turma”.

Agora declare uma variável chamada “chave” do tipo string na seção public da unit do

form_pesquisa_turmas. A variável “chave” será utilizada para armazenar a chave primária do

registro que for selecionado.

226 de 332


Agora iremos programar os eventos desta tela.

Evento OnShow do Form_pesquisa_turma:

Evento OnClick do botão “Pesquisar”:

procedure TForm_pesquisa_turmas.btn_pesquisaClick(Sender: TObject); var condicao : string; sql : string; begin condicao := ''; if cb_campo.ItemIndex = 0 then condicao := ' WHERE TURMAS.COD_TURMA LIKE ' + QuotedStr(edt_texto.Text) else if cb_campo.ItemIndex = 1 then condicao := ' WHERE CURSOS.NOME LIKE ' + QuotedStr(edt_texto.Text) else if cb_campo.ItemIndex = 2 then condicao := ' WHERE INSTRUTORES.NOME LIKE ' + QuotedStr(edt_texto.Text);

if (condicao='') or (edt_texto.Text='') then Showmessage('Pesquisa inválida!') else begin sql := 'SELECT TURMAS.COD_TURMA, ' + ' CURSOS.NOME AS CURSO, ' + ' INSTRUTORES.NOME AS INSTRUTOR ' + 'FROM TURMAS ' + 'INNER JOIN CURSOS '+ ' ON TURMAS.COD_CURSO = CURSOS.COD_CURSO '+ 'INNER JOIN INSTRUTORES '+ ' ON TURMAS.COD_INSTRUTOR = INSTRUTORES.COD_INSTRUTOR ';

ADOQuery_pesquisa_turma.Close; ADOQuery_pesquisa_turma.SQL.Text := sql + condicao; ADOQuery_pesquisa_turma.Open; end; end;

227 de 332


Evento OnClick do botão “Limpar”:

Evento OnClick do botão “Selecionar”:

Evento OnClick do botão “Cancelar”:

Pronto, o form_pesquisa_turmas já está concluído! Salve as alterações e volte ao

form_turmas.

228 de 332


Estando no form_turmas, insira um objeto BitBtn. Altere as propriedades Name e


a seguir:

Este botão irá chamar o form_pesquisa_turmas, portanto vá em File > Use Unit... e

selecione a unit_pesquisa_turmas. Em seguida salve as alterações clicando em Save All.


procedure TForm_turmas.btn_localizarClick(Sender: TObject); var sql : string; begin limpa_campos; bloqueia_campos; desabilita_salvar(sender);

Form_pesquisa_turmas.ShowModal; if Form_pesquisa_turmas.chave <> '' then begin pk := Form_pesquisa_turmas.chave;

sql := 'SELECT TURMAS.COD_TURMA, TURMAS.VALOR_AULA, ' + ' CURSOS.NOME AS CURSO, CURSOS.COD_CURSO, ' + ' INSTRUTORES.NOME AS INSTRUTOR, INSTRUTORES.COD_INSTRUTOR ' + 'FROM TURMAS ' + 'INNER JOIN CURSOS '+ ' ON TURMAS.COD_CURSO = CURSOS.COD_CURSO '+ 'INNER JOIN INSTRUTORES '+ ' ON TURMAS.COD_INSTRUTOR = INSTRUTORES.COD_INSTRUTOR ' + ' WHERE TURMAS.COD_TURMA = ' + QuotedStr(pk);

ADOQuery_aux.SQL.Text := sql; ADOQuery_aux.Open;

edt_cod.Text := ADOQuery_aux.fieldbyname('COD_TURMA').AsString; edt_valor.Text := ADOQuery_aux.fieldbyname('VALOR_AULA').AsString; edt_valor.Text := formata_valor(edt_valor.Text,'T'); edt_curso.Text := ADOQuery_aux.fieldbyname('CURSO').AsString; edt_instrutor.Text := ADOQuery_aux.fieldbyname('INSTRUTOR').AsString; cod_curso := ADOQuery_aux.fieldbyname('COD_CURSO').AsString; cod_instrutor := ADOQuery_aux.fieldbyname('COD_INSTRUTOR').AsString; end; end;

229 de 332


Pronto, a funcionalidade de pesquisa de turmas já está concluída! Vamos agora alterar

o form_menu para chamar o form_turmas. Acesse o form_menu e digite o seguinte no evento

OnClick do botão “Cadastro de Turmas”:


230 de 332


Cadastro de Alunos

O cadastro de alunos é a funcionalidade responsável por fazer a manutenção da tabela

“Alunos” do banco de dados “Academico”. Neste capítulo iremos construir esta funcionalidade.


Configure as propriedades Name e Caption do novo Form como “Form_alunos” e

“Alunos” respectivamente. Aplique as mesmas configurações feitas para o form_logon para


form. Salve-o como “Unit_alunos”.

231 de 332


O cadastro de alunos é idêntico ao cadastro de instrutores. Eles possuem as mesmas

funcionalidades. As tabelas “Alunos” e “Instrutores” possuem os mesmos campos sendo a

única exceção o nome do campo da chave primária que na tabela de Instrutores é

“cod_instrutor” enquanto na tabela Alunos é “cod_aluno”. Sendo assim, repita os mesmos

procedimentos descritos no capítulo referente ao cadastro de instrutores aplicando as devidas

modificações.

Os códigos dos eventos OnClick dos botões “Salvar”, “Excluir” e “Localizar” devem ser

ajustados para a tabela Alunos.

Abaixo segue os códigos destes botões:

OnClick do botão “Salvar” do Form_alunos:

procedure TForm_alunos.btn_salvarClick(Sender: TObject); var deuerro : boolean; begin if (edt_nome.Text='') or (edt_idade.Text='') or (edt_telefone.Text='') or (edt_sexo.Text='') then begin Showmessage('Preencha todos os campos !'); end else begin if operacao = 'novo' then adoquery_aux.SQL.Text := 'INSERT INTO ALUNOS ' + '(NOME, IDADE, TELEFONE, SEXO) VALUES '+ '('+ QuotedStr(edt_nome.Text) + ','+ edt_idade.Text + ','+ QuotedStr(edt_telefone.Text) + ','+ QuotedStr(edt_sexo.Text) + ')'

else if operacao = 'alterar' then adoquery_aux.SQL.Text := 'UPDATE ALUNOS SET '+ ' NOME ='+ QuotedStr(edt_nome.Text) + ', IDADE ='+ edt_idade.Text + ', TELEFONE ='+ QuotedStr(edt_telefone.Text) + ', SEXO ='+ QuotedStr(edt_sexo.Text) + ' WHERE COD_ALUNO = '+ pk;

Form_logon.ConexaoBD.BeginTrans; try ADOQuery_aux.ExecSQL; deuerro := false; except on E : Exception do begin deuerro := true; if Form_logon.ErroBD(E.Message,'PK_Alunos') = 'Sim' then ShowMessage('Aluno já cadastrado!') else if Form_logon.ErroBD(E.Message,'FK_Matriculas_Alunos') = 'Sim' then Showmessage('Existem matrículas cadastradas para este aluno!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;

if deuerro = true then begin Form_logon.ConexaoBD.RollbackTrans; end else

232 de 332


begin Form_logon.ConexaoBD.CommitTrans; if operacao = 'novo' then begin ADOQuery_aux.SQL.Text:='SELECT COD_ALUNO FROM ALUNOS ' + 'WHERE NOME = '+ QuotedStr(edt_nome.Text) + 'AND IDADE ='+ edt_idade.Text + 'AND TELEFONE ='+ QuotedStr(edt_telefone.Text) + 'AND SEXO ='+ QuotedStr(edt_sexo.Text); ADOQuery_aux.Open; pk := ADOQuery_aux.fieldbyname('COD_ALUNO').AsString; ADOQuery_aux.Close; end; desabilita_salvar(sender); bloqueia_campos; edt_cod.Text := pk; end; end; end;

OnClick do botão “Excluir” do Form_alunos:

procedure TForm_alunos.btn_excluirClick(Sender: TObject); var deuerro : boolean; begin if pk = '' then Showmessage('Impossível excluir!') else begin adoquery_aux.SQL.Text := ' DELETE FROM ALUNOS ' + ' WHERE COD_ALUNO = ' + pk; Form_logon.ConexaoBD.BeginTrans;

try ADOQuery_aux.ExecSQL; deuerro := false; except on E : Exception do begin deuerro := true; if Form_logon.ErroBD(E.Message,'FK_Matriculas_Alunos') = 'Sim' then Showmessage('Existem matrículas cadastradas para este aluno!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;


233 de 332


OnClick do botão “Localizar” do Form_alunos:

Após concluir o cadastro de alunos, altere o form_menu para chamar o form_alunos.

Acesse o form_menu e digite o seguinte no evento OnClick do botão “Cadastro de Alunos”:

234 de 332



235 de 332


Cadastro de Matrículas

O cadastro de matrículas consiste na funcionalidade que permitirá ao usuário matricular

os alunos nas turmas. Como todos os demais cadastros, esta funcionalidade será responsável

por fazer a manutenção de uma tabela do banco de dados “Academico”. Neste caso será a

tabela “Matriculas”. Para fazer uma matrícula, o usuário deve selecionar o aluno e a turma em

que o aluno deseja se matricular. Portanto, nesta tela utilizaremos outras tabelas além da

tabela principal do cadastro. Chega de conversa e vamos ao trabalho!


Configure as propriedades Name e Caption do novo Form como “Form_matriculas” e

“Matrículas” respectivamente. Aplique as mesmas configurações feitas para o form_logon para


form. Salve-o como “Unit_matriculas”.

236 de 332


Insira 6 objetos BitBtn ao form_matriculas. Arrume-os lado-a-lado e altere as


Name Caption

btn_novo Novo

btn_salvar Salvar

btn_alterar Alterar


btn_excluir Excluir

btn_fechar Fechar



habilitam/desabilitam botões e os campos da tela conforme fizemos nos cadastros anteriores.

No cadastro de matrículas teremos duas variáveis “pk”, pois a chave primária é composta pelo

código do aluno e pelo código da turma. Faça as seguintes declarações:


237 de 332


Agora digite o código de cada uma delas.


238 de 332




239 de 332




Após programar as procedures, insira ao form_matriculas 2 objetos do tipo Edit e 2


240 de 332


Renomeie os Edits para edt_aluno, e edt_turma além de limpar o conteúdo da

propriedade Text de ambos. Altere também a propriedade Caption dos labels conforme

exibido na imagem acima.

Atenção: Os campos “Aluno” e “Turma” não serão digitados pelo usuário. Eles serão

selecionados através de pesquisa. Sendo assim, o usuário não poderá digitar nestes campos e,

portanto, devemos alterar a procedure “libera_campos” para que ela não libere os objetos

“edt_aluno” e “edt_turma”. Acesse a procedure libera_campos da unit_matriculas e faça a

seguinte alteração:

Após fazer a alteração descrita acima, insira um objeto ADOQuery ao form_matriculas e

altere a propriedade Name para ADOQuery_aux. Usaremos este objeto para executar os

comandos SQL no banco de dados, porém, precisamos configurar a propriedade Connection

do ADOQuery_aux. O ADOQuery irá utilizar a conexão fornecida pelo objeto ConexaoBD que

está no form_logon, portanto, vá em File > Use Unit... e selecione a Unit_logon. Em seguida


Para que o usuário possa selecionar o aluno e a turma, iremos inserir 2 objetos BitBtn.

Renomeie os objetos para “btn_aluno” e “btn_turma”, em seguida selecione uma imagem para

os botões através da propriedade Glyph. Organize estes novos botões conforme mostrado da

imagem abaixo:

241 de 332


Estes novos botões só devem estar habilitados quando o form_matriculas estiver em

modo de edição. Sendo assim, devemos alterar as procedures habilita_gravar e

desabilita_gravar contemplando os novos objetos.

242 de 332


Agora vamos programar todos os eventos do form_matriculas começando pelos novos

botões.

Os objetos “btn_aluno” e “btn_turma” farão uso do form_pesquisa e

form_pesquisa_turmas respectivamente. Desta forma é necessário criar a referência da

unit_pesquisa e da unit_pesquisa_turmas na unit_matriculas através da cláusula Uses. Para

isto vá em File > Use Unit... e selecione a unit_pesquisa e a unit_pesquisa_turmas.

Código do evento OnClick do objeto “btn_aluno”:

Código do evento OnClick do objeto “btn_turma”:

243 de 332


Código do evento OnShow do Form_matriculas:

Código do evento OnClick do botão “Novo” do Form_matriculas:

244 de 332


Código do evento OnClick do botão “Salvar” do Form_matriculas:

procedure TForm_matriculas.btn_salvarClick(Sender: TObject); var deuerro : boolean; begin if (cod_aluno='') or (edt_turma.Text='') then begin Showmessage('Informe todos os campos !'); end else begin if operacao = 'novo' then adoquery_aux.SQL.Text := 'INSERT INTO MATRICULAS VALUES ' + '('+ QuotedStr(cod_turma) + ','+ cod_aluno + ')'

else if operacao = 'alterar' then adoquery_aux.SQL.Text := 'UPDATE MATRICULAS SET '+ ' COD_TURMA ='+ QuotedStr(cod_turma) + ' ,COD_ALUNO ='+ cod_aluno + ' WHERE COD_TURMA = '+ QuotedStr(pk_turma) + ' AND COD_ALUNO = '+ pk_aluno;

Form_logon.ConexaoBD.BeginTrans; try ADOQuery_aux.ExecSQL; deuerro := false; except on E : Exception do begin deuerro := true; if Form_logon.ErroBD(E.Message,'PK_Matriculas') = 'Sim' then ShowMessage('Matrícula já cadastrada!') else if Form_logon.ErroBD(E.Message,'FK_Frequencias_Matriculas') = 'Sim' then Showmessage('Existem frequências lançadas para esta matrícula!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;

if deuerro = true then begin Form_logon.ConexaoBD.RollbackTrans; end else begin Form_logon.ConexaoBD.CommitTrans; pk_turma := cod_turma; pk_aluno := cod_aluno; desabilita_salvar(sender); bloqueia_campos; end; end; end;

245 de 332


Código do evento OnClick do botão “Alterar” do Form_matriculas:

Código do evento OnClick do botão “Cancelar” do Form_ matriculas:

246 de 332


Código do evento OnClick do botão “Excluir” do Form_matriculas:

procedure TForm_matriculas.btn_excluirClick(Sender: TObject); var deuerro : boolean; begin if (pk_turma = '') or (pk_aluno = '') then Showmessage('Impossível excluir!') else begin adoquery_aux.SQL.Text := ' DELETE FROM MATRICULAS ' + ' WHERE COD_TURMA = ' + QuotedStr(pk_turma) + ' AND COD_ALUNO = ' + cod_aluno; Form_logon.ConexaoBD.BeginTrans;

try ADOQuery_aux.ExecSQL; deuerro := false; except on E : Exception do begin deuerro := true; if Form_logon.ErroBD(E.Message,'FK_Frequencias_Matriculas') = 'Sim' then Showmessage('Existem frequências lançadas para esta matrícula!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;

if deuerro = true then begin Form_logon.ConexaoBD.RollbackTrans; end else begin Form_logon.ConexaoBD.CommitTrans; pk_turma := ''; pk_aluno := ''; cod_turma := ''; cod_aluno := ''; desabilita_salvar(sender); limpa_campos; bloqueia_campos; end; end; end;

Código do evento OnClick do botão “Fechar” do Form_matriculas:

247 de 332



de pesquisa de matrículas. O usuário irá pesquisar uma matrícula através do aluno, ou seja,

através do aluno o usuário irá selecionar a matrícula desejada. Sendo assim, podemos utilizar

a tela genérica de pesquisa: o form_pesquisa. Entretanto, precisaremos fazer uma pequena

modificação no form_pesquisa, mas nada que afete as outras telas que também fazem uso

dele. O form_pesquisa, da maneira como está, retorna como chave primária o primeiro campo

do registro selecionado. Como o cadastro de matrículas possui uma chave composta por dois

campos, iremos alterar o form_pesquisa para que ele retorne também o segundo campo do

registro selecionado.

Acesse a seção public da unit_pesquisa e declare a variável “chave_aux”.

Em seguida, acesse o evento OnClick do botão Selecionar e faça a seguinte alteração no

código:

Pornto, agora já podemos uilizar o form_pesquisa também no cadastro de matrículas!

248 de 332


Insira um objeto BitBtn ao form_matriculas e altere as propriedades Name e Caption

para btn_localizar e “Localizar” respectivamente. Arrume o objeto conforme mostrado a

seguir:




249 de 332


Pronto, o cadastro de matriculas já está concluído! Vamos agora alterar o form_menu

para chamar o form_matriculas. Acesse o form_menu e digite o seguinte no evento OnClick do

botão “Matrículas”:


250 de 332


Criando o Lançamento de Aulas

O lançamento de aulas é uma das funcionalidades mais simples deste sistema. Ele

consiste basicamente em uma tela para executar um comando INSERT. Esta funcionalidade

será utilizada pelos instrutores da escola de informática. Eles irão utilizar esta opção apenas

para lançar as aulas que já aconteceram, pois não será permitido lançar aulas

antecipadamente conforme especificado no capítulo de planejamento da aplicação.


Configure a propriedade Name do novo Form como “Form_lanca_aulas” e Caption

como “Lançamento de aulas”. Aplique as mesmas configurações feitas para o form_logon para


form. Salve-o como “Unit_lanca_aulas”.

251 de 332


Após salvar o novo form, insira 2 objetos Label e um objeto Edit ao form_lanca_aulas.

Altere a propriedade Caption dos Label’s para “Turma” e “Data”. Renomeie o objeto Edit para

edt_turma, limpe a propriedade Text, configure a propriedade Enable como “False” e Color

como “clInfoBk”.

Insira também um objeto DateTimePicker que está localizada na guia Win32 da

paleta de componentes. Este objeto é uma espécie de calendário.

Configure as propriedades do objeto DateTimePicker exatamente como a tabela abaixo:

Propriedade Valor

Format dd/MM/yyyy

Name dt_aula

Time 00:00:00

Insira 2 objetos BitBtn ao form_lanca_aulas, configure Name como “btn_lancar” e

“btn_cancelar”. Configure Caption como “Lançar” e “Cancelar”. Além disso, insira um outro

BitBtn para selecionar a turma. Configure-o da mesma maneira que foi configurado no

form_matriculas.

Em seguida, insira um ADOQuery. Altere a propriedade Name do ADOQuery para

“ADOQuery_aux” e configure a propriedade Connection para Fom_logon.ConexaoBD. Mas

antes vá em File > Use Unit... e selecione a Unit_logon.

Após estas configurações, seu form deve ficar semelhante ao exibido abaixo:

Agora vamos programar os eventos desta tela.

252 de 332


Evento OnShow do form_lanca_aulas:

Evento OnClick do btn_turma:

Evento OnClick do btn_lancar

procedure TForm_lanca_aulas.btn_lancarClick(Sender: TObject); var data_aula : string; deuerro : boolean; begin if edt_turma.Text = '' then ShowMessage('Informe a turma!') else if dt_aula.Date > date then ShowMessage('Não é permitido lançar aulas antecipadamente !') else begin data_aula := FormatDateTime('mm/dd/yyyy',dt_aula.Date);

ADOQuery_aux.SQL.Text := 'INSERT INTO AULAS VALUES '+ '('+ QuotedStr(edt_turma.Text) + ','+ QuotedStr(data_aula) + ','+ QuotedStr('N') + ')';

Form_logon.ConexaoBD.BeginTrans; try ADOQuery_aux.ExecSQL; deuerro := false; except on E: Exception do begin

253 de 332


deuerro := true; if Form_logon.ErroBD(E.Message,'PK_Aulas') = 'Sim' then Showmessage('Aula já lançada!') else ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;

if deuerro = true then Form_logon.ConexaoBD.RollbackTrans else begin Form_logon.ConexaoBD.CommitTrans; ShowMessage('Aula lançada com sucesso!'); edt_turma.Clear; dt_aula.Date := Date; end; end; end;

Obs.: No código acima, formatamos a data para o formato americano “mm/dd/yyyy”,

porque é assim que o SQL Server trabalha internamente. Na verdade, o SQL Server armazena

datas no formato “yyyy-mm-dd”, mas também entende o formato “mm/dd/yyyy” que

particularmente achamos mais simples.

Evento OnClick do btn_cancelar:

Pronto, o lançamento de aulas já está concluído! Salve as alterações clicando em Save

All. Vamos agora alterar o form_menu para chamar o form_lanca_aulas. Acesse o form_menu

e digite o seguinte no evento OnClick do botão “Lançamento de Aulas”:

254 de 332


Em seguida, execute o projeto para testar a nova funcionalidade!

255 de 332


Criando o Lançamento de Presença

O lançamento de presença é mais uma funcionalidade a ser utilizada pelos instrutores

da escola de informática. A idéia é a seguinte: ao término da aula o instrutor lança a aula dada

e em seguida faz o lançamento de presença. Ele seleciona a turma e a data da aula e o

sistema lista todos os alunos matriculados naquela turma. O instrutor então marca quem está

presente e não marca quem faltou, em seguida confirma o lançamento de presença. Neste

momento o sistema varre a lista de alunos verificando se cada linha está ou não marcada. Se

estiver, o sistema grava “S” no campo “presente” da tabela de “Frequencias”, do contrário ele

grava o campo “presente” com o valor “N”. Vamos então implementar esta lógica.


Configure a propriedade Name do novo Form como “Form_lanca_presenca” e Caption

como “Lançamento de Presença”. Aplique as mesmas configurações feitas para o form_logon


novo form. Salve-o como “Unit_lanca_presenca”.

256 de 332


Após salvar o novo form, insira 2 objetos Label, 1 objeto Edit e um ComboBox ao

form_lanca_presenca. Altere a propriedade Caption dos Label’s para “Turma” e “Data da Aula”.

Renomeie o objeto Edit para edt_turma, limpe a propriedade Text, configure a propriedade

Enable como “False” e Color como “clInfoBk”. Altere a propriedade Name do ComboBox para

cb_aulas e a propriedade Style para “csDropDownList”.

Insira 3 objetos BitBtn ao form_lanca_presenca, configure Name como

“btn_listar_alunos”, “btn_lancar” e “btn_fechar”. Configure Caption como “Listar”, “Confirmar”

e “Fechar”. Além disso, insira um outro BitBtn para selecionar a turma. Configure-o da mesma

maneira que foi configurado no form_matriculas.

Insira também um objeto CheckListBox que está localizada na guia Additional da

paleta de componentes. Este objeto será utilizado para listar os alunos matriculados na turma

selecionada.

Em seguida, insira um ADOQuery. Altere a propriedade Name do ADOQuery para

“ADOQuery_aux” e configure a propriedade Connection para Fom_logon.ConexaoBD. Mas

antes vá em File > Use Unit... e selecione a Unit_logon.

Após estas configurações, seu form deve ficar semelhante ao exibido abaixo:

Agora vamos programar os eventos desta tela.

257 de 332


Evento OnShow do form_lanca_presenca:

Evento OnClick do objeto btn_turma:

Evento OnEnter do objeto cb_aulas:

procedure TForm_lanca_presenca.cb_aulasEnter(Sender: TObject); var data : TDateTime; begin cb_aulas.Clear; if edt_turma.Text = '' then ShowMessage('Selecione uma turma!') else begin //Busca as aulas que ainda não tiveram a frequência lançada ADOQuery_aux.SQL.Text := 'SELECT DATA FROM AULAS '+ 'WHERE COD_TURMA=' +QuotedStr(edt_turma.Text)+ 'AND DATA NOT IN ' + '(SELECT DATA FROM FREQUENCIAS '+ ' WHERE COD_TURMA='+QuotedStr(edt_turma.Text)+')'+ 'ORDER BY DATA DESC'; ADOQuery_aux.Open; if ADOQuery_aux.IsEmpty then ShowMessage('Não existem aulas desta turma para lançamento de frequência!') else begin While not ADOQuery_aux.Eof do begin

258 de 332


data := ADOQuery_aux.fieldbyname('DATA').AsDateTime; cb_aulas.Items.Add(FormatDateTime('dd/mm/yyyy',data)); ADOQuery_aux.Next; end; end; ADOQuery_aux.Close; end; end;

Evento OnClick do objeto btn_listar_alunos:

259 de 332


Evento OnClick do objeto btn_confirmar:

procedure TForm_lanca_presenca.btn_confirmarClick(Sender: TObject); var i : integer; cod_aluno, presente, data : string; deuerro : boolean; begin Form_logon.ConexaoBD.BeginTrans; try deuerro := false; data := FormatDateTime('mm/dd/yyyy',StrToDate(cb_aulas.Text)); for i := 0 to ck_lista_alunos.Items.Count -1 do begin ck_lista_alunos.Selected[i] := true; cod_aluno := copy(ck_lista_alunos.Items.Strings[i],1,3);

if ck_lista_alunos.Checked[i] then presente := 'S' else presente := 'N';

ADOQuery_aux.SQL.Text := 'INSERT INTO FREQUENCIAS VALUES '+ '('+ QuotedStr(edt_turma.Text) + ','+ cod_aluno + ','+ QuotedStr(data) + ','+ QuotedStr(presente) + ')'; ADOQuery_aux.ExecSQL; end; except on E: Exception do begin deuerro := true; ShowMessage('Ocorreu o seguinte erro: ' + E.Message); end; end;

if deuerro = true then form_logon.ConexaoBD.RollbackTrans else begin Form_logon.ConexaoBD.CommitTrans; ShowMessage('Lançamento efetuado com sucesso!'); edt_turma.Clear; cb_aulas.Clear; ck_lista_alunos.Clear; end; end;

Evento OnClick do objeto btn_fechar:

260 de 332


Pronto, o lançamento de presença já está concluído! Salve as alterações clicando em

Save All. Vamos agora alterar o form_menu para chamar o form_lanca_presenca. Acesse o

form_menu e digite o seguinte no evento OnClick do botão “Frequências”:

Execute o projeto e confira o que acabamos de construir!

261 de 332


Montando o Pagamento de Instrutores

Nos dois últimos capítulos construímos os lançamentos de aula e de presença. Estas

funcionalidades serão utilizadas pelos instrutores para registrar o trabalho desenvolvido na

escola de informática. Em contrapartida, cada instrutor deve ser remunerado pelas aulas

dadas. Portanto, criaremos agora a funcionalidade que permitirá ao administrador da escola de

informática contabilizar as aulas de cada instrutor e então efetuar o devido pagamento.

O pagamento de instrutores, no que diz respeito à aplicação, consiste na geração do

demonstrativo de aulas dadas e na marcação de cada aula como “paga”. Para gerar o

demonstrativo, o usuário deverá selecionar o instrutor e o mês que deseja contabilizar as

aulas. Somente estarão disponíveis os meses que possuírem aulas não pagas. Após o usuário

selecionar o instrutor e o mês desejado, o sistema irá contabilizar todas as aulas do mês em

questão agrupadas por turma. Quando o usuário fechar o demonstrativo, o sistema deve

perguntar se o usuário deseja marcar as aulas do demonstrativo como pagas, caso negativo, o

sistema cancela a operação. Vamos então desenvolver o que foi dito acima.


Configure a propriedade Name do novo Form como “Form_pag_instrutores” e Caption

como “Pagamento de Instrutores”. Aplique as mesmas configurações feitas para o form_logon


novo form. Salve-o como “Unit_pag_instrutores”.

262 de 332


Após salvar o novo form, insira 2 objetos Label, 1 objeto Edit e um ComboBox ao

form_pag_instrutores. Altere a propriedade Caption dos Label’s para “Instrutor” e “Mês/Ano”.

Renomeie o objeto Edit para edt_instrutor, limpe a propriedade Text, configure a propriedade

Enable como “False” e Color como “clInfoBk”. Altere a propriedade Name do ComboBox para

cb_mes_ano e a propriedade Style para “csDropDownList”. Insira 2 objetos BitBtn ao

form_pag_instrutores, configure Name como “btn_gerar”, e “btn_cancelar”. Configure Caption

como “Gerar demonstrativo”, e “Cancelar”. Além disso, insira um outro BitBtn para selecionar

o instrutor. Configure-o da mesma maneira que foi configurado no form_turmas.

Em seguida, insira dois objetos ADOQuery. Nós iremos utilizar um para fazer as

consultas e demais operações no banco e o outro para montar o SELECT do demonstrativo.

Altere a propriedade Name dos ADOQuery’s para “ADOQuery_demonstrativo” e

“ADOQuery_aux”. Configure a propriedade Connection deles para Fom_logon.ConexaoBD.

Mas antes vá em File > Use Unit... e selecione a Unit_logon. Após estas configurações, seu

form deve ficar semelhante ao exibido abaixo:

263 de 332


Para criar o demonstrativo, iremos utilizar o editor de relatórios Rave Reports que faz

parte do Delphi 7. Os componentes necessários à criação de um relatório usando o Rave

Reports estão na guia Rave da paleta de componentes. Precisamos utilizar apenas dois

componentes desta guia para montar nosso demonstrativo.

Insira estes dois objetos ao form_pag_instrutores. O objeto RvProject fará referência

ao arquivo de projeto de relatórios que será criado quando fizermos o demonstrativo no Rave.

O RvDataSetConnection é o objeto que utilizaremos para conectar ao

ADOQuery_demonstrativo. Renomeie o RvProject para “rel_demonstrativo” e o

RvDataSetConnection para “ds_demonstrativo”. Agora ligue o ds_demonstrativo ao

ADOQuery_demonstrativo através da propriedade DataSet.

Atenção: O comando SELECT do ADOQuery utilizado pelo ds_demonstrativo será

montado dinamicamente via código, entretanto, para construir nosso demonstrativo no

ambiente do Rave Reports devemos estabelecer conexão com o banco de dados e ativar o

ADOQuery_demonstrativo. Isto é necessário apenas para que o Rave consiga obter a relação

de campos presentes no ADOQuery. Quando terminarmos de criar o demonstrativo, iremos

desativar o ADOQuery_demonstrativo e finalizar a conexão com o banco de dados.

Vamos agora estabelecer a conexão com o banco de dados através do objeto

ConexaoBD que está no form_logon. Lembramos que iremos fazer isto apenas para criar o

relatório, assim que acabarmos iremos desconectar o objeto.

264 de 332


Estando no form_logon, selecione o ConexaoBD e em seguida, clique sobre o botão “...”

da propriedade ConnectionString. A propriedade ConnectionString é que define o banco de

dados que iremos acessar. Aqui definimos se vamos acessar um banco de dados Oracle, SQL

Server ou Microsoft Access entre outros, além disso, especificamos o nome do servidor, o

usuário e a senha que será utilizada para acessar o banco de dados. Na tela que surgiu após

clicar sobre o botão “...”, clique sobre o botão Build...

A primeira opção que devemos configurar é o software de banco de dados que iremos

acessar, em nosso caso, iremos acessar um servidor SQL Server, portanto selecione a opção

Microsoft OLE DB Provider for SQL Server. Clique em Avançar para continuar com a

configuração do objeto ConexaoDB.

265 de 332


Agora devemos informar o nome do servidor SQL Server que desejamos acessar. Você

também pode informar o endereço IP do servidor caso não saiba ou não queira usar o nome do

servidor.

A próxima opção é usuário e a senha utilizada para acessar o servidor. Aqui você pode

utilizar o usuário “admin_academico” que criamos para ser utilizado pela aplicação. Marque a

opção “Permitir salvamento de senha”. A última opção a configurar é o banco de dados que

iremos acessar. Selecione o banco de dados Academico.

Clique no botão Testar conexão para checar se está tudo Ok.

Vá clicando em OK até voltar ao Form_logon. Agora selecione o objeto ConexaoBD e

altere a propriedade Connected mudando o valor de False para True. Isto faz com que o

objeto estabeleça a conexão com o servidor de banco de dados.

266 de 332


Agora volte ao form_pag_instrutores e selecione o objeto ADOQuery_demonstrativo.

Acesse a propriedade SQL dele e digite o seguinte:

Após digitar o SELECT acima, altere a propriedade Active para True.

Vamos então criar nosso demonstrativo no Rave. Dê um clique duplo no objeto

rel_demonstrativo, será exibido o ambiente do Rave Reports.

267 de 332


À esquerda temos a janela de propriedades semelhante ao Object Inspector. Na tela

principal temos a área de criação do relatório e a direita existe uma outra janela onde estão a

Report Library, o Global Page Catalog e o Data View Dictionary.

Na parte superior temos a paleta de componentes para confecção de relatórios. A guia

Report é a que mais iremos utilizar:

Expanda a Report Library até chegar ao item Page1. Selecione-o e altere a propriedade

Orientation para “poPortrait” (Página na Vertical) e a propriedade PageSize para A4.

Após configurar o tamanho e a posição da página, iremos criar um objeto de banco de

dados. Este objeto tem por finalidade disponibilizar os campos de uma query no relatório.

Clique em File > New Data Object:

268 de 332


Na janela que surgirá, selecione a opção Direct Data View e clique em Next.

Será exibido outra tela, então selecione o objeto “ds_demonstrativo” para ligar o Rave

com o ADOQuery_demonstrativo que possui o SELECT que configuramos anteriormente.

Observe que agora aparece o objeto DataView1 com os campos do SELECT do

ADOQuery_demonstrativo.

269 de 332


Vamos então montar nosso relatório, para isso vá até a guia Report. Veja os principais

objetos:

Insira um objeto Region ao relatório. Aumente o objeto de forma que ele ocupe todo o

espaço disponível da página. Para facilitar este trabalho, utilize o menu Zoom para ajustar a

visualização.

Em seguida insira um objeto Band. Renomeie o objeto para “cabecalho”.

270 de 332


Na propriedade BandStyle, clique no botão “...” e marque a opção Body Header. Isto

determinará que essa banda seja o cabeçalho do relatório.

Como dito anteriormente, o demonstrativo de aulas do instrutor deve ser agrupado por

turma, portanto, iremos inserir mais uma banda que será o cabeçalho do grupo. Insira um

objeto Band. Renomeie o objeto para “cabecalho_turma”. Na propriedade BandStyle, clique

em “...” e marque a opção Group Header. Assim esta banda será o cabeçalho do

agrupamento de turmas.

271 de 332


Agora vamos inserir a banda principal, onde serão listadas as aulas dadas pelos

instrutores. A banda principal deve ser uma DataBand e não uma Band comum. Então insira

um DataBand. Renomeie o objeto para “aulas”. Na propriedade BandStyle, clique em “...” e

marque a opção Detail.

Após criar a banda de detalhe, vamos inserir as bandas de rodapé de grupo e de rodapé

do relatório. Insira 2 objetos Band, renomeie o primeiro como “rodape_turma” e o segundo

como “rodape”. O BandStyle do primeiro será “Group Footer” e do segundo “Body Footer”.

A região do relatório deve ficar semelhante à figura abaixo:

272 de 332


Até agora o que fizemos foi apenas criar as bandas e definir o estilo de cada uma.

Vamos então configurar as propriedades de cada uma.

Selecione a Band “cabecalho” e altere as propriedades seguindo a tabela abaixo:

Propriedade Valor

ControllerBand aulas

Selecione a Band “cabeçalho_turma” e altere as propriedades seguindo a tabela

abaixo:

Propriedade Valor


GroupDataView DataView1

GroupKey COD_TURMA

Selecione a DataBand “aulas” e altere as propriedades seguindo a tabela abaixo:

Propriedade Valor

DataView DataView1

DetailKey DATA

Selecione a Band “rodape_turma” e altere as propriedades seguindo a tabela abaixo:

Propriedade Valor


GroupDataView DataView1

GroupKey COD_TURMA

Selecione a Band “rodape” e altere as propriedades seguindo a tabela abaixo:

Propriedade Valor


Pronto, todas as bandas do demonstrativo estão configuradas! Antes de continuarmos,

vamos salvar nosso projeto. Acesse o menu File > Save:

273 de 332


Salve o arquivo do projeto do demonstrativo na mesma pasta do projeto como o nome

“demonstrativo.rav”:

A partir de agora, sempre que quiser salvar as alterações no projeto deste relatório,

basta clicar sobre o botão Save Project:

274 de 332


Após salvar o nosso projeto Rave, vamos agora inserir os objetos nas bandas criadas.

Iremos utilizar 3 objetos para este relatório:

Este objeto é utilizado para exibição de textos fixos. Ele é

semelhante ao objeto Label do Delphi.

Este objeto é utilizado para exibição de um campo de

uma tabela de um banco de dados.

Este objeto é utilizado para realizar cálculos com um

campo de uma tabela de um banco de dados.

Insira 3 objetos Text à Band “cabecalho”. Altere a propriedade Text deles para

“Demonstrativo de Aulas”, “Código do Instrutor” e “Nome do Instrutor”. Em seguida, os

organize conforme exibido na imagem abaixo:

275 de 332


Agora insira 2 objetos DataText à Band “cabecalho”. Altere a propriedade DataView

deles para “DataView1”. Em seguida, altere a propriedade DataField para “COD_INSTRUTOR” e

“NOME” respectivamente. Posicione-os lado-a-lado com os objetos Text.

Na Band “cabecalho_turma”, insira 1 objeto Text e 1 DataText. Altere a propriedade

Text do objeto Text para “Turma”. Altere a propriedade DataView para “DataView1” e

DataField para “COD_TURMA”. Insira mais 2 objetos Text à Band “cabecalho_turma”. Altere a

propriedade Text para “Data da Aula” e “Valor” respectivamente. Veja abaixo como deve ficar

seu projeto:

Agora insira 2 objetos DataText à DataBand “aulas”. Altere a propriedade DataView

deles para “DataView1”. Altere a propriedade DataField para “DATA” e “VALOR_AULA”

respectivamente. Altere a propriedade FontJustify do DataText “DATA” para “pjCenter” e do

DataText “VALOR_AULA” para “pjRight”. Posicione-os conforme apresentado na imagem

abaixo:

276 de 332


Agora só falta inserir os objetos das bandas de rodapé. Insira um objeto CalcText na

Band “rodape_turma”. Insira também um objeto Hline (guia Drawing).

Altere as propriedade do objeto CalcText conforme a tabela abaixo:

Propriedade Valor

CalcType ctSum

Controller aulas

DataView DataView1

DataField VALOR_AULA

DisplayFormat R$ ,0.00

FontJustify pjRight

Em seguida, arrume o CalcText e o HLine conforme mostrado na figura a seguir:

277 de 332


E por fim, vamos inserir os objetos da Band “rodape”. Insira um objeto Rectangle

(guia Drawing).

Insira também 1 objeto Text e 1 objeto DataText. Altere a propriedade Text do objeto

Text para “Valor total à pagar:”. Em seguida altere as propriedades do CalcText de acordo com

a tabela abaixo:

Propriedade Valor

CalcType ctSum

Controller aulas

DataView DataView1

DataField VALOR_AULA

DisplayFormat R$ ,0.00

FontJustify pjRight

Agora arrume os objetos da Band “rodape” conforme exibido na imagem a seguir:

278 de 332


Salve as alterações e feche o ambiente do Rave Reports para voltarmos ao Delphi.

Estando de volta ao Delphi, iremos desativar o ADOQuery_demonstrativo e finalizar a

conexão estabelecida pelo ConexaoBD. Antes disso, iremos adicionar os campos do SELECT ao

ADOQuery_demonstrativo. Faremos isto para poder configurar o formato de exibição dos

campos de data e valor de aula.

Clique com o botão direito do mouse sobre o ADOquery_demonstrativo e acesse a

opção Fields Editor.

Na janela que surgirá, clique novamente com o botão direito do mouse e selecione a

opção Add all fields:

279 de 332


Selecione o campo DATA e altere a propriedade DisplayFormat para “dd/mm/yyyy”. Em

seguida, selecione o campo VALOR_AULA e altere a propriedade DisplayFormat para “R$ ,0.00”

Estas configurações são necessárias para formatar a exibição destes campos.

Selecione ADOQuery_demonstrativo. Altere a propriedade Active para False e limpe

a propriedade SQL. Vá até o form_logon e selecione o objeto ConexaoBD. Altere a propriedade

Connected para False e limpe a propriedade ConnectionString. Em seguida salve as alterações

clicando em Save All. Feito isso, feche o projeto e o abra novamente. Calma, não estamos

malucos, isto é apenas para o Delphi limpar o “cache” da conexão.

Depois de todo este trabalho, volte para o form_pag_instrutores e programe os eventos

desta tela. Antes de programar os eventos, declare a seguinte variável:

280 de 332


Evento OnShow do form_pag_instrutores:

Evento OnClick do botão “btn_instrutor”:

281 de 332


Evento OnEnter do objeto “cb_mes_ano”:

282 de 332


Evento OnClick do objeto “btn_gerar”:

procedure TForm_pag_instrutores.btn_gerarClick(Sender: TObject); var mes,ano, sql : string; begin if (cod_instrutor='') or (cb_mes_ano.Text='') then Showmessage('Informações Inválidas!') else begin mes := copy(cb_mes_ano.Text,1,2); ano := copy(cb_mes_ano.Text,4,4);

sql :=' SELECT INSTRUTORES.COD_INSTRUTOR, INSTRUTORES.NOME, '+ ' AULAS.COD_TURMA, AULAS.DATA, TURMAS.VALOR_AULA '+ ' FROM AULAS '+ ' INNER JOIN TURMAS ON '+ ' AULAS.COD_TURMA = TURMAS.COD_TURMA '+ ' INNER JOIN INSTRUTORES ON '+ ' TURMAS.COD_INSTRUTOR = INSTRUTORES.COD_INSTRUTOR '+ ' WHERE TURMAS.COD_INSTRUTOR =' + cod_instrutor + ' AND MONTH(DATA) =' + mes + ' AND YEAR(DATA) = ' + ano + ' AND AULAS.PAGA = ' + QuotedStr('N') + ' ORDER BY TURMAS.COD_TURMA, AULAS.DATA ';

ADOQuery_demonstrativo.SQL.Text := sql; ADOQuery_demonstrativo.Open;

rel_demonstrativo.ProjectFile := GetCurrentDir + '\demonstrativo.rav'; rel_demonstrativo.Execute;

ADOQuery_demonstrativo.Close;

//Pergunta se deseja quitar as aulas do demonstrativo if Application.MessageBox('Deseja quitar estas aulas ?', 'Quitar Aulas ?', mb_yesno+mb_iconquestion) = idyes then begin sql := ' UPDATE AULAS SET AULAS.PAGA =' + QuotedStr('S') + ' FROM AULAS '+ ' INNER JOIN TURMAS ON '+ ' AULAS.COD_TURMA = TURMAS.COD_TURMA '+ ' WHERE TURMAS.COD_INSTRUTOR = ' + cod_instrutor;

Form_logon.ConexaoBD.BeginTrans; ADOQuery_aux.SQL.Text := sql; ADOQuery_aux.ExecSQL; Form_logon.ConexaoBD.CommitTrans; Showmessage('Aulas quitadas com sucesso!'); cb_mes_ano.Clear; edt_instrutor.Clear; cod_instrutor := ''; end;

end; end;

Evento OnClick do objeto “btn_cancelar”:

283 de 332


Pronto, o pagamento de instrutores já está concluído! Vamos agora alterar o

form_menu para chamar o form_pag_instrutores. Acesse o form_menu e digite o seguinte no

evento OnClick do botão “Pagamento de Instrutores”:

Agora execute o projeto e teste a nova funcionalidade!

284 de 332


Módulo 6:

Criando os Relatórios

inalizando este curso, iremos construir os relatórios do sistema. Os

relatórios são a forma que o usuário possui para visualizar de maneira

organizada as informações contidas no banco de dados. Os relatórios

também são utilizados como uma ferramenta de consulta. Neste módulo

veremos como parametrizar cada relatório de forma que o usuário possa

definir o que ele quer que o sistema exiba.

F

285 de 332


Relação de Cursos

Neste último módulo iremos apenas criar relatórios. A palavra “apenas” não significa

que será pouco trabalho ou que será um trabalho sem importância. Os relatórios são as

ferramentas de controle mais utilizadas pelos usuários. Através deles os usuários podem tomar

conhecimento das diversas informações contidas no sistema. Além disso, os relatórios

possibilitam que os dados sejam impressos em papel de maneira simples e organizada.

Iremos criar uma tela que concentrará todos os relatórios do sistema, assim o usuário

terá, em um único lugar, acesso a eles.


Configure a propriedade Name do novo Form como “Form_relatorios” e Caption como

“Relatórios”. Aplique as mesmas configurações feitas para o form_logon para manter o mesmo

padrão. Após fazer as configurações, clique em Save All para salvar o novo form. Salve-o

como “Unit_relatorios”.

286 de 332


Após salvar o novo form, insira 6 objetos BitBtn. Altere as propriedades Name e Caption

de cada um deles seguindo a tabela abaixo:

Name Caption

btn_rel_curso Relação de Cursos

btn_rel_turmas Relação de Turmas por Curso

btn_rel_alunos Relação de Alunos por Turma

btn_rel_faltas Relatório de Faltas dos Alunos

btn_rel_aulas Relatório de Aulas por Instrutor

btn_fechar Fechar

Organize os botões um em cima do outro semelhante à imagem abaixo:

Agora iremos criar nosso primeiro relatório: “Relação de Cursos”. Este relatório é bem

simples, pois consiste em listar os cursos cadastrados na tabela cursos do sistema. Para este

relatório, insira 1 objeto ADOQuery, 1 objeto Rvproject e 1 objeto RvDataSetConnection.

Altere a propriedade Name do ADOQuery para “ADOQuery_rel_cursos”. Configure a

propriedade Connection dele para Fom_logon.ConexaoBD. Mas antes vá em File > Use

Unit... e selecione a Unit_logon. Na propriedade SQL digite o seguinte comando: “SELECT *

FROM CURSOS ORDER BY NOME”. Renomeie o RvProject para “rel_cursos” e o

RvDataSetConnection para “ds_rel_cursos”. Agora ligue o ds_rel_cursos ao

ADOQuery_rel_cursos através da propriedade DataSet.

Como já sabemos, para criar o relatório no ambiente do Rave Reports é necessário

estabelecer conexão com o banco de dados e ativar o ADOQuery que será utilizado pelo

relatório. Portanto, estabeleça a conexão através do ConexaoBD que está no form_logon e

ative o ADOQuery_rel_cursos. Se tiver alguma dúvida neste procedimento consulte o capítulo

anterior.

287 de 332


Após ativar o ADOQuery_rel_cursos, dê um duplo clique sobre o objeto rel_cursos

(RvProject) para abrir o ambiente do Rave Reports. Quando o ambiente do Rave Reports for

exibido, talvez apareça o último projeto criado. Então, clique em File > New para

disponibilizar um novo arquivo de projeto.





Clique em File > New Data Object. Na janela que surgirá, selecione a opção Direct Data

View e clique em Next. Será exibido outra tela, selecione o objeto “ds_rel_cursos” para ligar o

Rave com o ADOQuery_rel_cursos que possui o SELECT que configuramos anteriormente.

288 de 332



ADOQuery_rel_cursos.

Vamos então montar nosso relatório. Insira um objeto Region ao relatório. Aumente o

objeto de forma que ele ocupe todo o espaço disponível da página. Para facilitar este trabalho,

utilize o menu Zoom para ajustar a visualização.

Em seguida insira um objeto Band. Renomeie o objeto para “cabecalho”. Na

propriedade BandStyle, clique no botão “...” e marque a opção Body Header. Isto


289 de 332


Agora vamos inserir a banda principal, onde serão listadas os cursos da escola de

informática. A banda principal deve ser uma DataBand e não uma Band comum. Então insira

um DataBand. Renomeie o objeto para “cursos”. Na propriedade BandStyle, clique em “...” e


290 de 332



Vamos agora configurar as propriedades de cada banda do relatório.


Propriedade Valor

ControllerBand cursos

Selecione a DataBand “cursos” e altere as propriedades seguindo a tabela abaixo:

Propriedade Valor

DataView DataView1

DetailKey COD_CURSO

Pronto, todas as bandas do relatório estão configuradas! Antes de continuarmos, vamos

salvar nosso projeto. Acesse o menu File > Save:

Salve o arquivo do Rave na mesma pasta do projeto do Delphi com o nome

“rel_cursos.rav”:

291 de 332


A partir de agora, sempre que quiser salvar as alterações no projeto deste relatório,

basta clicar sobre o botão Save Project:

Após salvar o nosso projeto Rave, vamos agora inserir os objetos nas bandas criadas.

Insira 3 objetos Text à Band “cabecalho”. Altere a propriedade Text deles para “Relação de

Cursos”, “Código do Curso” e “Nome do Curso”. Em seguida, os organize conforme exibido na

imagem abaixo:

292 de 332


Agora insira 2 objetos DataText à DataBand “cursos”. Altere a propriedade DataView

deles para “DataView1”. Altere a propriedade DataField para “COD_CURSO” e “NOME”

respectivamente. Posicione-os conforme apresentado na imagem abaixo:

Salve as alterações. Se desejar, pressione F9 no teclado para visualizar a prévia do

relatório.

Feche o ambiente do Rave Reports para voltarmos ao Delphi.

293 de 332


Estando de volta ao Delphi, selecione ADOQuery_rel_cursos e altere a propriedade

Active para False. Neste caso não é preciso limpar a propriedade SQL. Vá até o form_logon e

selecione o objeto ConexaoBD. Altere a propriedade Connected para False e limpe a

propriedade ConnectionString. Em seguida salve as alterações clicando em Save All. Feito isso,

feche o projeto e o abra novamente para o Delphi limpar o “cache” da conexão.

Volte para o form_relatorios e digite o seguinte código no evento OnClick do botão

btn_rel_cursos:

E digite o seguinte no evento OnClick do botão btn_fechar:

Pronto, a relação de cursos já está concluída! Vamos agora alterar o form_menu para

chamar o form_relatorios. Acesse o form_menu e digite o seguinte no evento OnClick do botão

“Relatórios”:

294 de 332


Em seguida salve as alterações e execute o projeto para verificar a funcionalidade do

novo relatório.

295 de 332


Relação de Turmas por Cursos

A relação de turmas por curso funcionará da seguinte maneira: o usuário irá selecionar

o curso desejado e então a aplicação listará todos as turmas daquele curso. Como podemos

perceber, precisaremos de uma tela de parâmetros, para que o usuário possa selecionar o

curso desejado.


Configure a propriedade Name do novo Form como “Form_rel_turmas” e Caption

como “Relação de Turmas por Curso”. Aplique as mesmas configurações feitas para o

form_logon para manter o mesmo padrão. Após fazer as configurações, clique em Save All

para salvar o novo form. Salve-o como “Unit_rel_turmas”.

296 de 332


Após salvar o novo form, acesse a unit_rel_turmas e declare a seguinte variável na

seção public:

Após fazer a declaração, insira 1 objeto Label e 1 objeto Edit ao form_rel_turmas.

Altere a propriedade Caption do Label para “Curso”. Renomeie o objeto Edit para edt_curso,

limpe a propriedade Text, configure a propriedade Enable como “False” e Color como

“clInfoBk”. Insira 2 objetos BitBtn ao form_rel_turmas, configure Name como “btn_ok” e

“btn_fechar”. Configure Caption como “Ok” e “Fechar”. Além disso, insira um outro BitBtn para

selecionar o curso. Configure-o da mesma maneira que foi configurado no form_turmas.

Em seguida, insira dois objetos ADOQuery. Nós iremos utilizar um para fazer as

consultas no banco e o outro para montar o SELECT do relatório. Altere a propriedade Name

dos ADOQuery’s para “ADOQuery_rel_turmas” e “ADOQuery_aux”. Configure a propriedade

Connection deles para Fom_logon.ConexaoBD. Mas antes vá em File > Use Unit... e

selecione a Unit_logon. Após estas configurações, seu form deve ficar semelhante ao exibido

abaixo:

O próximo passo é inserir os objetos do Rave Reports. Insira 1 RvProject e 1

RvDataSetConnection.

297 de 332


Renomeie o RvProject para “rel_turmas” e o RvDataSetConnection para

“ds_rel_turmas”. Agora ligue o ds_rel_turmas ao ADOQuery_rel_turmas através da

propriedade DataSet.

Antes de abrir o ambiente do Rave, digite o seguinte comando na propriedade SQL do

ADOQuery_rel_turmas:

Como dito anteriormente, para criar o relatório no ambiente do Rave Reports é

necessário estabelecer conexão com o banco de dados e ativar o ADOQuery que será utilizado

pelo relatório. Portanto, estabeleça a conexão através do ConexaoBD que está no form_logon

e ative o ADOQuery_rel_turmas. Se tiver alguma dúvida neste procedimento consulte o

capítulo “Montando o Pagamento de Instrutores”.

Após ativar o ADOQuery_rel_turmas, dê um duplo clique sobre o objeto rel_turmas






298 de 332





View e clique em Next. Será exibido outra tela, selecione o objeto “ds_rel_turmas” para ligar

o Rave com o ADOQuery_rel_turmas que possui o SELECT que configuramos anteriormente.


ADOQuery_rel_turmas.




299 de 332





Agora vamos inserir a banda principal, onde serão listadas as turmas do curso

escolhido. A banda principal deve ser uma DataBand e não uma Band comum. Então insira

um DataBand. Renomeie o objeto para “turmas”. Na propriedade BandStyle, clique em “...” e





Propriedade Valor

ControllerBand turmas

Selecione a DataBand “turmas” e altere as propriedades seguindo a tabela abaixo:

Propriedade Valor

DataView DataView1

DetailKey TURMA



300 de 332



“rel_turmas.rav”:

Após salvar o nosso projeto Rave, vamos inserir os objetos nas bandas criadas. Insira 4

objetos Text à Band “cabecalho”. Altere a propriedade Text deles para “Relação de Turmas por

Curso”, “Curso”, “Turma” e “Instrutor”. Insira também 1 DataText, altere a propriedade

DataView para “DataView1” e DataField para “CURSO”. Em seguida, os organize conforme

exibido na imagem abaixo:

Agora insira 2 objetos DataText à DataBand “turmas”. Altere a propriedade DataView

deles para “DataView1”. Altere a propriedade DataField para “TURMA” e “INSTRUTOR”


301 de 332



Estando de volta ao Delphi, iremos desativar o ADOQuery_rel_turmas e finalizar a

conexão estabelecida pelo ConexaoBD. Selecione o ADOQuery_rel_turmas, altere a

propriedade Active para False e limpe a propriedade SQL. Vá até o form_logon e selecione o

objeto ConexaoBD. Altere a propriedade Connected para False e limpe a propriedade

ConnectionString. Em seguida salve as alterações clicando em Save All. Feito isso, feche o

projeto e o abra novamente para o Delphi limpar o “cache” da conexão.

Voltando ao form_rel_turmas, programe os eventos abaixo.

Evento OnShow do form_rel_turmas:

Evento OnClick do btn_curso:

302 de 332


Evento OnClick do btn_ok:

Evento OnClick do btn_fechar:

Pronto, a relação de turmas por curso já está concluída! Vamos agora alterar o

form_relatorios para chamar o form_rel_turmas. Acesse o form_relatorios e digite o seguinte

no evento OnClick do botão “Relação de Turmas por Curso”:

303 de 332


Agora execute o projeto e teste o novo relatório!

304 de 332


Relação de Alunos por Turma

A relação de alunos por turma será bem semelhante ao último relatório que criamos.

Neste relatório, teremos uma tela de parâmetro onde o usuário deverá selecionar a turma

desejada e então a aplicação irá listar os alunos desta turma.


Configure a propriedade Name do novo Form como “Form_rel_alunos” e Caption como

“Relação de Alunos por Turma”. Aplique as mesmas configurações feitas para o form_logon


novo form. Salve-o como “Unit_rel_alunos”.

Após salvar o novo form, acesse a unit_rel_alunos e declare a seguinte variável na

seção public:

305 de 332


Após fazer a declaração, insira 1 objeto Label e 1 objeto Edit ao form_rel_alunos. Altere

a propriedade Caption do Label para “Turma”. Renomeie o objeto Edit para edt_turma, limpe a

propriedade Text, configure a propriedade Enable como “False” e Color como “clInfoBk”. Insira

2 objetos BitBtn ao form_rel_alunos, configure Name como “btn_ok” e “btn_fechar”. Configure

Caption como “Ok” e “Fechar”. Além disso, insira um outro BitBtn para selecionar a turma.

Configure-o da mesma maneira que foi configurado no form_matriculas. Em seguida, insira

dois objetos ADOQuery. Nós iremos utilizar um para fazer as consultas no banco e o outro para

montar o SELECT do relatório. Altere a propriedade Name dos ADOQuery’s para

“ADOQuery_rel_alunos” e “ADOQuery_aux”. Configure a propriedade Connection deles para

Fom_logon.ConexaoBD. Mas antes vá em File > Use Unit... e selecione a Unit_logon. Após

estas configurações, seu form deve ficar semelhante ao exibido abaixo:


RvDataSetConnection. Renomeie o RvProject para “rel_alunos” e o RvDataSetConnection para

“ds_rel_alunos”. Agora ligue o ds_rel_alunos ao ADOQuery_rel_alunos através da propriedade

DataSet.


ADOQuery_rel_alunos:

306 de 332





e ative o ADOQuery_rel_alunos. Se tiver alguma dúvida neste procedimento consulte o

capítulo “Montando o Pagamento de Instrutores”.

Após ativar o ADOQuery_rel_alunos, dê um duplo clique sobre o objeto rel_alunos









View e clique em Next. Será exibido outra tela, selecione o objeto “ds_rel_alunos” para ligar o

Rave com o ADOQuery_rel_alunos que possui o SELECT que configuramos anteriormente.

307 de 332



ADOQuery_rel_alunos.







Agora vamos inserir a banda principal, onde serão listadas os alunos da turma

escolhida. A banda principal deve ser uma DataBand e não uma Band comum. Então insira

um DataBand. Renomeie o objeto para “alunos”. Na propriedade BandStyle, clique em “...” e



308 de 332




Propriedade Valor

ControllerBand alunos

Selecione a DataBand “alunos” e altere as propriedades seguindo a tabela abaixo:

Propriedade Valor

DataView DataView1

DetailKey COD_ALUNO




“rel_alunos.rav”:

309 de 332



objetos Text à Band “cabecalho”. Altere a propriedade Text deles para “Relação de Alunos por

Turma”, “Turma”, “Código do Aluno”, “Nome do Aluno”, “Idade”, “Telefone” e “Sexo”. Insira

também 1 DataText, altere a propriedade DataView para “DataView1” e DataField para

“TURMA”. Em seguida, os organize conforme exibido na imagem abaixo:

Agora insira 5 objetos DataText à DataBand “alunos”. Altere a propriedade DataView

deles para “DataView1”. Altere a propriedade DataField para “CODIGO_ALUNO”, “NOME”,

“IDADE”, “TELEFONE” e “SEXO” respectivamente. Posicione-os conforme apresentado na

imagem abaixo:

310 de 332



Estando de volta ao Delphi, iremos desativar o ADOQuery_rel_alunos e finalizar a

conexão estabelecida pelo ConexaoBD. Selecione o ADOQuery_rel_alunos, altere a propriedade

Active para False e limpe a propriedade SQL. Vá até o form_logon e selecione o objeto

ConexaoBD. Altere a propriedade Connected para False e limpe a propriedade



Voltando ao form_rel_alunos, programe os eventos abaixo.

Evento OnShow do form_rel_alunos:


311 de 332




Pronto, a relação de alunos por turma já está concluída! Vamos agora alterar o

form_relatorios para chamar o form_rel_alunos. Acesse o form_relatorios e digite o seguinte

no evento OnClick do botão “Relação de Alunos por Turma”:

312 de 332



313 de 332


Relatório de Faltas dos Alunos

O relatório de faltas dos alunos será um relatório onde serão listados os alunos de uma

turma com a quantidade de faltas de cada um deles. Também teremos uma tela de

parâmetros idêntica ao relatório de alunos por turma.


Configure a propriedade Name do novo Form como “Form_rel_faltas” e Caption como

“Relatório de Faltas dos Alunos”. Aplique as mesmas configurações feitas para o form_logon


novo form. Salve-o como “Unit_rel_faltas”.

Após salvar o novo form, acesse a unit_rel_faltas e declare a seguinte variável na seção

public:

314 de 332


Após fazer a declaração, insira 1 objeto Label e 1 objeto Edit ao form_rel_faltas. Altere

a propriedade Caption do Label para “Turma”. Renomeie o objeto Edit para edt_turma, limpe a

propriedade Text, configure a propriedade Enable como “False” e Color como “clInfoBk”. Insira

2 objetos BitBtn ao form_rel_faltas, configure Name como “btn_ok” e “btn_fechar”. Configure

Caption como “Ok” e “Fechar”. Além disso, insira um outro BitBtn para selecionar a turma.

Configure-o da mesma maneira que foi configurado no form_matriculas. Em seguida, insira

dois objetos ADOQuery. Nós iremos utilizar um para fazer as consultas no banco e o outro para

montar o SELECT do relatório. Altere a propriedade Name dos ADOQuery’s para

“ADOQuery_rel_faltas” e “ADOQuery_aux”. Configure a propriedade Connection deles para

Fom_logon.ConexaoBD. Mas antes vá em File > Use Unit... e selecione a Unit_logon. Após

estas configurações, seu form deve ficar semelhante ao exibido abaixo:


RvDataSetConnection. Renomeie o RvProject para “rel_faltas” e o RvDataSetConnection para

“ds_rel_faltas”. Agora ligue o ds_rel_faltas ao ADOQuery_rel_faltas através da propriedade

DataSet.


ADOQuery_rel_faltas:

315 de 332





e ative o ADOQuery_rel_faltas. Se tiver alguma dúvida neste procedimento consulte o capítulo

“Montando o Pagamento de Instrutores”.

Após ativar o ADOQuery_rel_faltas, dê um duplo clique sobre o objeto rel_faltas









View e clique em Next. Será exibido outra tela, selecione o objeto “ds_rel_faltas” para ligar o

Rave com o ADOQuery_rel_faltas que possui o SELECT que configuramos anteriormente.

316 de 332



ADOQuery_rel_faltas.







Agora vamos inserir a banda principal, onde serão listadas as faltas dos alunos da

turma escolhida. A banda principal deve ser uma DataBand e não uma Band comum. Então

insira um DataBand. Renomeie o objeto para “faltas”. Na propriedade BandStyle, clique em

“...” e marque a opção Detail.


317 de 332




Propriedade Valor

ControllerBand alunos

Selecione a DataBand “faltas” e altere as propriedades seguindo a tabela abaixo:

Propriedade Valor

DataView DataView1

DetailKey COD_ALUNO




“rel_faltas.rav”:

318 de 332



objetos Text à Band “cabecalho”. Altere a propriedade Text deles para “Relação de Faltas dos

Alunos”, “Turma”, “Código do Aluno”, “Nome do Aluno” e “Faltas”. Insira também 1 DataText,

altere a propriedade DataView para “DataView1” e DataField para “TURMA”. Em seguida, os

organize conforme exibido na imagem abaixo:

Agora insira 3 objetos DataText à DataBand “faltas”. Altere a propriedade DataView

deles para “DataView1”. Altere a propriedade DataField para “CODIGO_ALUNO”, “NOME” e

“FALTAS” respectivamente. Posicione-os conforme apresentado na imagem abaixo:

319 de 332



Estando de volta ao Delphi, iremos desativar o ADOQuery_rel_faltas e finalizar a

conexão estabelecida pelo ConexaoBD. Selecione o ADOQuery_rel_faltas, altere a propriedade





Voltando ao form_rel_faltas, programe os eventos abaixo.

Evento OnShow do form_rel_faltas:


320 de 332




Pronto, o relatório de faltas dos alunos já está concluído! Vamos agora alterar o

form_relatorios para chamar o form_rel_faltas. Acesse o form_relatorios e digite o seguinte no

evento OnClick do botão “Relatório de Faltas dos Alunos”:

321 de 332



322 de 332


Relatório de Aulas por Instrutor

O relatório de aulas por Instrutor será um relatório onde deverá constar a quantidade

de aulas que o instrutor selecionado deu em cada turma. Neste relatório teremos uma tela de

parâmetros onde o usuário selecionará o instrutor desejado.


Configure a propriedade Name do novo Form como “Form_rel_aulas” e Caption como

“Relatório Aulas por Instrutor”. Aplique as mesmas configurações feitas para o form_logon


novo form. Salve-o como “Unit_rel_aulas”.

Após salvar o novo form, acesse a unit_rel_aulas e declare a seguinte variável na seção

public:

323 de 332


Após fazer a declaração, insira 1 objeto Label e 1 objeto Edit ao form_rel_aulas. Altere

a propriedade Caption do Label para “Instrutor”. Renomeie o objeto Edit para edt_instrutor,

limpe a propriedade Text, configure a propriedade Enable como “False” e Color como

“clInfoBk”. Insira 2 objetos BitBtn ao form_rel_aulas, configure Name como “btn_ok” e

“btn_fechar”. Configure Caption como “Ok” e “Fechar”. Além disso, insira um outro BitBtn para

selecionar o instrutor. Configure-o da mesma maneira que foi configurado no

form_pag_instrutores. Em seguida, insira dois objetos ADOQuery. Nós iremos utilizar um para

fazer as consultas no banco e o outro para montar o SELECT do relatório. Altere a propriedade

Name dos ADOQuery’s para “ADOQuery_rel_aulas” e “ADOQuery_aux”. Configure a

propriedade Connection deles para Fom_logon.ConexaoBD. Mas antes vá em File > Use

Unit... e selecione a Unit_logon. Após estas configurações, seu form deve ficar semelhante ao

exibido abaixo:


RvDataSetConnection. Renomeie o RvProject para “rel_aulas” e o RvDataSetConnection para

“ds_rel_aulas”. Agora ligue o ds_rel_aulas ao ADOQuery_rel_aulas através da propriedade

DataSet.


ADOQuery_rel_aulas:

324 de 332





e ative o ADOQuery_rel_aulas. Se tiver alguma dúvida neste procedimento consulte o capítulo

“Montando o Pagamento de Instrutores”.

Após ativar o ADOQuery_rel_aulas, dê um duplo clique sobre o objeto rel_aulas









View e clique em Next. Será exibido outra tela, selecione o objeto “ds_rel_aulas” para ligar o

Rave com o ADOQuery_rel_aulas que possui o SELECT que configuramos anteriormente.

325 de 332



ADOQuery_rel_aulas.







Agora vamos inserir a banda principal, onde serão listadas as aulas do instrutor

escolhido. A banda principal deve ser uma DataBand e não uma Band comum. Então insira

um DataBand. Renomeie o objeto para “aulas”. Na propriedade BandStyle, clique em “...” e



326 de 332




Propriedade Valor


Selecione a DataBand “aulas” e altere as propriedades seguindo a tabela abaixo:

Propriedade Valor

DataView DataView1

DetailKey COD_TURMA




“rel_aulas.rav”:

327 de 332



objetos Text à Band “cabecalho”. Altere a propriedade Text deles para “Relatório de Aulas por

Instrutor”, “Código do Instrutor”, “Nome do Instrutor”, “Turma” e “Aulas”. Insira também 2

DataText’s, altere a propriedade DataView para “DataView1” e DataField para

“COD_INSTRUTOR” e “NOME”. Em seguida, os organize conforme exibido na imagem abaixo:

Agora insira 2 objetos DataText à DataBand “aulas”. Altere a propriedade DataView

deles para “DataView1”. Altere a propriedade DataField para “COD_TURMA” e “AULAS”


328 de 332



Estando de volta ao Delphi, iremos desativar o ADOQuery_rel_aulas e finalizar a

conexão estabelecida pelo ConexaoBD. Selecione o ADOQuery_rel_aulas, altere a propriedade





Voltando ao form_rel_aulas, programe os eventos abaixo.

Evento OnShow do form_rel_aulas:

Evento OnClick do btn_instrutor:

329 de 332




Pronto, o relatório de aulas por instrutor já está concluído! Vamos agora alterar o

form_relatorios para chamar o form_rel_aulas. Acesse o form_relatorios e digite o seguinte no

evento OnClick do botão “Relatório Aulas por Instrutor”:

330 de 332



331 de 332


Conclusão

Em fim terminamos! Ufa... Depois de tantas horas dedicadas a este curso você deve

estar um pouco cansado e satisfeito (esperamos que sim). Acreditamos que o objetivo deste

curso foi alcançado: Mostrar como desenvolver aplicações Delphi com um banco de dados

Cliente/Servidor. Aqui desenvolvemos assuntos que foram desde a introdução aos sistemas

gerenciadores de banco de dados, passando pelo aprendizado básico do SQL Server 2000 e o

controle de transações até a construção de uma aplicação de banco de dados. Conhecemos a

linguagem SQL e como ela pode ser útil em programas Delphi. Durante os exemplos citados

foram mostrados muitos conceitos que podem ser utilizados em outras aplicações.

Obviamente, a aplicação desenvolvida neste curso foi projetada com um propósito meramente

didático, entretanto você pode adaptá-la para ter uma abordagem mais comercial.

Despedimos-nos certos de que este trabalho será de grande importância aos

interessados no assunto. Esperamos que faça bom proveito deste material !

Grande abraço dos autores,

Rodrigo Costa e Sergio Ferreira

332 de 332

Documents

Delphi 7 - SQL Server 2000