delphi - apostila2, Notas de estudo de Cultura

Baixe delphi - apostila2 e outras Notas de estudo em PDF para Cultura, somente na Docsity!

Sumário

• Introdução a Banco de Dados e à Linguagem SQL.....................................................................
• Relacionamento entre Tabelas....................................................................................................
• A Linguagem SQL.......................................................................................................................
• Acessando Banco de Dados pelo Delphi...................................................................................
  • Abrindo e fechando uma tabela..................................................................................................
  • Inserindo, Editando e Gravando Dados......................................................................................
• Eventos do Componente Table
  • Usando Aliases pré-definidos.....................................................................................................
• Mais de um Formulário no Mesmo Aplicativo
• Usando o componete Query......................................................................................................
  • Instruções SQL com Query........................................................................................................
  • Somando os valores de um campo .............................................................................................
  • Buscando o Maior e o Menor Valor...........................................................................................
  • Usando Apenas Uma Query Para Várias Consultas...................................................................
  • Obtendo o Nome do Produto Além do Maior e Menor Preço ...................................................
  • Usando outros comandos SQL com Query................................................................................
  • Usando o comando INSERT e UPDATE ..................................................................................
• Introdução
• Versões do InstallShield
• Usando o InstallShield para Delphi 5.0......................................................................................
• Usando o InstallShield para Delphi 6.0......................................................................................
• Usando o InstallShield para Delphi 7.0......................................................................................
• Usando o Inno Setup.................................................................................................................

Introdução a Banco de Dados e à Linguagem SQL

O Delphi, quando integrado com banco de dados (BD), amplia significativamente os horizontes do programador. Vamos conhecer, neste capítulo, alguns conceitos que poderão ser utilizados em diversas situações.

Um Banco de Dados (BD) é um conjunto de arquivos que armazena informações com um determinado objetivo. Por exemplo, um banco de dados do setor contábil de uma empresa irá armazenar informações contábeis pertinentes àquela empresa, tais como fluxos de caixa e as totalizações das contas de Ativo e Passivo. Do mesmo modo, o banco de dados da Folha de Pagamento armazenará nomes de funcionários, valor dos salários de cada um, etc. Não devemos confundir Banco de dados com Sistema Gerenciador de Banco de Dados (SGBD). Este último permite uma visão macro do sistema, do qual fazem parte inclusive os softwares responsáveis pela administração e utilização do BD. O objetivo de se ter banco de dados, portanto, é o de unir informações em um só lugar, que poderão ser modificadas a qualquer tempo. Isso significa que podemos interagir com o BD, através de transações.

Uma transação é um conjunto de comandos que devem ser executados com o intuito de trocar informações com o BD antes que informações definitivas sejam gravadas. Após executar-se uma transação, poderemos ou não confirmá-la e, aí sim, estaremos ou não gravando aquelas informações pertinentes à transação no BD.

Grava-se uma transação num BD através de um comando COMMIT e descartam-se transações através de um comando ROLLBACK. Quando, ao invés de um COMMIT (confirmação), optamos por enviar ao Banco um ROLLBACK, estamos descartando todas as modificações realizadas no BD desde sua última gravação.

Por exemplo: suponha que um usuário do R.H. está conectado ao BD da empresa realizando modificações em salários de alguns cargos. No momento em que ele altera o valor do salário do cargo Gerente de Produção de R$ 2.000,00 para R$ 4.000,00 apenas ele próprio está ciente disso. Outro usuário conectado ao mesmo Banco e olhando os dados do mesmo cargo somente “enchergará” esta modificação quando o funcionário que a está editando enviar um COMMIT ao sistema. Aí então a alteração será gravada e estará disponível para consulta.

Para modificar ou criar dados novos em um BD há um conjunto específico de comandos que podemos utilizar e que encontra-se agrupado numa linguagem chamada SQL (Structure Query Language). A maioria dos Bancos de Dados traz consigo um aplicativo que suporta esta linguagem para que a comunicação com os dados fique padronizada.

Quando falamos em banco de dados, é necessário também que se fale em Triggers. Triggers são conjuntos de funções que disparam ações, normalmente associadas a instruções SQL (como INSERT, UPDATE e DELETE). Estas ações estão relacionadas à eventos do banco de dados e podem ser de 6 tipos:

• BEFORE INSERT
• BEFORE UPDATE
• BEFORE DELETE

• AFTER INSERT

• AFTER UPDATE

• AFTER DELETE

UPDATE Empregado SET Salario = Salario * :Indice End

A stored procedure acima, ao ser executada, aumentaria o salário de todos os funcionários de acordo com o índice (parâmetro Indice) de aumento passado. Para executar esta stored procedure passando um aumento de 10%, faríamos assim:

EXECUTE PROCEDURE Aumento (1.10)

Relacionamento entre Tabelas

Os sistemas de banco de dados atuais baseiam-se em um modelo matemático derivado da Teoria dos Conjuntos e que desenvolveu-se mais fortemente a partir da década de 70. Trata-se do Modelo Relacional. Os sistemas que suportam esse conceito são chamados Sistemas Gerenciadores de Bancos de Dados Relacionais (SGBDR). Dentre os bancos baseados neste modelo, temos: Interbase, da Borland, MS-SQL Server e MS-Access, da Microsoft, Oracle (da empresa homônima), IBM-DB2, da IBM, e outros.

Bancos de dados relacionais trabalham com tabelas. Um banco pode ter diversas tabelas, nas quais estão armazenadas dados de uma mesma “entidade”. Por exemplo, no banco de dados da empresa SG-TECNOLOGIES, pode haver uma tabela chamada Empregado, que guarda o registro de todos os funcionários da casa. Uma tabela é composta da junção de uma ou mais linhas e uma ou mais colunas, tal qual numa planilha de MS-Excel.

Já que um BD é formado por mais de uma tabela, é possível também que na empresa citada também haja uma tabela chamada Cargo, que mantém os nomes e uma breve descrição dos cargos existentes. Podemos, na verdade, imaginar a existência de diversas tabelas. Mas para que cada uma delas não represente um amontoado de informações dispersas, elas precisam manter um relacionamento. Se um funcionario da tabela Empregado ocupa um determinado cargo na empresa, provavelmente a tabela Cargo deve fazer alguma referência a ele também. Mas como se dá isso?

Em bancos relacionais, temos o conceito de Chave Primária e Chave Estrangeira. Através delas especificamos como uma tabela relaciona-se com a outra. Observe abaixo um esquema onde duas tabelas são unidas:

Figura 1 - Relacionamento entre tabelas

O campo CODIGO da tabela Empregado identifica cada funcionário cadastrado por um código único. Como não deve haver mais de um funcionário com o mesmo código, este campo, durante a criação da tabela, foi definido como sendo chave primária. Chave primária é justamente isso: não se pode repetir valores num determinado campo.

Por sua vez, na tabela Cargo, cada nome de cargo também tem um código. Impossível haver um cargo com o mesmo código; portanto, definiu-se aqui também como chave primária.

Agora, para que cada funcionário pudesse ser enquadrado num cargo, criou-se um campo a mais na tabela Empregado (aparentemente sem utilidade), que serve para guardar a associação entre funcionário e seu cargo. Esta é a nossa Chave Estrangeira. Ele referencia, na verdade, a chave primária de outra tabela.

A tabela de funcionários, tendo o campo CARGO como chave estrangeira (cujos valores vêm do campo CODIGO da tabela Cargo), realiza a associação desejada. Assim sendo, conclui-se que o funcionário JOSÉ é um Gerente de Setor e que o sr. ABREU e o sr. SILVA são operários.

A Linguagem SQL

“Desenvolvida nos laboratórios da IBM na primeira metade dos anos 70, a SQL constitui-se numa linguagem de acesso a banco de dados. Baseia-se nos princípios lançados por E. F. Codd, tendo sido projetada para viabilizar a construção de um produto relacional pela IBM. Apesar dessa origem, constitui-se hoje num padrão internacional para os SGBDRs [Sistema Gerenciador de Banco de Dados Relacionais], com especificações formalizadas pela ANSI (o último padrão publicado é de 1992) e adotadas em maior ou menor grau por vários fornecedores de bancos de dados, tendo sido implementada inclusive por produtos não exatamente relacionais”^1.

“A linguagem SQL é bastante ampla, suportando comandos para criação e manipulação de banco de dados, de tabelas, bem como de recuperação de dados. (...) a linguagem ainda oferece recursos de segurança, permitindo criar usuários do banco de dados e restringir seu acesso a eles”^2.

“Quando se deseja interagir diretamente com o banco de dados, sem o uso de uma linguagem de programação como a Delphi, deve-se escolher uma ferramenta para editar e executar os comandos SQL. Digitam-se os comandos SQL no editor da ferramenta, que tem alguma maneira de executar o comando. No Interbase, que vem com o Delphi Professional (versão Local Interbase) e com o Enterprise (versão para cinco usuários), há uma ferramenta chamada WISQL. Ela tem duas janelas: na superior, digita-se a sentença SQL, e na inferior, verificam-se os resultados (...)”^3.

(^1) MUNARI, 1997 (^2) SONNINO, 2000 (^3) Idem

Acessando Banco de Dados pelo Delphi

O Delphi pode acessar a grande maioria dos bancos de dados existentes no mercado utilizando seus próprios componentes ou de terceiros. Para aplicações mais simples, a Borland / CodeGear (fabricante do Delphi) desenvolveu uma interface de acesso a bancos de dados chamada de BDE

• Borland Database Engine.

“A BDE, por meio de drivers para cada banco de dados, permite acessar da mesma maneira tanto uma base de dados desktop quanto uma cliente-servidor. Isto traz muita flexibilidade: pode-se criar o sistema utilizando-se Paradox e implantar o sistema definitivo usando-se Oracle, sem grandes modificações”^4.

Inicialmente, trabalharemos com tabelas Paradox – um tipo simples, porém bastante eficiente - para que possamos adquirir uma visão prévia dos componentes de acesso a banco de dados do Delphi.

O Paradox, um sistema de banco de dados relacional baseados em tabelas, é mundialmente conhecido desde os primórdios da Informática; rivalizou durante anos com o DBase, que era o melhor de todos os bancos. O Paradox tem como diferencial ser um banco de dados relacional (o DBase não era), permitindo que suas tabelas se relacionem umas com as outras.

Para criar tabelas Paradox usaremos o programa Database Desktop, que acompanha o Delphi. Você pode encontrá-lo dentro do menu Tools do próprio Delphi ou acessando o menu Iniciar > Todos os Programas (ou apenas Programas, dependendo da configuração do seu Windows) > Borland Delphi 7 > Database Desktop. No Database Desktop, clique em File > New > Table. Escolha Paradox 7 e clique em OK.

Uma nova tela é exibida, onde deverão ser preenchidos os campos que irão compor a tabela:

(^4) SONNINO, 2000

Figura 2 - Criando tabelas com Database Desktop

Vamos entender o que significa cada coluna da janela que foi aberta:

• Field Name
  é onde devemos digitar o nome do campo da tabela. Por exemplo: NomeCliente, Endereco, Cidade, Estado, etc.
• Type
  permite que você escolha qual será o tipo do campo. Todo campo precisa ter um tipo associado a ele, de acordo com o tipo de dado que será armazenado. Por exemplo, NomeCliente irá guardar dados do tipo texto; logo, devemos escolher Alpha (representado pela letra “A”). Já um campo chamado QuantidadeVendida poderia ser Inteiro Longo (Long Integer, representado por “I”).
• Size
  define o tamanho máximo do campo, ou seja, o número máximo de caracteres que aquele campo será capaz de armazenar para cada registro criado. Em tabelas Paradox, campos numéricos do tipo inteiro não precisam dessa especificação. Já outros campos exigem esta informação, tal como o tipo Alpha, cujo tamanho pode variar de 1 caractere a 255 ou o tipo Memo (representado por “M”), capaz de armazenar num único arquivo algo entre 1 e 240 caracteres.
• Key
  a coluna “Key” permite selecionar um campo como chave-primária, isto é, um campo no qual nenhum dado poderá ser repetido.

Para o nosso exemplo, vamos criar uma tabela de clientes com apenas quatro campos: Nome, Endereco, Cidade e Estado. Para iniciar, clique logo abaixo da palavra Field Name e digite “Nome”. Pressione ENTER para avançar para a coluna seguinte e digite “A” (este será o tipo do campo: Alpha). Pressione ENTER de novo para mudar para a coluna Size e defina um tamanho de 80 caracteres (deve ser mais do que suficiente para nomes de clientes). Finalmente, pressione ENTER mais uma vez e, então, pressione a barra de espaços. Surgirá um asterisco (*) em Key,

alterar o programa: basta alterar para onde o alias aponta.”^5

Para criar um alias, clique em Tools > Alias Manager... e, na tela que se abrirá, clique no botão New. No campo Database alias, digite um nome para seu alias. Pode ser qualquer coisa, mas sem acentuação ou espaços. Em Driver type, deixe Standard selecionado – Standard é a opção padrão para tabelas Paradox e DBase. Em Path, você deve digitar o caminho em que se encontra a tabela de clientes que acabamos de criar. Você pode optar por clicar no botão Browse... e procurá-la na hierarquia de pastas, se não tiver certeza do caminho exato.

Feito isso, clique em OK, OK de novo e, depois, em Sim. Pronto. O seu alias está criado e você já pode sair do Database Desktop.

Voltemos, agora, ao Delphi para criarmos um aplicativo que permite cadastrar dados em nossa tabela e pesquisá-los. Para isso, inicie um aplicativo novo clicando em File > New > Application. Procure a paleta BDE e coloque um componente Table no seu formulário. Este componente permitirá o acesso aos dados da tabela Clientes. Vamos configurá-lo para isso, então.

No Object Inspector, procure a propriedade DatabaseName e selecione o Alias que você acabou de criar. Mais abaixo, em TableName, procure suas tabela Clientes: ela deverá aparecer listada ali.

Vamos, agora, informar ao componente Table quais campos da tabela queremos ver em nosso formulário. Dê dois cliques em Table e, então, com o botão direito do mouse, escolha a opção Add Fields.... Selecione todos os campos e clique em OK. Você terá algo semelhante à Figura 5.

Fazendo isso, nosso componente Table já sabe quais serão os campos disponíveis para nossa aplicação, mas se deixarmos apenas assim, nosso usuário não possuirá acesso a eles. Precisamos, então, torná-los disponíveis também no formulário. Para isso, selecione todos os campos do Table e arraste-os com o mouse, soltando-os bem em cima do formulário. Vários objetos, semelhantes a Labels e Edits serão acrescentados automaticamente ao formulário. São, na

verdade, objetos Labels (específicos para referenciar objetos vindo de tabelas) e DBEdits (Edits que acessam os campos das tabelas). Cada campo tem seu

(^5) SONINNO, 2000

Figura 5 - Campos da tabela

próprio Label e DBEdit, conforme mostrado na figura a seguir:

Figura 6 - Formulário com DBTexts e DBEdits

É necessário reduzir um pouco o tamanho destes DBEdits para que caibam na tela. Segurando SHIFT no teclado, clique em cada um deles para selecionar todos ao mesmo tempo e, então, no Object Inspector, procure a propriedade Width, referente à largura dos componentes. Altere-a para um valor bem menor, algo em torno de 500 ou 400, por exemplo. Pressione ENTER e seus campos ficarão com um tamanho bem mais adequado.

Aproveite e note também que, ao arrastar os campos para o formulário, além dos componentes já

citados, outro item apareceu: é um Datasource ( ). Este objeto liga-se automaticamente à Table para fazer uma “ponte” entre os DBEdits e a tabela. Como arrastamos os campos, ele apareceu automaticamente, mas isso nem sempre acontecerá. Em alguns casos, será necessário buscá-lo na paleta Data Access e adicioná-lo manualmente.

Como podemos perceber olhando para a Figura 5, foi muito fácil colocar os campos da tabela no formulário. Ao serem arrastados para o form, eles automaticamente se tornam componentes do tipo DBEdit. O DBEdit é um componente semelhante ao Edit (que já estudamos anteriormente, na Parte 1 dessa apostila), mas com a vantagem de que ele se conecta diretamente com os campos da tabela. Isso significa que, tudo o que for digitado neles, será gravado, posteriormente, na tabela. E os rótulos que indicam os nomes dos campos, tais como “Nome”, “Endereco”, etc, são componentes DBText, também criados automaticamente durante o arraste.

procedure TForm1. FormClose(Sender: TObject; var Action: TCloseAction); begin Table1.Active := False; Table2.Active := False; Table3.Active := False; end;

Opcionalmente, você também poderá usar o método Open e o método Close para, respectivamente, abrir e fechar suas tabelas, ao invés de usar a propriedade Active. Observe como seria:

procedure TForm1.FormCreate(Sender: TObject); begin Table1.Open ; end;

E, para fechar:

procedure TForm1. FormClose(Sender: TObject; var Action: TCloseAction); begin Table1.Close;

end;

Inserindo, Editando e Gravando Dados

Para podermos inserir dados e gravá-los, precisamos colocar a tabela no que chamamos de “modo de inserção”. Quando a tabela assume esse estado, o componente Table passa a permitir que o que está sendo digitado seja realmente inserido numa propriedade chamada EditText do DBEdit. E ao mandarmos que os dados sejam gravados, tudo o que estiver na propriedade EditText é, de fato, transferido do componente para a tabela física no disco e salvo adequadamente.

Podemos conseguir tudo isso com um simples componente: o DBNavigator, da paleta Data Controls. Trata-se de uma barra com 10 botões, cada um com uma função específica.

Figura 8 - O componente DBNavigator

O botão de adição (+) é aquele que precisamos para colocar a tabela em modo de inserção; já o

botão  grava os dados. Além disso, as setas permitem a navegação pelo cadastro. Veja abaixo

qual a finalidade de cada botão:

Botão Função

Vai para o primeiro registro da tabela Volta um registro Avança para o registro seguinte da tabela Avança para o último registro Insere um novo registro Deleta o registro atual Modifica o registro atual Grava um registro Cancela a modifcação ou a inserção de um novo registro, desde que ainda não tenha sido gravado Atualiza os dados na tela, enviando um comando “refresh” para a tabela

Eventos do Componente Table

O componente Table permite o tratamento de vários eventos através da guia Events do Object Inspector. Vale a pena olhar, ao menos, três deles:

Ajuste os campos no form para que fiquem semelhantes à Erro! Fonte de referência não encontrada.. Adicione, ainda, um DBNavigator (da paleta Data Controls) e, através de sua propriedade DataSource, conecte-o ao Datasource1.

Para visualizarmos o que já temos cadastrado ali, precisamos abrir a tabela, o que é sempre interessante fazermos via código. Para isso, no evento OnCreate do form, coloque isto:

procedure TForm1.FormCreate(Sender: TObject); begin Table1.Open; end;

Ainda no layout, aumente um pouco as dimensões do objeto DBImage para que as figuras que estão no banco de dados possam ser vistas por completo. Uma largura de 200 pixels por 185 de altura deve ser suficiente:

Figura 11 - Modificando o layout

Figura 10 - Layout da aplicação com DBDEMOS

Execute sua aplicação pressionando F9 e veja os dados contidos nesta tabela:

Figura 12 - Dados da tabela 'animals.dbf'

Note que as imagens da tabela são armazenadas num campo do tipo BINARY (ou BLOB – Binary Large Object), que permite a inserção de dados que não sejam caracteres numéricos, lógicos ou de texto. Se você abrir a tabela animals.dbf no Database Desktop verá estes dados:

Para campos que armazenam figuras o Delphi traz um componente específico para exibi-las: o DBImage. Ele é capaz de ler os dados binários lá armazenados e carregá-los no componente para visualização.

Claro que você também pode inserir suas próprias figuras ali, desde que estejam no formato Bitmap do Windows (.Bmp). Vamos fazer isso com nossa aplicação. Adicione um botão abaixo do DBImage e altere seu Caption para “Inserir Figura”. É interessante ainda adicionarmos um componente não-visual chamado OpenPictureDialog, da paleta Dialogs, que nos permite buscar pelas pastas do sistema a figura deseja e selecioná-la para inserção no banco.

Dê dois cliques no botão que você adicionou para gerar um evento OnClick para ele. Lá, digite o seguinte:

Figura 13 - Registros da tabela