DESENVOLVIMENTO DESENVOLVIMENTO DE SISTEMAS S ISTEMAS UTILIZANDO DELPHI E FIREBIRD
Professor Francisco das Chagas de Mariz Fernandes Diretor Geral do Centro Federal de Educação Tecnológica Tecnol ógica do Rio Grande do Norte Professor Enilson de Araújo Pereira Diretor da Unidade Sede Professor Dante Henrique Moura Diretor de Ensino Professor Jucelino Cardoso de Medeiros Diretor de Administração e Planejamento Professor Liznando Fernandes da Costa Diretor de Relações Empresarias e Comunitárias Professora Anna Catharina da Costa Dantas Gerente Educacional da Tecnologia da Informação Professora Anna Catharina da Costa Dantas Coordenador do Curso de Tecnologia da Informática Professor Gilbert Azevedo da Silva Orientador Orientador do Estágio Professor Raimundo Raimundo Nonato Camelo Parente Coordenador de Estágio Supervisionado Estágio realizado na Accessus Consultores e Associados sob a supervisão do Analista de Sistemas Zalkind Lincoln. Lincoln. Divisão de Serviços Técnicos Catalogação da Publicação na Fonte. CEFET-RN
SOUZA FILHO, Silvio Oliveira Oliveira de. Desenvolvimento Desenvolvimento de sistemas utilizando Delphi e Firebird. Natal, 2005.
102 p.
1.Banco de dados. dados. 2. Desenvolvimento de Software. 3.Delphi. I.Autor. II.Título.
S729d
Professor Francisco das Chagas de Mariz Fernandes Diretor Geral do Centro Federal de Educação Tecnológica Tecnol ógica do Rio Grande do Norte Professor Enilson de Araújo Pereira Diretor da Unidade Sede Professor Dante Henrique Moura Diretor de Ensino Professor Jucelino Cardoso de Medeiros Diretor de Administração e Planejamento Professor Liznando Fernandes da Costa Diretor de Relações Empresarias e Comunitárias Professora Anna Catharina da Costa Dantas Gerente Educacional da Tecnologia da Informação Professora Anna Catharina da Costa Dantas Coordenador do Curso de Tecnologia da Informática Professor Gilbert Azevedo da Silva Orientador Orientador do Estágio Professor Raimundo Raimundo Nonato Camelo Parente Coordenador de Estágio Supervisionado Estágio realizado na Accessus Consultores e Associados sob a supervisão do Analista de Sistemas Zalkind Lincoln. Lincoln. Divisão de Serviços Técnicos Catalogação da Publicação na Fonte. CEFET-RN
SOUZA FILHO, Silvio Oliveira Oliveira de. Desenvolvimento Desenvolvimento de sistemas utilizando Delphi e Firebird. Natal, 2005.
102 p.
1.Banco de dados. dados. 2. Desenvolvimento de Software. 3.Delphi. I.Autor. II.Título.
S729d
CENTRO FEDERAL FEDER AL DE EDUCAÇÃO TECNOLÓGICA DO RIO GRANDE DO NORTE DIRETORIA DE ENSINO GERÊNCIA DE TECNOLOGIA DA INFORMAÇÃO E EDUCACIONAL DE TELEMÁTICA CURSO SUPERIOR DE TECNOLOGIA TECNO LOGIA EM INFORMÁTICA
DESENVOLVIMENTO DESENVOLVIMENTO DE SISTEMAS S ISTEMAS UTILIZANDO DELPHI E FIREBIRD
Silvio Oliveira de Souza Filho Trabalho apresentado em cumprimento às exigências legais da disciplina Estágio Supervisionado, sob a orientação do Professor MSc. Gilbert Azevedo da Silva, co-orientaçã co-ori entação o e supervisão do Professor Raimundo Nonato Camelo Parente para obtenção do título de Tecnólogo em Informática.
Natal – RN Junho de 2005 ii
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DO RIO GRANDE DO NORTE DIRETORIA DE ENSINO GERÊNCIA DE TECNOLOGIA DA INFORMAÇÃO E EDUCACIONAL DE TELEMÁTICA CURSO SUPERIOR DE TECNOLOGIA EM INFORMÁTICA
DESENVOLVIMENTO DE SISTEMAS UTILIZANDO DELPHI E FIREBIRD
Silvio Oliveira de Sou za Filho Trabalho apresentado em cumprimento às exigências legais da disciplina Estágio Supervisionado, sob a orientação do Professor MSc. Gilbert Azevedo da Silva, co-orientação e supervisão do Professor Raimundo Nonato Camelo Parente para obtenção do título de Tecnólogo em Informática.
Período de realização do estágio: __________________ Carga Horária: _______ Data da apresentação para apreciação: ______________ Resultado: ________________________________________________________
Comissão de Avaliação do Relatório _________________________________________________________________ Prof. MSc. Gilbert Azevedo da Silva Orientador
_________________________________________________________________ Professor MSc. Raimundo Nonato Camelo Parente Avaliador 1
_________________________________________________________________ Professor MSc. Eduardo Janser Azevedo Dantas Avaliador 2
Natal – RN,
iii
de
de 2005.
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DO RIO GRANDE DO NORTE DIRETORIA DE RELAÇÕES EMPRESARIAIS – Coordenação de Integração Escola Empresa Endereço: Av Senador Salgado Filho, 1559 – Tirol – CEP: 59015- 000 Fones (0xx84) 4005-2627 FAX (0xx84) 4004-2697 FICHA DE AVALIAÇÃO DO ESTAGIÁRIO
ESTAGIÁRIO: ___________________________________________________________ CURSO: ______________________________________ÁREA:____________________ 01.
O Plano de estágio proposto foi executado em: 20% ( )
40% ( )
60% ( )
80% ( )
100% ( )
Se inferior a 60% justifique: _______________________________________________________________________________ _______________________________________________________________________________ 02.
A empresa ou instituição ficou satisfeita com os resultados do projeto de estágio
executado? Sim ( )
Não ( )
Em parte ( )
Em caso “negativo” ou “Em parte”, justifique: _______________________________________________________________________________ _______________________________________________________________________________ 03.
O Estagiário apresentou dificuldades quanto à adaptação inicial ao trabalho e ao
desenvolvimento das atividades técnicas? Em caso positivo, enumera-las. _______________________________________________________________________________ _______________________________________________________________________________ 04.
O estagiário preenche os requisitos técnicos que a profissão exige? Sim ( )
05.
Como você classifica o nível técnico-prático do nosso aluno: Ruim ( )
06.
Não ( ) Regular ( )
Bom ( )
Excelente (
)
Que sugestões a empresa ou instituição daria ao CEFET para melhorar o nível de
conhecimento técnico do aluno? _______________________________________________________________________________ _______________________________________________________________________________
Natal, ______/______/2005
CARIMBO DA EMPRESA/INSTITUIÇÃO
Assinatura do chefe imediato
iv
Gostaria de agradecer primeiramente a Deus, pela oportunidade que me foi dada não só de ingressar neste curso, mas também de poder concluí-lo; à minha família, pelo incentivo, compreensão, paciência, dedicação, educação e, sobretudo, amor incondicional; à minha namorada, pelo constante incentivo, companheirismo e amor durante o curso; aos professores do Curso de Tecnologia em Informática, pelos conhecimentos e lições de vida transmitidos; aos colegas de turma, pelo agradável convívio e ajuda mútua; e a todos, que direta ou indiretamente contribuíram para o desenvolvimento deste trabalho.
v
SUMÁRIO LISTA DE FIGURAS _____________________________________________________________ ix LISTA DE TABEL AS _____________________________________________________________x LISTA DE EXEMPLOS___________________________________________________________ xi RESUMO _____________________________________________________________________ xii ABSTRACT ___________________________________________________________________ xiii INTRODUÇÃO___________________________________________________________________1 1.
2.
CARACTERIZAÇÃO DA INSTITUIÇÃO ________________________________________2 1.1.
A Empresa ______________________________________________________________2
1.2.
Histórico________________________________________________________________2
1.3.
Vetor de Negócios _______________________________________________________2
1.4.
Estrutura Funcional e Local do Desenvolvimento do Estágio _________________3 FUNDAMENTAÇÃO TEÓRICA _______________________________________________4
2.1. Banco de Dados_________________________________________________________4 2.1.1. Introdução __________________________________________________________4 2.1.2. Conceito ____________________________________________________________4 2.1.3. Sistema de Gerenciamento de Bancos de Dados (SGBD) _________________4 2.1.4. Características Gerais de um SGBD ____________________________________7 2.2. Uma Introdução à SQL __________________________________________________10 2.2.1. A Instrução SELECT ________________________________________________10 2.2.1.1. Calculando Valores _____________________________________________13 2.2.1.2. Definindo Grupos _______________________________________________13 2.2.2. A Instrução INSERT _________________________________________________14 2.2.3. A Instrução DELETE ________________________________________________14 2.2.4. A Instrução UPDATE ________________________________________________14 2.3. Banco de Dados Firebird ________________________________________________14 2.3.1. Histórico ___________________________________________________________15 2.3.2. Edições do Firebird _________________________________________________17 2.3.3. Administrando o Firebird ____________________________________________18 2.3.4. Características _____________________________________________________19 2.3.5. Comparação _______________________________________________________24 2.4. Modelos de Dados ______________________________________________________25 2.4.1. O Modelo Entidade -Relacionamento __________________________________25 2.4.2. O Modelo Relacional ________________________________________________30 2.5. Algoritmo ______________________________________________________________32 2.5.1. Conceito de Algoritmo_______________________________________________32 2.5.2. Formas de Representação de Algoritmos______________________________33 2.5.3. Descrição Narrativa _________________________________________________34 2.5.4. Fluxograma Convencional ___________________________________________35 2.5.5. Diagrama de Chapin_________________________________________________36 2.5.6. Pseudocódigo ______________________________________________________37 2.5.7. Fases de um Algoritmo ______________________________________________39 2.5.8. Variáveis___________________________________________________________40 2.5.8.1. Formação de Variáveis __________________________________________40 2.5.8.2. Tipos de Dados _________________________________________________40
vi
2.5.8.3. Definição de Variáveis___________________________________________41 2.5.9. Comando de Atribuição______________________________________________42 2.5.10. Operadores Matemáticos __________________________________________43 2.5.11. Operadores Lógicos_______________________________________________43 2.5.12. Comandos de Entrada e Saída ______________________________________44 2.5.13. Estruturas de Repetição ___________________________________________45 2.5.13.1. Comando While_________________________________________________45 2.5.13.2. Comando FOR __________________________________________________46 2.5.13.3. Comando REPEAT / UNTIL _______________________________________47 2.5.14. Estruturas de Seleção _____________________________________________48 2.5.15. Sub-rotinas_______________________________________________________49 2.5.16. Variáveis Globais e Locais _________________________________________50 2.5.17. Passagem de Parâmetros __________________________________________50 2.5.18. Função __________________________________________________________51 2.6. Delphi _________________________________________________________________53 2.6.1. Introdução _________________________________________________________53 2.6.2. Conceitos Básicos do Ambiente Delphi________________________________54 2.6.3. Ambientes de Desenvolvimento ______________________________________54 2.6.4. Características do Delphi ____________________________________________55 2.6.5. Escrevendo Aplicações______________________________________________56 2.6.5.1. Estrutura do Código _____________________________________________56 2.6.5.2. Arquivos de uma Aplicação ______________________________________58 2.6.5.3. Arquivos Gerados pela Compilação_______________________________59 2.6.5.4. Exemplo de Aplicação ___________________________________________59 2.6.5.5. O Arquivo de Projeto (*.DPR) _____________________________________60 2.6.5.6. As Unidades (*.PAS)_____________________________________________61 2.6.5.7. Eventos________________________________________________________63 2.6.6. Elementos Visuais __________________________________________________65 2.6.6.1. Form __________________________________________________________65 2.6.6.2. Component Palette (Palheta de Componentes) _____________________66 2.6.6.3. Object Inspector (Inspetor de Objetos) ____________________________67 2.6.6.4. Code Editor (Editor de Código) ___________________________________68 2.6.6.5. SpeedBar ______________________________________________________70 2.6.6.6. Help On-Line ___________________________________________________71 2.6.7. Suporte a Programação Orientada a Objeto ____________________________72 2.6.7.1. Propriedades___________________________________________________73 2.6.7.2. Eventos________________________________________________________74 2.7. Delphi Acessando Banco de Dados _______________________________________74 2.7.1. Introdução _________________________________________________________74 2.7.2. Relacionamento entre o Delphi e a Conectividade de Banco de Dados ____75 2.7.3. Ferramentas de Bancos de Dados ____________________________________76 2.7.4. Borland Database Engine (BDE) ______________________________________76 2.7.5. Relacionamento entre o BDE e Outros Produtos Borland ________________77 2.7.6. Database Desktop __________________________________________________77 2.7.7. Descrição do Componente DataSource ________________________________78 2.7.8. Descrição dos Componentes da Guia BDE _____________________________79 2.7.9. Descrição dos Componentes Data Control _____________________________80 2.7.10. Usando DataSets _________________________________________________82 2.7.10.1. Abrindo e Fechando DataSets ____________________________________82 2.7.10.2. Navegando no Dataset __________________________________________83 2.7.10.3. Modificando Dados no Dataset ___________________________________83 2.7.10.4. Lendo Valores do Campo ________________________________________84 2.8. Conexão do Delphi com Interbase/Firebird_________________________________84 2.8.1. Montando uma Conexão_____________________________________________85 2.8.2. Acessando Dados __________________________________________________87 2.8.2.1. Utilizando o IBDataSet___________________________________________88 2.8.2.2. Utilizando o IBSQL ______________________________________________90
vii
3.
METODOLOGIA __________________________________________________________92
4.
RESULTADOS____________________________________________________________93
5.
CONCLUSÃO ____________________________________________________________98
6.
RECOMENDAÇÕES E SUGESTÕES _________________________________________99
BIBLIOGRAFIA________________________________________________________________100 ANEXO A_____________________________________________________________________101
viii
LISTA DE FIGURAS Figura 1: entidades dominante e subordinada .............................................................27 Figura 2: relacionamento .................................................................................................27 Figura 3: cardinalidade.....................................................................................................28 Figura 4: auto-relacionamento ........................................................................................29 Figura 5: agregação..........................................................................................................29 Figura 6: generalização....................................................................................................30 Figura 7: especialização ..................................................................................................30 Figura 8: principais formas geométricas usadas em fluxogramas............................35 Figura 9: algoritmo escrito em fluxograma....................................................................36 Figura 10: diagrama de Chapin......................................................................................37 Figura 11: Form em branco .............................................................................................66 Figura 12: Compone nt Palette ........................................................................................67 Figura 13: Object Inspector .............................................................................................68 Figura 14: Code Editor .....................................................................................................70 Figura 15: SpeedBar ........................................................................................................70 Figura 16: help ...................................................................................................................72 Figura 17: acesso a banco de dados.............................................................................75 Figura 18: conectividade do BDE...................................................................................76 Figura 19: Database Desktop .........................................................................................78 Figura 20: esquema de ligação entre Dataset, DataSource e Data Controls .........79 Figura 21: conexão entre Data Control, Data Source, DataSets, BDE e Banco de Dados..................................................................................................................................82 Figura 22: componentes InterBase ................................................................................85 Figura 23: propriedades do banco de dados................................................................86 Figura 24: propriedades das transações.......................................................................87 Figura 25: editor de SQL SELECT.................................................................................88 Figura 26: gerador de SQLs............................................................................................90 Figura 27: ferramenta de ponto ......................................................................................94 Figura 28: fábrica de relatórios .......................................................................................95 Figura 29: ferramenta de pesquisa ................................................................................96 Figura 30: exportação e importação de informações..................................................97 Figura 31: gerenciador de backup e manutenção do banco de dados....................97
ix
LISTA DE TABELAS
Tabela 1: operadores para a cláusula WHERE ...........................................................11 Tabela 2: comparação entre bancos de dados gratuitos. ..........................................24 Tabela 3: preços de alguns SGBDs...............................................................................25 Tabela 4: tabela no modelo relacional...........................................................................31 Tabela 5: tipos de dados..................................................................................................41 Tabela 6: operadores matemáticos................................................................................43 Tabela 7: operadores lógicos..........................................................................................43 Tabela 8: resultados usando AND .................................................................................43 Tabela 9: resultados usando OR ....................................................................................44 Tabela 10: resultados usando NOT ...............................................................................44 Tabela 11: arquivos de uma aplicação..........................................................................58 Tabela 12: arquivos gerados na compilação................................................................59 Tabela 13: exemplo de arquivos de uma aplicação ....................................................59 Tabela 14: botões do SpeedBar.....................................................................................71 Tabela 15: componentes BDE........................................................................................79 Tabela 16: componentes Data Controls ........................................................................81 Tabela 17: propriedades e métodos de navegação ....................................................83 Tabela 18: métodos para modificar um dataset...........................................................84 Tabela 19: componentes InterBase ...............................................................................88
x
LISTA DE EXEMPLOS
Exemplo 1: SELECT e WHERE .....................................................................................11 Exemplo 2: cláusula WHERE com AND .......................................................................11 Exemplo 3: DISTINCT......................................................................................................12 Exemplo 4: ORDER BY...................................................................................................12 Exemplo 5: SELECT de várias tabelas .........................................................................13 Exemplo 6: cálculo ............................................................................................................13 Exemplo 7: GROUP BY...................................................................................................14 Exemplo 8: INSERT..........................................................................................................14 Exemplo 9: DELETE.........................................................................................................14 Exemplo 10: UPDATE......................................................................................................14 Exemplo 11: algoritmo usando descrição narrativa ....................................................34 Exemplo 12: elementos do pseudocódigo ....................................................................38 Exemplo 13: pseudocódigo .............................................................................................39 Exemplo 14: definições de variáveis..............................................................................41 Exemplo 15: atribuição.....................................................................................................42 Exemplo 16: READ e WRITE ..........................................................................................44 Exemplo 17: estrutura do WHILE ...................................................................................45 Exemplo 18: WHILE .........................................................................................................46 Exemplo 19: estrutura do FOR .......................................................................................46 Exemplo 20: FOR..............................................................................................................47 Exemplo 21: estrutura do REPEAT................................................................................47 Exemplo 22: REPEAT......................................................................................................48 Exemplo 23: estrutura IF ..................................................................................................48 Exemplo 24: IF ..................................................................................................................49 Exemplo 25: estrutura de uma PROCEDURE .............................................................50 Exemplo 26: passagem de parâmetro...........................................................................51 Exemplo 27: estrutura de uma FUNCTION..................................................................52 Exemplo 28: valor a ser retornado pela FUNCTION...................................................52 Exemplo 29: projeto ..........................................................................................................61 Exemplo 30: estrutura de uma Unit................................................................................63 Exemplo 31: evento ..........................................................................................................65 Exemplo 32: formas de ler dados...................................................................................84 Exemplo 33: controle de transação e IBSQL ...............................................................91
xi
RESUMO
Este Relatório descreve a participação do estagiário Silvio Oliveira de Souza Filho no processo de desenvolvimento e manutenção dos sistemas criados pela Accessus Consultores e Associados na figura do analista de sistemas Zalkind Lincoln. O objetivo do estágio foi de fazer melhorias nos sistemas Patho Control, sistema de elaboração e emissão de laudos e gerenciamento de laboratórios de Anatomia Patológica, e Cyto Control, sistema de elaboração e emissão de laudos e gerenciamento de laboratórios de Citopatologia. Apesar desses sistemas já estarem em fase de manutenção, havia a necessidade de aumentar a velocidade de implementações e de realizar mudanças exigidas por muitos usuários espalhados por todo o Brasil. Foi utilizado durante o estágio o ambiente de desenvolvimento integrado Delphi 5, banco de dados MS Access 2000, sendo este acessado através do Borland Database Engine – BDE. Durante o estágio foi exigido basicamente conhecimentos de banco de dados e linguagem de programação. A modelagem do banco de dados é importante para um bom funcionamento da aplicação, pois garante velocidade e recuperação adequada das informações inseridas no banco de dados, além de facilitar o trabalho de programação. A linguagem de programação Pascal, que é utilizada pelo Delphi para a criação dos aplicativos, é simples, mas capaz de oferecer todos os recursos necessários para a construção de aplicações, o que, juntamente com o ambiente visual fornecido pelo Delphi, torna o processo de criação simples, rápido e prático. Entre as modificações realizadas, damos destaque a migração do código fonte para o Delphi 6, eliminação do acesso através do BDE e alteração do banco de dados para o Firebird, que, além de proporcionar um acesso mais rápido, uma maior segurança e estabilidade, é um banco de dados totalmente gratuito. Para atingir os objetivos almejados no estágio, foram utilizadas como fonte de pesquisa as anotações de aula de diversas disciplinas, livros sobre Delphi, manuais de componentes utilizados no desenvolvimento e, evidentemente, a Internet.
Palavras-chave: Banco de dados Desenvolvimento de software Delphi
xii
ABSTRACT
This Report describes the participation of the trainee Silvio Oliveira de Souza Filho in the development and maintenance of the systems created by the Accessus Consultores e Associados in the figure of the Analyst of Systems Zalkind Lincoln. The objective of the period of training was to make improvements in the Patho Control, system of elaboration and emission of findings and management of laboratories of Pathological Anatomy, and in the Cyto Control, system of elaboration and emission of findings and management of laboratories of Citopatologia. Despite these systems already being in maintenance phase, they had the necessity to increase the speed of implementations and to make changes demanded for many users. It was used during the period of training the integrated development environment Delphi 5, database MS Access 2000, being this had access through the Borland Database Engine - BDE. During the period of training it was basically demanded knowledge of database and programming language. The modeling of the database is important for a good functioning of the application, it will go to guarantee speed and the adequate recovery of the inserted information in the data base, besides facilitating the programming work. The Pascal programming language that is used by the Delphi for the creation of the applications is simple, but it offers all the necessary resources for the construction of applications, what together with the visual environment supplied by the Delphi it becomes the process of creation simple, fast and practical. One of modifications that we give to prominence was the migration of the code source for Delphi 6, elimination of the access through the BDE and alteration of the database for the Firebird, that besides providing a faster access, offer a greater security and stability, is total free. To reach these objectives, were used as research source the notations of lesson of diverse disciplines, books about Delphi, manuals of components used in the development and the Inter net.
Keywords: Database Software development Delphi
xiii
INTRODUÇÃO
A finalidade do presente relatório é descrever a seqüência de atividades executadas durante o estágio em uma empresa de desenvolvimento de sistemas. Neste relatório tem-se uma breve caracterização da Instituição onde se desenvolveu o estágio. Logo em seguida, são apresentadas: a Fundamentação Teórica necessária para embasar os conhecimentos utilizados; a metodologia utilizada no decorrer do desenvolvimento do mesmo; e, finalmente, a conclusão com uma síntese das experiências adquiridas com o estágio supervisionado. Os sistemas que foram objeto do presente relatório são o Patho Control, sistema de elaboração e emissão de laudos e gerenciamento de laboratórios de Anatomia Patológica, e Cyto Control, sistema de elaboração e emissão de laudos e gerenciamento de laboratórios de citopatologia. Apesar desses sistemas já estarem em fase de manutenção, havia a necessidade de aumentar a velocidade de implementações e de realizar mudanças exigidas por muitos usuários.
1
1. CARACTERIZAÇÃO DA INSTITUIÇÃO 1.1.
A Empresa A Accessus Consultores e Associados tem como objetivo produzir e
desenvolver software de qualidade para ajudar seus clientes a atingir, da melhor maneira possível, suas metas. Sua razão social é Fagundes & Fagundes Ltda e seus proprietários são Zalkind Lincoln, Alair Fagundes e Salustiano Fagundes.
1.2.
Histórico Após a conclusão do curso de Ciência da Computação na Universidade
Federal do Rio Grande do Norte (UFRN), Zalkind Lincoln iniciou o desenvolvimento de sistemas personalizados e, em 1994, deu-se a criação da IPSO Consultoria Ltda. Com o amadurecimento do negócio, Zalkind reuniu-se com Alair e Salustiano para então criar a Accessus Consultores e Associados no ano de 2000.
1.3.
Vetor de Negócios A
Accessus
Consultores
e
Associados
se
especializou
no
desenvolvimento de sistemas personalizados visando à adequação da estrutura e objetivos de cada cliente. Pensando nisso, não se restringiu a uma plataforma ou ferramenta específica. Abaixo segue uma breve descrição de alguns dos softwares já desenvolvidos pela empresa: •
Patho Control: software para auxiliar a elaboração de laudos anátomo e cito patológicos; 2
•
Cyto Control: software para elaboração de laudos colposcópicos e de citologia ginecológica;
•
Politics: software para automação de campanha e gabinete político;
•
SCRE: software para automatizar empresas de recarga de extintores;
•
PHISYS: software para avaliação física em academias de ginástica;
•
Legis: software de cadastro e pesquisas legislativas;
•
IPSORI: software para automatização do trabalho em cartórios de registro de imóveis;
•
Conteven: software para controle de eventos.
1.4.
Estrutura Funcional e Local do Desenvolvimento do Estágio O quadro de funcionários da Accessus se resume a secretária
administrativa e a recepcionista. Houve sempre uma preferência por estabelecer parcerias no desenvolvimento dos projetos, evitando a contratação de funcionários. Tendo o anseio de aumentar a velocidade na implementação de mudanças em seus softwares, Zalkind, o responsável pelo setor de desenvolvimento de software da empresa, sentiu a necessidade de contratação de estagiários.
3
2. FUNDAMENTAÇÃO TEÓRICA 2.1.
Banco de Dados
2.1.1. Introdução A tecnologia aplicada aos métodos de armazenamento de informações vem crescendo e gerando um impacto cada vez maior no uso de computadores em qualquer área em que os mesmos podem ser apli cados. Um "banco de dados" pode ser definido como um conjunto de "dados" devidamente relacionados. Por "dados" podemos compreender como "fatos conhecidos" que podem ser armazenados e que possuem um significado implícito. Porém, o significado do termo "banco de dados" é mais restrito que simplesmente a definição dada acima.
2.1.2. Conceito Banco de Dados é uma coleção de dados inter-relacionados, representando informações sobre um domínio específico. Pode ser definido também como uma coleção de dados organizados de tal forma que possam ser acessados e utilizados por muitas aplicações diferentes. Como exemplo de banco de dados temos: uma lista telefônica, o controle do acervo de uma biblioteca e o sistema de controle dos recursos humanos de uma empresa.
2.1.3. Sistema de Gerenciamento de Bancos de Dados (SGBD) O SGBD é um software com recursos específicos para facilitar a manipulação das informações dos bancos de dados e o desenvolvimento de
4
programas aplicativos. Exemplos de SGBDs são o Oracle, MS SQL Server, Interbase/Firebird, Postgresql, MySQL, etc. Para manipulação de um SGBD, algumas regras básicas e claras devem ser consideradas. Se ao menos uma das características abaixo não estiver presente, o software em questão poderá ser um gerenciador de arquivo, mas não um SGBD. •
Auto-Contenção: um SGBD não contém apenas os dados em si,
mas armazena completamente toda a descrição dos dados, seus relacionamentos e formas de acesso. Normalmente esta regra é chamada de Meta-Base de Dados. •
Independência dos Dados: é a capacidade de modificar uma
definição de esquema do banco de dados em um nível de abstração sem afetar a definição de esquema em um nível mais alto. Por exemplo, um sistema que tem independência de dados física permite que se altere o esquema físico (rotinas de armazenamento e acesso aos dados) sem se ter que mexer nos programas de aplicação. Quando as aplicações estiverem realmente imunes a mudanças na estrutura de armazenamento ou na estratégia de acesso aos dados, pode-se dizer que esta regra foi atingida. Portanto, nenhuma definição dos dados deverá estar contida nos programas da aplicação. •
Abstração dos Dados: em um SGBD real é fornecida ao usuário
somente uma representação conceitual dos dados, o que não inclui maiores detalhes sobre sua forma de armazenamento real. O chamado Modelo de Dados é um tipo de abstração utilizada para fornecer esta representação conceitual. Neste modelo, um esquema das tabelas, seus relacionamentos e suas chaves de acesso são exibidos ao usuário, porém, nada é afirmado sobre a criação dos 5
índices, ou como serão mantidos, ou qual a relação existente entre as tabelas que deverá ser mantida íntegra. Os principais níveis de abstração existentes são: a) Nível físico - é o nível mais baixo de abstração. Nele é descrito o modo como os dados são realmente armazenados. Engloba complexas estruturas de armazenamento de informação de baixo nível. O nível físico depende fortemente do SGBD escolhido; b) Nível lógico - descreve quais os dados serão armazenados e os relacionamentos entre eles. Não existe a preocupação de como os dados serão armazenados (nível físico). O nível lógico não depende do SGBD a ser escolhido, mas sim da classe do SGBD; c) Nível conceitual descreve quais dados estão armazenados e seus relacionamentos. Neste nível, o banco de dados é descrito através de estruturas relativamente simples, que podem envolver estruturas complexas no nível físico. •
Visões: um SGBD deve permitir que cada usuário visualize os dados de forma diferente daquela existente previamente no Banco de Dados. Uma visão consiste de um subconjunto de dados do Banco de Dados, necessariamente derivados dos existentes no Banco de Dados, porém estes não deverão estar explicitamente armazenados.
•
Transações: um SGBD deve gerenciar completamente a integridade referencial definida em seu esquema sem precisar, em tempo algum, do auxílio do programa aplicativo. Desta forma, exige-se que o banco de dados tenha ao menos uma instrução que permita a gravação de uma série modificações simultâneas (transação) e uma instrução capaz de cancelar uma série modificações. A transação deverá ser 6
desfeita com apenas uma instrução ao Banco de Dados, sem quaisquer modificações suplementares nos dados. •
Acesso Automático: em um gerenciador de arquivo uma situação típica é o chamado dead-lock . Esta situação indesejável pode ocorrer toda vez que um usuário travou um registro em uma tabela e seu próximo passo será travar um registro em uma tabela relacionada à primeira, porém se este registro estiver previamente travado por outro usuário, o primeiro usuário ficará paralisado, pois, estará esperando o segundo usuário liberar o registro em uso, para que então possa travá-lo e prosseguir sua tarefa. Se, por hipótese, o segundo usuário necessitar travar o registro travado pelo primeiro usuário, afirmamos que ocorreu um dead-lock , pois cada usuário travou um registro e precisa travar um outro, justamente o registro anteriormente travado pelo outro. Por exemplo, se um responsável pelos pedidos acabou de travar o registro “item de pedido” e necessita travar um registro no “cadastro de produtos” para indicar uma nova reserva. Se concomitantemente estiver sendo realizada uma tarefa de atualização de pendências na tabela de itens, e para tanto, previamente este segundo usuário travou a tabela de produtos,
tem-se
a
ocorrência
do
dead-lock .
responsabilidade de evitar esta ocorrência é do SGBD.
2.1.4. Características Gerais de um SGBD 7
A
O SGBD tem sete características operacionais elementares sempre observadas, listadas abaixo. Controle de Redundâncias : a redundância consiste no
•
armazenamento de uma mesma informação em locais diferentes, provocando inconsistências. Em um Banco de Dados, as informações só se encontram armazenadas em um único local, não existindo duplicação descontrolada dos dados. Quando existem replicações dos dados, estas são decorrentes do processo de armazenagem típica do ambiente Cliente-Servidor, totalmente sob controle do SGBD. •
Compartilhamento dos Dados: o SGBD deve incluir software de controle de concorrência ao acesso dos dados, garantindo em qualquer tipo de situação a escrita/leitura de dados sem erros.
•
Controle de Acesso: o SGDB deve dispor de recursos que possibilitem selecionar a autoridade de cada usuário. Assim um usuário poderá realizar qualquer tipo de acesso, outros poderão ler alguns dados e atualizar outros e outros ainda poderão somente acessar um conjunto restrito de dados para escrita e leitura.
•
Interfaceamento: um SGBD deverá disponibilizar formas de acesso gráfico em linguagem natural, em SQL ou ainda via menus de acesso, não sendo uma "caixa-preta" somente sendo passível de ser acessada por aplicações.
8
•
Esquematização: um Banco de Dados deverá fornecer mecanismos
que
possibilitem
a
compreensão
do
relacionamento existente entre as tabelas e de sua eventual manutenção. •
Controle de Integridade: um Banco de Dados deverá impedir que aplicações ou acessos pelas interfaces possam comprometer a integridade dos dados.
•
Backup: o SGBD deverá apresentar facilidade para recuperar falhas de hardware e software, através da existência de arquivos de "pré-imagem" ou de outros recursos automáticos, exigindo minimamente a intervenção de pessoal técnico.
Existe a possibilidade de se encontrar bancos de dados que não satisfaçam completamente todas as características acima, o que não o invalida como Banco de Dados. Na prática pode-se encontrar situações onde a primeira característica (controle de redundância) não seja importante, pois pode-se ter o Banco de Dados baseado totalmente em um único servidor, e as redundâncias podem ser aceitas em algumas situações sob controle da aplicação (algo não muito recomendado, mas passível de aceitação, por exemplo, em situações onde a existência do nome do cliente em um arquivo contendo duplicatas emitidas, possibilita o acesso a apenas uma tabela sem relacionamentos, e sabe-se de antemão que uma duplicata depois de emitida, não pode ter seu cliente alterado). Deve-se ressaltar ainda o fator desempenho. Um SGBD que satisfaça todas as características acima não necessariamente é um bom banco de dados. Se o seu desempenho for muito ruim, com um tempo de resposta alto,
9
este SGBD provavelmente será trocado por outro que não tenha todas as características, mas que tenha um desempenho alto.
2.2.
Uma Introdução à SQL A abreviatura SQL significa Structured Query Language (Linguagem
Estruturada de Consulta). É uma linguagem padrão, usada para construir e acessar sistemas de bancos de dados relacionais (RDBMS) de diferentes tipos e em diferentes plataformas de hardware. Apesar de ser uma linguagem padrão, há diferenças entre os dialetos SQL implementados em bancos de dados SQL.
2.2.1. A Instrução SELECT A instrução SQL select tem como objetivo resgatar valores nas tabelas do banco dados, ela é criada em cima de três cláusulas: •
select
- indica a lista de campos que se quer ver no
resultado da consulta. Usando o símbolo de asterisco (*), em vez de uma lista de campos, pode-se selecionar todos os campos da tabela. •
From
- indica as tabelas que se quer considerar na
montagem da consulta. •
where - indica algum critério de seleção. Se não houver a
cláusula where, todos os registros são selecionados. Para selecionar somente algumas e não todas as linhas de uma tabela, deve-se incluir a cláusula where. O Exemplo 1 retorna somente os pacientes que tenham idade a partir dos 18 anos. PACIENTES select NOME from
10
where IDADE >= 18
Exemplo 1: SELECT e WHERE
Podem-se mesclar duas condições utilizando and e indicar que elas devem ser atendidas ao mesmo tempo, ou pode-se usar or para indicar que um registro deve atender a uma das condições. No Exemplo 2, serão selecionados somente os pacientes que tenham idade a partir dos 18 anos e que sejam do sexo feminino. PACIENTES select NOME from SEXO=’FEMININO’ where IDADE >= 18 and
Exemplo 2: cláusula WHERE com AND
Na Tabela 1 vemos todos os operadores que podem ser usados com a cláusula where. Operador
Descrição
= <> > < >= <= BETWEEN ... AND ... NOT BETWEEN ... AND ... IN (list) NOT IN (list) LIKE
IS NULL IS NOT NULL
Igual Diferente maior que menor que maior igual que menor igual que entre dois valores não está entre dois valores existe na lista não existe na lista utiliza caracter máscara que varia entre os SGBD. No Interbase e MS SQL Server, é usado (%) e no MS Access, (*). Colocando (‘%a%’) seria localizada a informação que contivesse a letra “a” em qualquer posição do campo. Se fosse usado (‘a%’), no resultado teríamos as informações que começassem com a letra “a”. Também pode ser utilizado o (_). Nesse caso, se tivéssemos (‘_a%’), no resultado haveria as informações que têm como segunda letra a vogal “a”. é um valor nulo não é um valor nulo
Tabela 1: operadores para a cláusula WHERE
Para evitar elementos repetidos no resultado, pode-se incluir mais uma palavra-chave SQL, distinct , que força a remoção das repetições. O Exemplo 3 retornará quais as cidades dos pacientes. 11
PACIENTES select distinct CIDADE from
Exemplo 3: DISTINCT
Outra cláusula SQL é order by , que determina a ordem dos valores no resultado. Caso não seja especificado em contrário, assumirá a ordem crescente; caso se queira o contrário, deve-se colocar a cláusula desc após do nome da coluna. A consulta contida no Exemplo 4 retorna os nomes dos pacientes ordenados pelo nome. PACIENTES select NOME from order by NOME
Exemplo 4: ORDER BY
Na maioria dos casos, as instruções SQL referem-se a duas ou mais tabelas. Para trabalhar com duas tabelas e juntá-las de maneira apropriada, usase na cláusula where os valores de campos das tabelas envolvidas que estejam relacionadas ou ainda utiliza-se a cláusula join . Temos os seguintes tipos de join : INNER (só aparecerá no resultado os elementos que possuem elementos iguais
na “amarração” entre as tabelas), LEFT (aparecerão no resultado todos os elementos à esquerda do join , a “amarração” entre as tabelas estará feita, mas quando não houver correspondente na tabela da direita e algum campo desta estiver presente no resultado será retornado o valor null – nulo), RIGHT (aparecerão no resultado todos os elementos à direita do join , a “amarração” entre as tabelas estará feita, mas quando não houver correspondente na tabela da esquerda e algum campo desta estiver presente no resultado será retornado o valor null ), FULL JOIN (aparecerão no resultado todos os elementos à direita e à esquerda do join , a “amarração” entre as tabelas estará feita, quando não houver correspondente nas tabelas o valor do campo presente no resultado estará
12
presente o valor null ). Geralmente os campos que usamos para “amarrar” as tabelas são, em uma delas, a chave primária e na outra , a chave estrangeira. Por exemplo, podemos juntar as tabelas pacientes, requisições e médicos para podermos informar qual a data da recepção de um paciente, e qual
o médico que o encaminhou, como foi feito no Exemplo 5 : select PACIENTES.NOME, REQUISICOES.DATARECEPCAO, MEDICOS.NOME PACIENTES, REQUISICOES, MEDICOS from where PACIENTES.PACI_NR_MATRICULA = REQUISICOES.PACI_NR_ MATRICULA AND REQUISICOES.MEDI_NR_CRM = MEDICOS.MEDI_NR_CRM OU
select PACIENTES.NOME, REQUISICOES.DATARECEPCAO PACIENTES INNER JOIN REQUISICOES ON from (PACIENTES.PACI_NR_MATRICULA = REQUISICOES.PACI_NR_ MATRICULA) INNER JOIN MEDICOS ON (REQUISICOES.MEDI_NR_CRM = MEDICOS.MEDI_NR_CRM)
Exemplo 5: SELECT de várias tabelas
2.2.1.1. Calculando Valores Na cláusula select, em vez de um campo de uma tabela, pode-se ter o resultado de um cálculo. Os cálculos possíveis são: COUNT, SUM, AVG, MAX e MIN , podendo incluir a cláusula distinct para calcular somente os valores não
repetidos. Para campos com números, podemos fazer operações matemáticas normalmente colocando junto ao nome do campo os operadores e valores, formando a expressão que se deseja calcular. No Exemplo 6, calcula-se a quantidade e a média de idade dos pacientes. PACIENTES select count(*),avg(idade) from
Exemplo 6: cálculo
2.2.1.2. Definindo Grupos Além de fazer cálculos com o resultado, podemos calcular um valor para cada grupo de elementos usando a cláusula having, que funciona como o 13
where, restringindo o resultado da pesquisa. O resultado da consulta abaixo é
uma lista dos convênios, cada um deles com a quantidade de r equisições . select convenio , count(*) from requisicoes group by convenio having count(*) >10 order by convenio
Exemplo 7: GROUP BY
2.2.2. A Instrução INSERT Adiciona uma ou mais linhas novas a uma tabela especificada. INSERT INTO nome_tabela (nome_coluna, nome_colun a …) (VALORES DO TIPO STRING DEVEM VALUES (valor1, valor2 …) ESTAR ENTRE ASPAS)
Ou INSERT INTO nome_tabela (nome_coluna, nome_colun a …) (TEM QUE TER A MESMA SELECT nome_coluna, nome_coluna … FROM nome_tabela QUANTIDADE DE CAMPOS E OS TIPOS DOS CAMPOS DEVEM SER OS MESMOS)
Exemplo 8: INSERT
2.2.3. A Instrução DELETE Remove linhas de uma tabela. nome_tabela DELETE FROM WHERE condição_de_procura
(SE APLICA O MESMO DO SELECT)
Exemplo 9: DELETE
2.2.4. A Instrução UPDATE Altera informações de um registro já existente de uma tabela. UPDATE nome_tabela SET nome_coluna=valor1, nome_coluna=valor2 … (QU ANDO STRING DEVEM ESTAR ENTRE ‘ ’) (SE APLICA O MESMO DO SELECT) WHERE condição_de_procura
Exemplo 10: UPDATE
2.3. Banco de Dados Firebird 14
2.3.1. Histórico O banco de dados Interbase foi originalmente concebido e criado por um grupo de engenheiros de sistemas, funcionários da DEC (Digital Equipment Corporation), que desejavam produzir um SGBDR - sistema gerenciador de banco de dados relacional, inovador e que substancialmente oferecesse maiores benefícios que os outros sistemas até então existentes. Na época de sua concepção, muita tecnologia já existia como proposta de inovação, mas nenhum produto a oferecia como recurso ou característica disponível. Tendo iniciado em 1985 como Groton Database System, logo mudou de nome para Interbase. Foi inicialmente comercializado pela Ashton Tate (Dbase) e em 1992 foi entregue à Borland como parte de uma negociação de produtos. Ao longo de seu desenvolvimento, foram consistentemente introduzidas um número de tecnologias de primeira mão. Muitas dessas são: arquitetura multi-geradora, commit automático em duas fases, sombreamento do banco de dados (replicação), admissão e tratamento de campos blobs, índices em mapa de bits disperso, colunas vetoriais multidimensionais e subsistema de eventos de alertas. Além de ter sido o primeiro a disponibilizar acesso nativo a driver de JDBC. Em julho de 2000, a então chamada Inprise, antes conhecida como Borland, decidiu liberar o código-fonte do banco de dados Interbase. Mais conhecido por ser fornecido junto às edições Enterprise do Delphi. A concorrência gerada pela entrada dos pesos-pesados como Oracle, DB2, Sybase e MS SQL Server estava tornando cada vez mais difícil vender licenças do Interbase. A Inprise como um todo estava passando por
15
problemas financeiros, o resultado foi a demissão da maior parte dos funcionários responsáveis por desenvolvimento, suporte e vendas do Interbase. Por outro lado, a Inprise precisava fornecer um servidor de bancos de dados relacional, pois suas principais concorrentes no mercado de BDs também forneciam ferramentas de desenvolvimento e as vendas casadas de bancos e IDEs estavam minando as vendas do carro-chefe da empresa, o Delphi, além do C++ Builder e do JBuilder. Portanto, descontinuar o Interbase não era uma opção desejável. A Inprise optou por uma solução inovadora para a época, que manteria o produto vivo a um custo mínimo: abrir o código da versão 6.0, ainda em beta. Foi uma decisão desesperada, tomada sob grande oposição dos setores da empresa que acreditavam ser melhor encerrar a divisão Interbase. O sucesso foi imediato: milhares de downloads e uma comunidade de usuários crescente. O produto passou a ser suportado ativamente por ferramentas de terceiros e ganhou componentes importantes, porém ausentes na versão proprietária, como o driver ODBC, e a versão do Linux atendendo o mercado de servidores. Em pouco tempo, a "nova" Borland decidiu mudar a estratégia para o Interbase (a Inprise alterou seu nome para Borland) e o produto foi novamente transformado em software proprietário. Foi liberada, em 2001, uma versão 6.0 "certificada", que continha código ausente da versão aberta e, em 2002, foi liberada a versão 6.5 exclusivamente sob licença proprietária. Foi então que a versão aberta do Interbase criou vida independente da Borland, sendo chamada de "Firebird" (ave de fogo), em alusão à Fênix, ave mitológica que renasce das próprias cinzas. 16
No dia 16 de dezembro de 2003, a Borland liberou a versão 7.1 do Interbase, mas perdeu grande parte da sua comunidade de usuários e do suporte de terceiros. Já o Firebird liberou a versão 1.5, em 16 de julho de 2004, com recursos exclusivos e suportando ainda mais plataformas.
2.3.2. Edições do Firebird Na maioria das plataformas, o Firebird é fornecido em duas edições, chamadas de Classic Server ou CS e "Super Server" ou SS. O Classic Server é a versão original do Interbase, onde cada cliente possui um processo “gds_inet_server” dedicado a ele, de forma semelhante a servidores como o Apache 1.x ou PostgreSQL. Quando o segundo cliente se conecta ao banco, inicia-se um processo “gds_lock_mgr”, que gerencia o acesso concorrente aos mesmos arquivos de banco de dados. As instâncias do Interbase/Firebird CS são iniciadas pelo “inetd”, e há também suporte a um modo de conexão local onde o próprio cliente realiza o acesso aos arquivos de banco de dados, de modo que não há um processo separado para este cliente. Esta última opção é bastante interessante para o uso embutido, onde o banco de dados é de uso exclusivo de uma aplicação. O Super Server surgiu na versão 5.0 do Interbase. O Firebird SS é formado por um único processo “ibserver”, executando autonomamente (em vez de iniciado pelo “inetd”), que mantém uma fila de solicitações para atender os pedidos dos clientes remotos. Estas solicitações compartilham um único cache de páginas do banco de dados e uma solicitação especializada gerencia o acesso concorrente aos arquivos. Não existe no SS o modo de conexão local suportado pelo CS. Esta é uma arquitetura bastante semelhante ao MySQL. 17
O SS é capaz de atender a uma carga de trabalho bem maior do que o CS, consumindo menos recursos do servidor, além de apresentar melhor tempo de resposta e segurança. Mas o CS continua sendo suportado por ser mais leve com poucos clientes e pelas vantagens do modo local para algumas aplicações. Em algumas plataformas há ainda o processo “ibguardian”, que atua como um watchdog (cão de guarda): ele monitora o processo “ibserver” e, caso seja terminado por algum motivo (por exemplo, um bug do código do servidor), um novo “ibserver” é iniciado. A versão 1.5 do Firebird muda os nomes dos executáveis e arquivos, basicamente trocando os prefixos "gds" e "ib" por "fbs" e "fb" respectivamente. Junto com esta mudança de nomes, cujo objetivo é permitir a instalação de versões do Firebird e do Interbase na mesma máquina, há mudanças no formato dos arquivos de banco de dados, que deixaram de ser intercambiáveis entre o banco livre e o seu irmão proprietário. Mas será a mantida a compatibilidade retroativa com aplicações compiladas para versões anteriores do Firebird (ou do Interbase) pelo fornecimento de uma biblioteca de cliente "pass-through" com o nome original.
2.3.3. Administrando o Firebird O Firebird não inclui o aplicativo gráfico de administração do Interbase, o IBConsole, pois ele não fazia parte da versão aberta. A versão aberta incluía o IBClient, cliente escrito em Java (mas não "100% pure" Java) ao qual o Projeto Firebird decidiu não dar continuidade devido aos problemas de compatibilidade com versões do Java e à necessidade de configuração extra de 18
processos no servidor apenas para atender ao IBClient. Assim sendo, a instalação padrão do Firebird inclui apenas utilitários de linha de comando, tal qual o MySQL e o PostgreSQL, mas existem várias ferramentas de terceiros que fornecem ferramentas gráficas ou web para administração do Firebird, tanto livres quanto proprietárias, entre elas temos: IBConsole(Interbase), IBAcces, Quick Desk e IBExpert. O IBExpert possui uma versão Personal que é distribuída gratuitamente e entre essas opções é a mais utilizada por ser fácil de usar e oferecer a maioria das funcionalidades necessárias. O conjunto de utilitários padrão do Firebird inclui, entre outros: •
isql: ferramenta para execução interativa de comandos e scripts SQL
•
gsec: ferramenta para configuração de usuários e senhas no banco de sistema
•
gbak: ferramenta para backup e restore de um banco de dados ativo
2.3.4. Características O Firebird foi desenvolvido de acordo com o conceito de "Atomicidade, Consistência, Isolamento e Durabilidade". Outras características: •
MGA - Multi-Generational Architecture: uma característica especial do Firebird é a "Arquitetura de Múltiplas Gerações", que permite ao banco manipular várias versões do mesmo registro físico em qualquer momento, assim qualquer transação pode ter sua própria versão sem se importar com outras transações concorrentes ("leitura não bloqueia escrita 19
e escrita não bloqueia leitura"). Isto assegura OLTP tão bem quanto operações OLAP. •
Procedimentos Armazenados (Stored Procedures): usando a linguagem SQL de procedimentos do Firebird, pode-se facilmente criar poderosos procedimentos armazenados para processar dados internamente no lado do Servidor. Um detalhe especial são os selectable stored procedures (procedimentos selecionáveis) que podem calcular dados linha por linha no servidor e podem ser usados como uma (tabela virtual) do lado cliente, a qual é especialmente view útil para criação de relatórios.
Eventos: Stored Procedures (procedimentos armazenados) e
•
triggers (gatilhos) podem disparar eventos que podem ser
monitorados de um cliente numa porta TCP/IP para bases de dados ativas. •
Geradores (Generators): O conceito de Generators permite a fácil implementação de colunas do tipo auto-incrementos, mas vai além disso. Generators são contadores não voláteis do tipo Int64 que são independentes de transações e podem ser usados de muitas maneiras.
•
Bases de dados "somente leitura": para distribuição de bases de dados em CD-ROM, por exemplo. Especialmente quando usado em conjunto com a versão embutida (embedded), isto dá uma facilidade imbatível de distribuição.
20
•
Controle total de transações: uma simples aplicação cliente pode ter multiplas transações concorrentes. Os diversos níveis de isolamento podem ser completamente controlados pelo cliente. O protocolo de commit em duas fases permite consistência garantida entre as bases de dados. Travamento otimista é também suportado, bem como múltiplos Savepoints em Transações.
•
Backups Onli ne: não há necessidade de parar a base de dados para efetuar o backup. Um processo de backup captura a imagem da base de dados no momento em que ele inicia, assim os usuários podem continuar trabalhando enquanto um backup roda, permitindo operação 24x7.
•
Gatilhos (Triggers): cada tabela pode ter múltiplos gatilhos que são disparados para cada linha da tabela antes ou depois de Inserts, Updates ou Deletes. Dentro de um gatilho, a riqueza da linguagem SQL de procedimentos pode ser usada para aplicar valores padrões, assegurar a integridade dos dados, gerar exceções, etc. A novidade no Firebird 1.5 são os "gatilhos universais”. Com ele pode haver um único gatilho para manipular Inserts, Updates e/ou Deletes na tabela de uma só vez.
•
Funções Externas (External Functions): bibliotecas com funções definidas pelo usuário (User Defined Functions ou UDFs) podem ser escritas em linguagens como C, C++ ou Delphi e podem ser facilmente ligadas ao núcleo do Firebird 21
via DLLs/SOs, estendendo a funcionalidade dentro do Servidor. •
Integridade Referencial em Cascata (Declarative Cascading Referential Integrity): assegura consistência e validade de um relacionamento 1-N (Pai e Filho) entre tabelas.
•
Configurações de Caracteres (Character Sets): o Firebird implementa
muitas
configurações
de
caracteres
internacionais, incluindo Unicode com uma variedade de collates.
O Firebird tem suporte completo ao SQL 92 Entry Level 1 e implementa a maioria do padrão SQL-99, além de alguns adicionais úteis. Isto inclui declarações dml/ddl, sintaxes full/left/right [outer] join, cláusulas union e distinct , subconsultas (in, exists), funções internas (avg, sum, min, max, coalesce, case, ..), constraints (primary key, unique, foreign key ), assim como todos os tipos
de dados da SQL. O Firebird também implementa Domínios (Domains) e campos com Check Constraints, Views, Exceptions, Roles e uma refinada gerência de
permissões (Grant). O Firebird roda em quase todo hardware. Mesmo hardwares "fracos" podem servir de servidor, especialmente quando usados com Linux. Como qualquer SGBDR, há os aspectos comuns que influenciam a performance: a quantidade física de RAM (16MB já irá rodar); a velocidade do subsistema de armazenamento (como sistemas RAID), etc. É claro, o hardware recomendado depende do que se quer fazer com uma base de dados, qual o tamanho que ela atingirá, quantos usuários concorrentes se espera e assim por di ante. 22
As plataformas mais usadas com o Firebird são Linux e Windows (incluindo MS Terminal Servers e Citrix MainFrames). Outras plataformas são Mac OS X, Solaris e HP-UX. Migrar de uma plataforma para outra é possível a qualquer momento simplesmente fazendo um backup da base de dados de um SO usando o formato transportável (transportable) e então restaurar em outro SO qualquer. O Firebird suporta um grande número de métodos de conectividade, incluindo: pacotes de componentes nativos para C/C++ e Delphi, ODBC, JDBC (JayBird), Driver PHP, driver OLEDB, dbExpress, .Net data provider e finalmente através de chamadas diretas à API usando a bibli oteca fbclient.dll/.so. As bases de dados podem se estender a múltiplos arquivos, o tamanho de cada arquivo depende do SO. O limite teórico é atualmente 64TB para um único arquivo da base de dados, então o limite prático é normalmente definido pelo sistema operacional ou o espaço disponível no HD. O Firebird é licenciado sob a IPL (InterBase Public License), a qual tem os mesmo termos da Mozilla Public License 1.1. O Firebird é completamente gratuito para usar e distribuir. Não é preciso entregar o código fonte do seu sistema, independente do seu modelo de licenciamento. Se o núcleo do Firebird, entretanto, for modificado, deve-se liberar o acesso público ao código fonte das modificações. Uma gama enorme de ferramentas está disponível para o Firebird, algumas gratuitas, outras comerciais. Há ferramentas para administradores, ferramentas
para
desenvolvedores,
Bibliotecas
conectividade, etc.
23
UDF,
ferramentas
de
Em www.firebirdsql.org , o lar do Firebird, há muitos links úteis sobre o projeto. A empresa IBPhoenix oferece vários contratos para suporte profissional por pessoas com um longo período de experiência. Em seu website, há também uma variedade de informações técnicas, tutoriais e documentações bem detalhadas disponíveis. Há uma comunidade sempre crescente de usuários do Firebird e vários newsgroups (grupos de discussão) para fornecer suporte on-line instantâneo. Na homepage do projeto há uma lista de todos os newsgroups sobre Firebird.
2.3.5. Comparação Como o Firebird, também temos o MySQL e PostGreSQL como banco de dados gratuitos. A Tabela 1 sumariza algumas diferenças entre os três principais bancos livres. Recurso
Firebird Sim
MySQL 3.x opcional
PostgreSQL sim
Transações Procedimentos armazenados (incompatíveis com ODBC) Triggers Integridade referencial Consultas aninhadas (subselects) Outer Joins Funções agregadas (count, sum, avg, ...) Recursos para OLAP / DatawareHouse Extensões Orientadas a Objetos Servidor baseado em múltiplos processos Servidor baseado em múltiplas threads Acesso direto, sem servidor Um arquivo por tabela
sim
não
sim
sim sim sim sim algumas não não sim (CS) sim (SS) sim (CS) não
sim sim sim sim muitas não sim sim não não sim
BD ocupando vários discos
não
Liberação automática de registros deletados Servidor estável em Windows Servidor em Netware
sim sim não
não não não não poucas não não não sim não sim sim (via links, apenas Linux/Unix) sim sim sim
Tabela 2: comparação entre bancos de dados gratuitos.
24
sim (via SQL) não não sim
É interessante ter uma noção dos preços dos banco de dados comerciais, na Tabela 2 são mostrados estes valores, não esquecendo que o Firebird é gratuito.
Tabela 3: preços de alguns SGBDs
2.4.
Modelos de Dados Os modelos de dados são formas de definir um banco de dados
através de ferramentas conceituais, relacionamentos entre dados, semântica e restrições. Existem vários modelos de dados a serem utilizados em diferentes SGBD e níveis de abstração.
2.4.1. O Modelo Entidade-Relacionamento O Modelo Entidade-Relacionamento (MER) é o modelo mais usado para representação de bancos de dados em nível conceitual. Tem como 25
característica principal a facilidade de projetar esquemas de bancos de dados. Este modelo baseia-se na representação do sistema por um conjunto de objetos do mundo real (entidades) e por relacionamentos entre estes objetos – o diagrama de entidade-relacionamento (DER). A maioria das ferramentas CASE adotam este diagrama, mas existem variações de simbologia, como a sugerida por CHEN. O modelo entidade-relacionamento, apresenta algumas definições que serão mostradas a seguir: •
Entidade: uma entidade representa uma coleção ou um conjunto de objetos do mundo real cujos membros desempenham um papel no sistema. Por exemplo, disciplina e aluno são entidades.
•
Atributos: são qualificadores das entidades. Por exemplo, nome e matrícula são atributos da entidade aluno.
•
Atributos multivalorados: são aqueles que podem ocorrer mais de uma vez para uma mesma entidade. Se definirmos que telefone é um atributo multivalorado da entidade aluno, será possível indicar um ou vários telefones para os alunos.
•
Chave ou atributos-chave: é o conjunto de atributos que identifica unicamente uma entidade no conjunto de entidades. Por exemplo, o atributo matrícula identifica unicamente um aluno.
Entidade forte ou dominante: entidade cuja existência
•
independe de outras entidades, podendo determinar a existência de entidades que são subordinadas a ela. 26
Entidade
•
fraca
ou
subordinada:
é
existencialmente
dependente de outra entidade, ou seja, se a entidade da qual depende deixa de existir, esta também deixará de existir. Um exemplo claro é a relação entre as entidades sócio (dominante) e dependente (subordinada) num sistema que modele o funcionamento de um plano de saúde, mostrado na Figura 1.
Figura 1: entidades dominante e subordinada
Uma entidade fraca está sempre associada a uma entidade forte através de um relacionamento chamado de Relacionamento de Dependência. Relacionamento : um relacionamento é uma associação entre
•
entidades. Por exemplo, as entidades aluno e curso têm uma relação, num sistema de controle acadêmico (veja a Figura 2).
Figura 2: relacionamento •
Cardinalidade: expressa o número máximo de entidades de um dado conjunto de entidades que pode se relacionar, através de um relacionamento, com uma ocorrência das outras entidades participantes. Por exemplo, um aluno só 27
pode estar matriculado em um único curso. Por sua vez, um curso pode ter vários alunos matriculados. Logo o relacionamento entre aluno e curso é 1:N (leia-se um para muitos). A cardinalidade de um relacionamento binário, por exemplo, pode ser 1:1, 1:N, N:1 ou N:N. No DER, a cardinalidade é representada por setas simples ou duplas. Setas simples indicam cardinalidade 1 enquanto setas duplas indicam cardinalidade N. A figura abaixo mostra um relacionamento com cardinalidade N:1.
Figura 3: cardinalidade •
Totalidade: é uma restrição de obrigatoriedade, de uma entidade, na participação de um relacionamento. Por exemplo, se um aluno deve, obrigatoriamente, estar matriculado em algum curso, então se diz que a entidade aluno é total em relação ao relacionamento matricula-se em .
No DER, a totalidade é representada pelo símbolo l . Auto-relacionamento: é um relacionamento onde só existe
•
uma entidade participante. No DER, é representado conforme mostra a figura a seguir.
28
Figura 4: a uto-relacionamento
Agregação:
•
é
uma
abstração
através
da
qual
os
relacionamentos são tratados como entidades de um nível mais alto, podendo assim se relacionar entre si ou, mesmo, com outras entidades. No DER, uma agregação é representada por um losango dentro de um retângulo. Um exemplo da necessidade de se tratar um relacionamento como uma entidade é mostrado no na Figura 5 que se segue.
Figura 5: agregação •
Generalização: é um tipo de relacionamento que expressa a união de subconjuntos de entidades de um nível mais baixo formando um conjunto de entidades em nível mais alto. Ou seja, é um relacionamento que cria, a partir de entidades mais específicas, entidades mais genéricas que contêm informações comuns a todas as outras e cuja classificação 29
interessa ao sistema. Um exemplo disso é termos a entidade cliente como sendo generalização de pessoa física e pessoa jurídica, como mostra a Figura 6.
Figura 6: generalização
Especialização: é um tipo de relacionamento que expressa a classificação de um subconjunto de entidades de um nível mais alto formando um conjunto de entidades em nível mais baixo. Ou seja, é um relacionamento que cria, a partir de entidades mais genéricas, novas entidades sobre as quais se têm informações mais específicas e cuja classificação interessa ao sistema. Um exemplo é termos cantor e ator como especializações de artista (Figura 7).
Figura 7: especialização
2.4.2. O Modelo Relacional O modelo relacional é utilizado pela grande maioria dos SGBD’s atualmente, como por exemplo: Interbase, Oracle, SQL Server, Postgresql, etc. A 30
razão para esse grande uso é que o modelo relacional permite acessos aos dados de forma eficiente, sendo baseado em noções simples e intuitivas. Neste modelo, um banco de dados é representado por uma coleção de tabelas. Alguns conceitos importantes são: •
Tabela: é conjunto de campos que contém informações sobre algum objeto concreto, abstrato ou mesmo interno ao sistema ao qual pertence. O conceito de tabela corresponde essencialmente ao conceito matemático de relação. Um exemplo de tabela no modelo relacional é mostrado na Tabela 4 que se segue.
CLIENTE Nome Endereço Telefone CPF Tabela 4: tabela no modelo relacional •
Campo ou coluna: o campo (ou coluna) de uma tabela é um dado que se deseja armazenar sobre o objeto que ela referencia ou um dado necessário ao acesso dos seus registros pelos programas de aplicação e rotinas de manutenção. No exemplo de Tabela 4, nome e endereço são duas de suas colunas.
•
Chave primária: é um conjunto de um ou mais campos que identificam unicamente um registro em um conjunto de registros e que tenha sido escolhido pelo projetista do banco de dados como forma de acesso principal a cada um destes 31
registros. Por exemplo, podemos definir o atributo CPF como sendo a chave primária da tabela cliente. •
Chave estrangeira: é conjunto de um ou mais campos de uma tabela que fazem referência à chave primária de outra tabela para fins de manutenção de integridade e consistência de dados do sistema.
2.5.
Algoritmo
2.5.1. Conceito de Algoritmo A automação é o processo em que uma tarefa deixa de ser desempenhada pelo homem e passa a ser realizada por máquinas, sejam estas dispositivos mecânicos (como as máquinas industriais), eletrônicos (como os computadores), ou de natureza mista (como os robôs). Para que a automação de uma tarefa seja bem-sucedida é necessário que a máquina que passará a realizá-la seja capaz de desempenhar cada uma das etapas constituintes do processo a ser automatizado com eficiência, de modo a garantir a repetição do mesmo. Assim, é necessário que seja especificado com clareza e exatidão o que deve ser realizado em cada uma das fases do processo a ser automatizado, bem como a seqüência em que estas fases devem ser realizadas. À especificação da seqüência ordenada de passos que deve ser seguida para a realização de um tarefa, garantindo a sua repetição, dá-se o nome de algoritmo. Embora esta definição de algoritmo seja correta, podemos definir algoritmo, de maneira informal e completa como sendo um conjunto finito de 32
regras, bem definidas, para a solução de um problema em um tempo finito e com um número finito de passos. Um algoritmo é, portanto, qualquer procedimento computacional bem definido que toma algum valor ou conjunto de valores como entrada e produz algum valor ou conjunto de valores como saída. Um algoritmo deve sempre possuir pelo menos um resultado, normalmente chamado de saída, e satisfazer a propriedade da efetividade, isto é, todas as operações especificadas no algoritmo devem ser suficientemente básicas para que possam ser executadas de maneira exata e em tempo finito. Na prática, não é importante ter-se apenas um algoritmo, mas sim, um bom algoritmo. O mais importante de um algoritmo é a sua correção, isto é, se ele resolve realmente o problema proposto e o faz exatamente. Para se ter um algoritmo, é necessário: que se tenha um número finito de passos; que cada passo esteja precisamente definido, sem possíveis ambigüidades; que existam zero ou mais entradas tomadas de conjuntos bem definidos; que existam uma ou mais saídas; e que exista uma condição de fim sempre atingida para quaisquer entradas e num tempo finito. Para que um computador possa desempenhar uma tarefa é necessário que esta seja detalhada passo a passo, numa forma compreensível pela máquina, utilizando aquilo que se chama de programa. Neste sentido, um programa de computador nada mais é que um algoritmo escrito em uma forma compreensível pelo computador.
2.5.2. Formas de Representação de Algoritmos Existem diversas formas de representação de algoritmos. Algumas formas de representação de algoritmos tratam dos problemas apenas em nível 33
lógico, abstraindo-se de detalhes de implementação muitas vezes relacionados com alguma linguagem de programação específica. Por outro lado, existem formas de representação de algoritmos que possuem uma maior riqueza de detalhes e muitas vezes acabam por obscurecer a idéia principal, o algoritmo, dificultando seu entendimento. Dentre as formas de representação de algoritmos mais conhecidas, sobressaltam: Descrição Narrativa, Fluxograma Convencional, Diagrama de Chapin e Pseudocódigo (Linguagem Estruturada ou Portugol).
2.5.3. Descrição Narrativa Nesta forma de representação os algoritmos são expressos diretamente em linguagem natural. Como no Exemplo 11, têm-se os algoritmos seguintes: – Troca de um pneu furado: – Afrouxar ligeiramente as porcas – Suspender o carro – Retirar as porcas e o pneu – Colocar o pneu reserva – Apertar as porcas – Abaixar o carro – Dar o aperto final nas porcas – Cálculo da média de um aluno: – Obter as notas da primeira e da segunda prova – Calcular a média aritmética entre as duas – Se a média for maior ou igual a 7, o aluno foi aprovado, senão ele foi reprovado Exemplo 11: algoritmo usando descrição narrativa
Esta representação é pouco usada na prática porque o uso de linguagem natural muitas vezes dá oportunidade a más interpretações, ambigüidades e imprecisões. 34
Por exemplo, a instrução “afrouxar ligeiramente as porcas” no algoritmo da troca de pneus está sujeita a interpretações diferentes por pessoas distintas. Uma instrução mais precisa seria: “afrouxar a porca, girando-a de 30º no sentido anti-horário”.
2.5.4. Fluxograma Convencional É uma representação gráfica de algoritmos onde formas geométricas diferentes implicam ações (instruções, comandos) distintas. Tal propriedade facilita o entendimento das idéias contidas nos algoritmos. Nota-se que os fluxogramas convencionais preocupam-se com detalhes de nível físico da implementação do algoritmo. Por exemplo, figuras geométricas diferentes são adotadas para representar operações de saída de dados realizadas em dispositivos distintos, como uma unidade de armazenamento de dados ou um monitor de vídeo. A Figura 8, vista a seguir mostra as principais formas geométricas usadas em fluxogramas.
Figura 8: principais formas geométricas usadas em fluxogramas
35
De modo geral, o fluxograma se resume a um único símbolo inicial, por onde a execução do algoritmo começa, e um ou mais símbolos finais, que são pontos onde a execução do algoritmo se encerra. Partindo do símbolo inicial, há sempre um único caminho orientado a ser seguido, representando a existência de uma única seqüência de execução das instruções. Isto pode ser melhor visualizado pelo fato de que, apesar de vários caminhos poderem convergir para uma mesma figura do diagrama, há sempre um único caminho saindo desta. A Figura 9 contém um exemplo de um diagrama. Exceções a esta regra são os símbolos finais, dos quais não há nenhum fluxo saindo, e os símbolos de decisão, de onde podem haver mais de um caminho de saída (normalmente dois caminhos), representando uma bifurcação no fl uxo.
Figura 9: algoritmo escrito em fluxograma
2.5.5. Diagrama de Chapin 36
Esse diagrama foi criado por Ned Chapin a partir de trabalhos de Nassi-Shneiderman, os quais resolveram substituir o fluxograma tradicional por um diagrama que apresenta uma visão hierárquica e estruturada da lógica do programa. A grande vantagem de usar este tipo de diagrama é a representação das estruturas que têm um ponto de entrada e um ponto de saída e são compostas pelas estruturas básicas de controle de seqüência, seleção e repartição. Enquanto é difícil mostrar o embutimento e a recursividade com o fluxograma tradicional, torna-se mais simples mostrá-lo com o diagrama de Chapin, bem como codificá-lo futuramente na conversão para pseudocódigos. A Figura 10 apresenta um exemplo de diagrama de Chapin para o algoritmo de cálculo da média de um aluno, indicando se ele foi “aprovado” ou “reprovado”. Início Leia N1, N2 Média ← (N1+N2)/2 Média >= 7 Sim
Não
Escreva “Aprovado”
Escreva “Reprovado” Fim
Figura 10: diagrama de Chapin
2.5.6. Pseudocódigo Esta forma de representação de algoritmos, também conhecida como português estruturado ou portugol, é bastante rica em detalhes e, por assemelhar-se bastante à forma em que os programas são escritos, encontra muita aceitação.
37
Na verdade, esta representação é suficientemente geral para permitir que a tradução de um algoritmo nela representado para uma linguagem de programação específica seja praticamente direta. A representação de um algoritmo na forma de pseudocódigo pode ser vista no Exemplo 12: Algoritmo
Início
Fim.
Exemplo 12: elementos do pseudocódigo
Onde: •
Algoritmo é uma palavra que indica o início da definição de um algoritmo em forma de pseudocódigo.
é um nome simbólico dado ao
•
algoritmo com a finalidade de distingui-lo dos demais. •
consiste em uma porção opcional onde são declaradas as variáveis globais usadas no algoritmo principal e, eventualmente, nos subalgoritmos.
consiste de uma porção opcional do
•
pseudocódigo onde são definidos os subalgoritmos. •
Início e Fim são respectivamente as palavras que delimitam o início e o término do conjunto de instruções do corpo do algoritmo.
O Exemplo 12 mostra a representação do algoritmo de cálculo da média de um aluno na forma de um pseudocódigo. Algoritmo Média Var N1, N2, Média
38
Início Leia N1, N2 Média := (N1+N2)/2 Se Média >= 7 Então Escreva “Aprovado”
Senão Escreva “Reprovado” Fim.
Exemplo 13: pseudocódigo
2.5.7. Fases de um Algoritmo Quando temos um problema e vamos utilizar um computador para resolvê-lo, inevitavelmente temos que passar pelas seguintes etapas: a) Definir o problema; b) Realizar um estudo da situação atual e verificar qual(is) a(s) forma(s) de resolver o problema; c) Terminada a fase de estudo, utilizar uma linguagem de programação para escrever o programa que deverá, a princípio, resolver o problema; d) Analisar junto aos usuários se o problema foi resolvido. Se a solução não for encontrada, deverá ser retornado para a fase de estudo para descobrir onde está a falha. Estas são, de forma bem geral, as etapas que um analista passa, desde a apresentação do problema até a sua efetiva solução. Iremos nos ater as etapas de estudo, também chamada de análise, e a etapa de programação. Mas antes vamos definir o seguinte conceito: programar um computador consiste em elaborar um conjunto finito de instruções, reconhecidas pela máquina, de forma que o computador execute estas instruções. Estas instruções possuem regras e uma sintaxe própria, como uma linguagem tipo português ou inglês, sendo isto chamadas de linguagem de computador. 39
No mundo computacional existe uma grande variedade de linguagens, como: Pascal, Java, C, C++, Cobol, Fortran. Iremos utilizar o Pascal, que é a linguagem de programação utilizada pelo Delphi, para introduzir os primeiros conceitos de programação.
2.5.8. Variáveis O computador possui uma área de armazenamento conhecida como memória. Todas as informações existentes no computador estão ou na memória primária (memória RAM), ou na memória secundária (discos, fitas, CD-ROM etc). Aqui iremos tratar, somente com a memória primária, especificamente com as informações armazenadas na RAM (memória de acesso aleatório). Podemos dizer que uma variável é uma posição de memória, representada por um nome simbólico que é atribuído pelo usuário, a qual contém, num dado instante, uma informação.
2.5.8.1. Formação de Variáveis Uma variável é formada por uma letra ou então por uma letra seguida de letras ou dígitos, em qualquer quantidade. Não é permitido o uso de espaços em branco ou de qualquer outro caractere, que não seja letra, sublinhado e dígito, na formação de um identificador. Na formação do nome da variável deve-se dar um nome, preferencialmente, significativo.
2.5.8.2. Tipos de Dados 40
O Pascal exige que no momento que formos trabalhar com variáveis, indiquemos o tipo de informação que uma variável pode conter, isto é, se uma dada posição de memória armazenará, por exemplo um número ou uma letra. Para isto, a linguagem Pascal possui definidos alguns tipos que deverão ser usados quando formos trabalhar com variáveis. Alguns tipos encontram-se na Tabela 5: Algoritmo a) Inteiro
Pascal INTEGER:
b) Real
REAL:
e) Caracter
CHAR:
d) Cadeia
STRING:
g) Lógica
BOOLEAN: WORD: BYTE: Shor Int LongInt Single Double
Descrição Representa os números entre -32768 até +32767. Ocupa 2 bytes na memória. Representa os números entre 2.9 x 10 -39 até 1.7 x 10 38 . Ocupa 6 bytes na memória. Representa um dos caracteres, da tabela ASCII. Ocupa 1 byte na memória. Conjunto de caracteres (CHAR). Ocupa de 1 a 255 bytes na memória. Valor lógico. Assuma somente dois valores: TRUE(Verdade) ou FALSE(Falso). Ocupa 1 byte na memória. Números de 0 até 65535. Ocupa 2 bytes na memória. Números de 0 até 255. Ocupa 1 byte na memória. Representa os números entre -128 até 128 . Ocupa 1 bytes na memória. Representa os números entre - 2.147.483.648 até 2.147.483.648 . Ocupa 4 bytes na memória. Representa os números entre 1.5 x 10 -45 até 3.4 x 10 38 . Ocupa 4 bytes na memória. Representa os números entre 5 x 10 -324 até 1.7 x 10308 . Ocupa 8 bytes na memória. Tabela 5: tipos de dados
2.5.8.3. Definição de Variáveis Para definir uma ou mais variáveis, devemos utilizar, em Pascal, a palavra VAR. O Exemplo 14 mostra algumas definições de variáveis: ALGORITMO Teste VARIÁVEIS
Teste; PROGRAM VAR
Palavra: CADEIA Letra: CARACTER Número: INTEIRO
INICIO
Palavra: String; Letra: CHAR; Número: INTEGER;
BEGIN
FIM
;
END.
Exemplo 14: definições de variáveis
41
Obs.: Os nomes dados as variáveis não podem ser os mesmos nomes de palavras reservadas do Pascal, tais como PROGRAM, BEGIN, END, VAR, etc.
2.5.9. Comando de Atribuição Quando definimos uma variável é natural atribuirmos a ela uma informação. Uma das formas de colocar um valor dentro de uma variável, consequentemente colocando este dado na memória do computador, é através da atribuição direta do valor desejado que a variável armazena. Para isto utilizaremos o símbolo := em Pascal, e
←
nos algoritmos, que significa: recebe,
ou seja, a posição de memória que uma variável representa, receberá uma informação, a qual será armazenada no interior desta variável. ALGORITMO Teste VARIÁVEIS
Teste; PROGRAM VAR
Número: INTEIRO
INICIO Número
FIM
Numero: INTEGER;
BEGIN 10
Numero := 10;
←
END.
Exemplo 15: atribuição
O Exemplo 15 nos informa que: a) Foi definida uma variável, a qual demos o nome de “Numero”, e informamos que esta variável, ou posição de memória, só poderá aceitar dados que sejam numéricos e que estejam entre -32768 e +32767 ( tipo INTEGER ). b) Atribuímos à variável “Numero” o valor 10. Quando estivermos fazendo a atribuição de um valor para uma variável do tipo CHAR (Caracter) ou STRING (Cadeia), temos que ter o cuidado
42
de colocar o valor (dado) entre aspas ( ‘ ), pois esta é a forma de informar que a informação é caracter. caracter.
2.5.10. Operadores Matemáticos Os operadores operadores matemáticos, usados no Pascal, são os seguintes: Operação
Operador
Adição Subtração Multiplicação Divisão Divisão Divis ão inteira intei ra (QUOCIENTE) (QUOCIE NTE) Resto da divisão (RESTO) Diferença Menor Igual Maior Igual
+ * / DIV MOD <> <= >=
Tabela 6: operadores matemáticos
2.5.11. Operadores Lógicos Os operadores lógicos, que realizam as operações da álgebra boolean booleana, a, encontram-se encontram -se na Tabela 7. Operação E OU NÃO NÃO OU
Operador AND OR NOT XOR
Tabela 7: operadores lógicos
A seguir, são mostradas as “tabelas verdade” de cada um dos operadores, indicando seis resultados para as possíveis util izações. a) Tabela verdade para o operador AND AND (Tabela 8): Operação TRUE AND TRUE TRUE AND FALSE FALSE AND TRUE FALSE AND FALSE
Resultado TRUE FALSE FALSE FALSE
Tabela 8: resultados usando AND
b) Tabela verdade verdade para o operador OR (Tabela 9): 43
Operação TRUE OR TRUE TRUE OR FALSE FALSE OR TRUE FALSE OR FALSE
Resultado TRUE TRUE TRUE FALSE
Tabela 9: resultados usando OR
c) Tabela verdade verdade para o operador NOT (Tabela 10): Operação
Resultado
NOT TRUE NOT FALSE
FALSE TRUE
Tabela 10: resultados usando NOT
2.5.12. Comandos de Entrada e Saída O computador não é uma máquina isolada, pois ele precisa se comunicar com o mundo exterior através atra vés de vídeo, ví deo, impressora, teclado, tecl ado, discos, etc. Para realizar esta comunicação, existem comandos que permitem que informações sejam exibidas, por exemplo, no vídeo, como também existem comandos que permitem que informações sejam colocadas na memória do computador através do teclado. Os comandos que iremos ver são os comandos LEIA e ESCREVA, respectivamente, comando de entrada e de saída que que em Pascal escreve-se READ e WRITE . O Exemplo 16 mostra a utilização deste comandos. ALGORITMO LeEscreve VARIÁVEIS
LeEscreve LeEscreve PROGRAM VAR
Num : INTEIRO
INICIO
Num: Integer;
Begin
LEIA(Num) ESCREVA(‘Entrada’)
FIM
READ(NUM); WRITE(‘Entrada’);
END;
Exemplo 16: READ e WRITE
Obs.: Em Pascal, quando usamos os comandos READ e WRITE , o cursor continuará posicionado na mesma linha. Para evitar tal situação, devemos pular para nova linha. Isto é obtido acrescentando as letras LN (de LINE NEW , ou 44
seja, linha nova) no final dos comandos READ e WRITE . Desta forma, os comandos terão a seguinte grafia: READLN e e WRITELN .
2.5.13. Estruturas de Repetição As estruturas de repetição são usadas para conjunto de ações a serem executadas repetidas vezes. Existem três tipos básicos de repetição no PASCAL: “WHILE ”, ”, “FOR ” e “REPEAT ”. ”.
2.5.13.1. Comando While O Comando while é usado para repetir “n” vezes uma seqüência de instruções, em que “n” pode ser um valor não conhecido previamente. Antes de executar a seqüência a condição é verificada. Se a condição não for atendida, mesmo na primeira vez, a seqüência não é acessada. A seqüência será executada até a condição se tornar falsa. Logo, a sua condição deverá ser alterada, em um determinado instante, dentro da “seqüência de operações”. A estrutura do comando while pode ser vista no Exemplo 17. WHILE DO BEGIN
END.
Exemplo 17: estrutura do WHILE
O Exemplo 18 calcula a média de um grupo de números, enquanto não entrar com um número de valor zero. Algoritmo : WhileMedia Real : N1, Soma, Media; Inteiro: Contador;
WhileMedia; WhileMedia; PROGRAM USES CRT; VAR
Início Soma ← 0 Media ← 0
N1,Soma,Media: REAL; Contador: INTEGER;
BEGIN
45
CLRSCR; Soma:=0; Media:=0; Contador:=-1; N1:=1; WHILE (N1 <> 0) DO
Contador ← -1 N1 ← 1 Enquanto N1 <> de Zero Faça Leia (N1); Soma ← N1+ Soma Contador ← Contador +1
BEGIN
Fim Enquanto Media ← Soma / Contador Escreva (A media dos Contador números é igual a Media)
Fim do Programa.
WRITELN('Entre o valor para se calcular a media dos numeros'); READLN (N1); Soma:= Soma + N1; Contador:= Contador + 1; END; Media:= Soma / Contador; WRITELN('A media dos ', Contador,'numeros e=' , Media:2:2); READLN; END.
Exemplo 18: WHILE
2.5.13.2. Comando FOR Este comando é utilizado quando queremos realizar uma operação durante um número fixo e conhecido de vezes. A estrutura do comando for pode ser vista no Exemplo 19. := FOR BEGIN
TO
DO
END
Exemplo 19: estrutura do FOR
As operações são realizadas no intervalo determinado sendo incrementada automaticamente de 1 em 1. No Exemplo 20, abaixo, é calculado a média de um grupo de números, sendo informado a quantidade de números para ser tirado a média, e os seus valores, usando o comando FOR. Algoritmo : ForMedia Real : Numero, Soma, Media Inteiro: I, Quantidade
ForMedia; PROGRAM USES CRT; VAR
Início Soma ← Zero Leia (Quantidade) Para I = 1 ate Quantidade Faça Leia (Numero)
Numero,Soma,Media: REAL; I, Quantidade: INTEGER;
BEGIN CLRSCR; Soma:=0;
46
Soma
Numero + Soma
←
Fim Para Media ← Soma / Quantidade Escreva (A media dos Quantidade números é igual a Media) Fim do Programa .
WRITELN('Entre com a quantidade de numeros para ser tirado a media'); READLN(Quantidade); I:= 1 TO Quantidade DO FOR
BEGIN WRITELN ('Entre com o valor do ',I,'o numero'); READLN(Numero); Soma:=Soma+Numero; END; Media:= Soma / Quantidade; WRITELN('A media dos ',Quantidade,' numeros e= ',Media:2:2); READLN; . END
Exemplo 20: FOR
2.5.13.3. Comando REPEAT / UNTIL É usado quando não conhecemos previamente o número de vezes que uma seqüência deve ser repetida. Neste comando a condição é executada pelo menos uma vez, pois a condição fica após a seqüência de operações. A estrutura do comando repeat pode ser vista no Exemplo 21. REPEAT UNTIL < condição>
Exemplo 21: estrutura do REPEAT
Calculando a soma dos números de uma seqüência linear determinada pelo usuário, usando o repeat teremos o código do Exemplo 22. Algoritmo : Repsoma Inteiro: Numero, Soma
Início Soma ← 0 Leia (Numero)
Repita Soma ← Numero + Soma Numero ← Numero -1 Até Numero = 0 Escreva (Soma)
Repsoma; PROGRAM USES CRT; VAR Numero,Soma:INTEGER; BEGIN CLRSCR; Soma:=0; WRITELN('Entre com numero da sequencia'); READLN (Numero);
o
ultimo
Soma:= Soma+Numero; Numero:= Numero-1; UNTIL (Numero=0); WRITELN ('A Soma
desta
REPEAT
Fim do Programa
47
sequencia e ', Soma); READLN; END.
Exemplo 22: REPEAT
2.5.14. Estruturas de Seleção São as estruturas de seleção que permitem a escolha de um grupo de ações a ser executado quando determinadas condições, representada por expressões lógicas, são ou não satisfeitas. É uma expressão lógica que quando inspecionada, pode gerar um resultado falso ou verdadeiro. O Exemplo 23 mostra a estrutura de uma seleção. if (condição) then Comando único; Ou
If (condição) then begin Comandos;
End else begin Comandos;
End;
Exemplo 23: estrutura IF
O Exemplo 24 demonstra a utilização do if. Iremos calcular o resultado da média aritmética das três notas do aluno e, caso a média for maior que 6, mostrar o resultado “Aprovado” e a média obtida, caso contrário, “Reprovado” e a sua média. Algoritmo : Ifmedia3 Real : N1, N2, N3, MA
Início Leia (N1, N2, N3) MA ← (N1+ N2 + N3) / 3 Se MA > 7 então Escreva (“Aprovado”) Escreva (MA)
Senão Escreva (“Reprovado”) Escreva (MA)
Ifmedia3; PROGRAM USES CRT; N1,N2,N3,MA: REAL; VAR BEGIN CLRSCR; WRITELN('Entre com as tres notas do aluno para calcular a media'); READLN (N1,N2,N3); MA:= (N1+N2+N3) / 3; IF MA > 6.0 THEN
BEGIN
Fim Se Fim Algoritmo .
WRITELN('O
48
Aluno
foi
Aprovado'); WRITELN('A ',MA:2:2);
sua
media
e=
END ELSE BEGIN WRITELN('O Reprovado'); WRITELN('A ',MA:2:2); END; READLN; END.
Aluno sua
media
foi e=
Exemplo 24: IF
2.5.15. Sub-rotinas Quando se necessita construir um grande sistema, deve-se dividir tal programa em partes, sendo então desenvolvida cada parte em separado. Depois, tais partes são acopladas para formar o sistema. Essas partes, em que o programa é particionado e desenvolvido à parte, são o que chamamos de subrotinas. Sub-Rotina é, então, um pedaço de código computacional que executa uma função bem definida, sendo que esta sub-rotina pode ser utilizada várias vezes no programa. Uma procedure é um tipo de sub-rotina que é ativada através da colocação de seu nome em alguma parte do programa. Desta forma, assim que o nome de uma procedure é encontrado, ocorre um desvio no programa, para que os comandos da sub-rotina sejam executados. Ao término da sub-rotina, a execução retornará ao ponto subseqüente à chamada da procedure. No Exemplo 25 vemos a definição da procedure EscreverNoVideo, que é responsável por escrever a palavra fim na tela. Teste; Teste; PROGRAM
PROCEDURE EscreveNoVideo; BEGIN
49
WRITE(‘fim’); END;
BEGIN READ(N); EscreveNoVideo; END.
Exemplo 25: estrutura de uma PROCEDURE
2.5.16. Variáveis Globais e Locais Damos o nome de variáveis globais para aquelas variáveis que são definidas logo após o comando var do programa principal, sendo desta forma visíveis em qualquer qual quer parte do programa. Damos o nome de variáveis locais às variáveis que são declaradas dentro de uma sub-rotina, sendo que as mesmas só podem ser manipuladas dentro da sub-rotina que as declarou, não sendo visíveis em nenhuma outra parte do programa.
2.5.17. Passagem de Parâmetros Para ativar uma sub-rotina, como visto anteriormente, basta colocar o seu nome em alguma parte do programa. As sub-rotinas foram criadas para serem genéricas o bastante para se adaptarem a qualquer situação, visando justamente a possibilidade de reutilização do código. Para isso, precisamos entender o que chamamos de “passagem de parâmetro” que é justamente a passagem de informações para uma determinada sub-rotina para serem utilizadas em seu interior. O Exemplo 26 traz uma procedure que utiliza passagem de parâmetro. Teste; Teste; PROGRAM VAR Número Funcionário
: INTEGER; : STRING ;
50
PROCEDURE EscreveNome(N : INTEGER; Nome : STRING ); I I : INTEGER; VAR BEGIN i i : = 1 TO n DO FOR BEGIN WRITE(Nome);
END; END ; BEGIN READ(Número, Funcionário); EscreveNome(Número, Funcionário);
END.
Exemplo 26: passagem de parâmetro
Variáveis do mesmo tipo são separadas por vírgulas (,) e variáveis de tipos diferentes são sã o separadas por ponto e vírgula (;). Os nomes dados aos parâmetros parâmetros não necessitam serem iguais às variáveis passadas para sub-rotina. sub -rotina. Temos dois tipos de passagem por parâmetro: parâmetro : a) Passagem de parâmetros por valor: qualquer alteração no conteúdo de um parâmetro, dentro de uma sub-rotina, não será refletido no programa chamado. b) Passagem de parâmetros por referência: quando a alteração no conteúdo de um parâmetro, dentro de uma sub-rotina, se reflete no programa que chamou. Os parâmetros a serem passados por referência deverão ter, na definição da da sub-rotina, colocado na frente do nome do parâmetro, parâmetr o, a palavra var .
2.5.18. Função Uma sub-rotina do tipo function possui as mesmas características de uma procedure no que se refere a passagem de parâmetros, variáveis globais e locais, mas possui uma importante diferença, que é o retorno de um valor ao término de sua execução, ou seja, uma function sempre deverá retornar um valor a quem a chamou. c hamou. 51
Na definição de uma function, deverá ser informado qual o tipo do valor retornado. O Exemplo 27 traz a estrutura de uma function. function ():;
Exemplo 27: estrutura de uma FUNCTION
Para informar qual o valor deve ser retornado, deve ser colocada, em algum ponto do código da function, uma linha com a seguinte sintaxe do Exemplo 28. result := ;
Exemplo 28: valor a ser retornado pela FUNCTION
52
2.6.
Delphi
2.6.1. Introdução O nome “Delphi” faz referência Delphos, o nome da localidade onde se situava um templo dedicado ao Deus Apolo. Nesse local, havia um oráculo para onde os cidadãos gregos se dirigiam para perguntar sobre o futuro às Pitonisas, videntes do local. Essa é a origem do nome dado ao ambiente de desenvolvimento de aplicações, orientado a objeto, que permite o desenvolvimento de poderosas aplicações baseadas no MS Windows com o mínimo de codificação. Ele foi criado pela Borland em 1995. Incorpora modernos conceitos de programação visual combinados aos poderosos recursos da linguagem Object Pascal. O Delphi (e os compiladores da Borland) utiliza um compilador extremamente otimizado, oriundo de mais de uma década de experiência em compiladores para a linguagem Pascal, da qual deriva. A linguagem Delphi é considerada como uma das mais completas e abrangentes já criadas até hoje, incluindo recursos como orientação a objetos, blocos protegidos, tratamento de exceções, eventos, propriedades, entre outros. O Delphi oferece ferramentas de desenvolvimento, tais como templates de aplicações e forms (janelas), que permitem criar e testar rapidamente o protótipo de aplicações. Pode-se utilizar o conjunto de componentes e código gerado para transformar protótipos em aplicações robustas que satisfaçam às necessidades. Além disso, também possui ferramentas de bancos de dados que permitem desenvolver aplicações Client/Server e relatórios. As ferramentas de bancos de dados permitem a visualização de dados 53
dinamicamente durante o desenvolvimento para que verifique imediatamente se os resultados das consultas estão de acordo com os objetivos almejados.
2.6.2. Conceitos Básicos do Ambiente Delphi As características básicas da programação orientada a objetos se resumem em classes. Cada classe é um tipo de dado definido pelo usuário, contendo métodos como funções e procedimentos. Cada objeto pertence a uma classe e cada componente é um objeto, que contém propriedades, métodos e eventos.
2.6.3. Ambientes de Desenvolvimento Um ambiente de desenvolvimento consiste na combinação de uma série de aplicativos habilitados para escrita de código fonte, compilação, depuração e entrega de aplicativos. Em geral possuem estreita ligação com a linguagem de programação, sendo em muitos casos chamados de Ambientes Integrados de Desenvolvimento (AID). O conceito de AID permitiu um grande salto de qualidade no desenvolvimento de aplicações, possibilitando depurações iterativas, acompanhamento passo a passo da execução dos aplicativos, melhor compreensão do código como um todo e outras vantagens. Mais recentemente, este conceito foi expandido para incorporar as facilidade de Desenvolvimento Rápido de Aplicações. Os ambientes pertencentes a esta categoria, na qual o Borland Delphi se inclui, permitem que o programador especifique manualmente o posicionamento dos componentes de um aplicativo e associe trechos de código a eventos destes componentes.
54
2.6.4. Características do Delphi O Delphi consiste de vários elementos, ferramentas de design e de banco de dados para auxiliá-lo a desenvolver e testar suas aplicações de forma rápida e intuitiva. A seguir descrevemos algumas características do Delphi: •
Construtor Visual de Interface com o Usuário: o IDE permite criar visualmente aplicações Client/Server de forma rápida através da seleção de componentes em paletas.
•
Arquitetura Baseada em Componentes: os componentes asseguram que as aplicações Delphi sejam robustas, reutilizáveis e de fácil manutenção.
•
Compilador de Código Nativo de Alta Performance: o compilador gera código otimizado de máquina ao invés de pcode interpretado e lento, fazendo com que as aplicações sejam até vinte vezes mais rápidas.
•
Tow-Way Tools: a capacidade de alternar entre um form e seu código permite que o desenvolvedor trabalhe tanto na edição de texto como no modo de design visual através de total sincronização do código fonte com a representação visual.
•
Biblioteca de Componentes Visuais (VCL-Visual Component Library): consiste de objetos reutilizáveis incluindo objetos padrão de interface com o usuário, gerenciamento de dados, gráficos, multimídia, gerenciamento de arquivos e quadros de diálogo padrão. 55
•
Arquitetura Aberta: a arquitetura do IDE permite adicionar componentes e ferramentas personalizadas e de terceiros.
•
Linguagem Orientada a Objetos: o Delphi utiliza o Object Pascal, que oferece a facilidade de programação em 4GL de alto nível com a performance e poderio de um 3GL.
•
Suporte à Tecnologia do Windows: o Delphi é compatível com a tendência da tecnologia Windows, incluindo suporte a OLE 2.0, DDE, VBXs e ODBC.
•
Debugador Gráfico: o Debugger permite encontrar e eliminar "bugs" em seu código.
•
Edição Estilo Brief: o Editor permite a utilização de um conjunto de símbolos para expressões.
•
Ambiente Personalizável: a opção de menu Environment Options permite personalizar seu ambiente para o máximo de produtividade.
•
Object Browser: permite a visualização da hierarquia dos objetos na visual component library.
•
Gerenciador de Projetos: o Project Manager oferece uma visualização de todos os forms e units de um determinado projeto e oferece um mecanismo conveniente para gerenciar projetos.
2.6.5. Escrevendo Aplicações 2.6.5.1. Estrutura do Código 56
Aplicações escritas em Delphi são também chamadas de projetos, podendo estar divididas em uma ou mais unidades (arquivos de código) separadas. Uma vez que a linguagem Delphi deriva da linguagem Pascal, cada unidade de código pode conter diversos tipos de símbolos, tais como funções, procedimentos, classes declarações de variáveis, etc . Entretanto, a linguagem Pascal não possui suporte para geração de aplicações visuais, o que faz com que algumas considerações especiais sejam feitas quando se escreve código em Delphi. Para todos os diferentes tipos de janelas que um programa possa exibir deve haver uma classe que implemente suas funções. O ambiente Delphi provê uma classe denominada TForm que implementa todas as funções básicas de uma janela comum do ambiente Windows, maximização, criação, fechamento e outras mais, sendo indicada como classe básica para qualquer classe que implemente quaisquer tipos de janela. Por este motivo, quando o usuário adiciona um novo modelo de janela ao seu projeto, o Delphi automaticamente cria uma nova classe herdada de TForm e a associa a esta janela. Desta forma, mesmo que o usuário não escreva
código algum, já terá um modelo de janela disponível a partir do qual poderá criar várias instâncias durante a execução de seu programa. Quando se abre um projeto no Delphi, ele já mostra uma unit com várias linhas de código. Um projeto Delphi tem, inicialmente, duas divisórias: uma unit , que é associada a um Form , e outro projeto, que engloba todos os Form e unit da aplicação.
57
Em Delphi, temos: o Project, os Forms e as Units. Para todo Form temos uma Unit (Código do Form), mas temos Units sem form (códigos de procedures, funções, etc).
2.6.5.2. Arquivos de uma Aplicação Na Tabela 11, a seguir, são descritas as definições e funções de tais arquivos. Extensão do Definição Arquivo .DPR Projeto
Função
.PAS
Código fonte da Unit (Object Pascal)
.DFM
Arquivo gráfico formulário
.OPT
opções do projeto
.RES
Recursos do Compilador Backup do Projeto Backup da Unit Backup do Arquivo gráfico do formulário
.~DPR1 .~PAS1 .~DFM1 .DSK
do
Situação da Área de Trabalho
Código fonte em Pascal do arquivo principal do projeto. Lista todos os formulários e units no projeto, e contém código de inicialização da aplicação. Criado quando o projeto é salvo. Um arquivo .PAS é gerado por cada formulário que o projeto contém. Seu projeto pode conter um ou mais arquivos .PAS associados com algum formulário. Contem todas as declarações e procedimentos incluindo eventos de um formulário. Arquivo binário que contém as propriedades do desenho de um formulário contido em um projeto. Um .DFM é gerado em companhia de um arquivo .PAS para cada formulário do projeto. Arquivo texto que contém a situação corrente das opções do projeto. Gerado com o primeiro salvamento e atualizado em subsequentes alterações feitas para as opções do projeto. Arquivo binário que contém o ícone, mensagens da aplicação e outros recursos usados pelo projeto. Gerado quando o projeto é salvo pela segunda vez. Se um .PAS é alterado, este arquivo é gerado. Se for aberto um. DFM no editor de código e f or feita alguma alteração, este arquivo é gerando quando se salva o arquivo. Este arquivo armazena informações sobre a situação da área de trabalho especifica para o projeto em opções de ambiente(Options Environment).
[1]: são arquivos de backup (menu “Tools, Editor Options...”, guia Display, opção Create Backup Files). Tabela 11: arquivos de uma aplicação
Devido a grande quantidade de arquivos de uma aplicação, cada projeto deve ser montado em um diretório específico.
58
2.6.5.3. Arquivos Gerados pela Compilação Quando é feita a compilação do projeto, são criados os arquivos listados na Tabela 12. Extensão Arquivo .EXE
.DCU
Definição Arquivo compilado executável
Função Este é um arquivo executável distribuivel de sua aplicação. Este arquivo incorpora todos os arquivos .DCU gerados quando sua aplicação é compilada. O Arquivo .DCU não é necessário distribuir em sua aplicação. Código objeto A compilação cria um arquivo .DCU para cada .PAS no da Unit projeto. Tabela 12: arquivos gerados na compilação
2.6.5.4. Exemplo de Aplicação Para um projeto intitulado Notepad , por exemplo, contendo uma unidade chamada MainWnd associada a um modelo de formulário, outra chamada de About também associada a um formulário e uma terceira unit chamada de Search, teríamos os seguintes arquivos gravados em disco: Arquivos NOTEPAD.DPR NOTEPAD.CFG NOTEPAD.RES MAINWND.PAS MAINWND.DFM ABOUT.PAS ABOUT.DFM SEARCH.PAS
Representação Arquivo de projeto da aplicação. Nada mais é do que o módulo p r o g r a m de um programa escrito em pascal Opções de compilação do aplicativo, tais como forma de otimização, geração de tabelas de símbolos e outros. Contém os recursos do aplicativo final. Recursos são ícones, bitmaps , tabelas de strings e outros elementos comuns a programas escritos para o ambiente Windows Código fonte da unidade MainWnd Representação binária do formulário contido na unidade MAINWND.PAS Código fonte da unidade About Representação binária do formulário contido na unidade ABOUT.PAS; Código fonte da unidade SEARCH Tabela 13: exemplo de arquivos de uma aplicação
Com um projeto e unidades definidos desta forma, a aplicação final receberia o nome de NOTEPAD.EXE, contendo o código compilado de todas as
59
unidades além das descrições de formulários contidos nos arquivos de extensão DFM e dos recursos contidos em NOTEPAD.RES.
2.6.5.5. O Arquivo de Projeto (*.DPR) Os arquivos de extensão DPR são gerados automaticamente quando o programador pede a criação de um novo projeto e, também, atualizados automaticamente quando o usuário altera os nomes dos formulários ou unidades envolvidos no projeto. Neste arquivo está escrito o código de criação da aplicação e seus formulários. O arquivo Project tem apenas uma seção. Esta seção é formada pelo seguinte código: •
PROGRAM - define o Projeto;
•
USES - cláusula que inicia uma lista de outras unidades;
•
Forms - é a unidade do Delphi que define a classe TForm;
•
In - cláusula indica ao compilador onde encontrar o arquivo referente a Unit;
•
Unit1 - unidade que criada;
•
{$R *.RES} - diretiva de compilação que inclui o arquivo de recursos.
O Exemplo 27 traz o código de um projeto. Notepad; program
uses Forms, Mainwnd in 'MAINWND.PAS' {FormBlocoNotas}, About in 'ABOUT.PAS' {AboutBox}, Search in 'SEARCH.PAS'; {$R *.RES}
60
begin Application.Title := 'Bloco de Notas Sythus'; Application.CreateForm(TFormBlocoNotas, FormBlocoNotas); Application.Run;
end.
Exemplo 29: projeto
2.6.5.6. As Unidades (*.PAS) Uma unidade pode conter declarações de tipos, variáveis, constantes e classes. Também pode conter declarações e as respectivas implementações de procedimentos e funções. Nestes arquivos serão escritos os códigos dos seus respectivos forms (Unit1 = Form1). Aqui são definidos os códigos de cada procedimento dos
componentes que se colocar no form. •
Seção Unit - declara o nome da unit .
•
Seção Uses - contém as units acessadas por este arquivo.
•
Seção Interface - nesta seção estão às declarações de constantes, tipos de variáveis, funções e procedimentos gerais da Unit/Form. As declarações desta seção são visíveis por qualquer unit . Esta seção é formada pelo seguinte código:
- INTERFACE - palavra que inicia a seção; - USES - cláusula que inicia uma lista de outras unidades compiladas (units). Será adicionado automaticamente as units necessárias aos componentes que foram inseridos no formulário, mas caso declare uma variável de um tipo em que a definição esteja em outra unit ou precise de um procedimento que igualmente não esteja presente nas units declaradas, será necessário adicionar manualmente. 61
•
Seção Type - declara os tipos definidos pelo usuário. Subseções: Private , declarações privativas da Classe; e Public declarações públicas da Classe.
•
Seção Var - Declara as variáveis públicas.
•
Seção Implementation - contém os corpos das funções e procedimentos declarados nas seções Interface e Type. Nesta seção também estão definidos todos os procedimentos dos componentes que estão incluídos no Form . As declarações desta seção são visíveis apenas por ela mesma. Esta seção é formada pelo seguinte código:
- {$R*.DFM} - diretiva de compilação que inclui toda a interface, propriedades do Form e componentes do arquivo *.DFM; - Seção uses adicional - serve para declarar Units que serão necessárias a esta; Inicialization - nesta seção, que é opcional, pode ser definido um código para proceder as tarefas de inicialização da Unit quando o programa começa. Ela consiste na palavra reservada inicialization seguida por uma ou mais declarações para serem executadas em ordem. O Exemplo 30 traz o código de uma unit . unit About; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, Buttons, ExtCtrls;
type TAboutBox = class(TForm) Panel1: TPanel;
62
OKButton: TBitBtn; ProgramIcon: TImage; ProductName: TLabel; Version: TLabel; Copyright: TLabel; Comments: TLabel;
procedure OKButtonClick(Sender: TObject); private { Private declarations }
public { Public declarations }
end; implementation {$R *.DFM}
procedure TAboutBox.OKButtonClick(Sender: TObject); begin Close;
end; end.
Exemplo 30: estrutura de uma Unit
2.6.5.7. Eventos A linguagem Delphi, assim como a maioria das linguagens desenvolvidas para o ambiente Windows, suporta também o conceito de orientação a eventos. Isto significa que o código escrito pelo usuário não possui uma seqüência clara de execução, como teria em uma linguagem tradicional para o ambiente DOS. Um bom exemplo pode ser a entrada de caracteres em um campo comum de texto. Normalmente, em uma linguagem convencional, o usuário precisaria escrever uma rotina que lesse uma seqüência de caracteres um a um e os colocasse em uma string final. Caso precisasse que algum caractere tivesse 63
algum tipo de tratamento especial, por exemplo, a tecla enter para indicar o final da entrada, também precisaria adicionar este código dentro da seqüência de leitura. No Delphi já existe um código padrão para entrada de caracteres em uma classe de nome TEdit . Dentro deste código padrão, a cada caractere lido, a biblioteca verifica se o usuário escreveu alguma rotina para tratar os caracteres individualmente e, caso exista, ele a chama. Em outras palavras, o usuário escreve um tratador (a rotina) para um evento (o caractere digitado). Estes tratadores são implementados como métodos da classe associada ao formulário que contém os componentes que geram os eventos e não como métodos do próprio componente. No código abaixo gerado para um formulário que contém um único botão, o tratador associado ao evento clicar (click) do botão é implementado como método da classe associada ao formulário e não como um método da classe BitBtn , que define o botão. unit About; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, Buttons, ExtCtrls;
type TDlgAbout = class(TForm) BitBtn1: TBitBtn;
procedure BitBtn1Click(Sender: TObject); ; end
implementation {$R *.DFM}
64
procedure TDlgAbout.BitBtn1Click(Sender: TObject); begin Close; ; end . end
Exemplo 31: evento
Uma vez que um tratador de eventos nada mais é do que um método de uma classe, é necessário que a informação da associação entre o tratador e o evento fique gravada no arquivo de descrição do formulário (.DFM) . Isso significa também que uma vez desfeita a associação entre um tratador e um evento, o código não é removido automaticamente pelo ambiente, podendo ser perfeitamente utilizado por outras rotinas de seu programa, desde que chamadas diretamente pelo código do usuário.
2.6.6. Elementos Visuais O Integrated Development Environment (IDE) do Delphi consiste de diversos elementos ou ferramentas visuais. Uma vez acostumados a estes elementos, pode-se começar a desenvolver aplicações. Os principais elementos visuais, que serão vistos em maiores detalhes, são: Form, Component Palette, Object Inspector, Code Editor, SpeedBar e On-Line Help.
2.6.6.1. Form A utilização de form é a característica central das aplicações Delphi. Quando o Delphi é aberto, um form se torna uma janela em sua aplicação. Quando estiver desenvolvendo a interface de usuário de uma aplicação, 65
adicionar-se-ão itens chamados de componentes ao seu form . Um componente é um objeto Delphi, tal como um label ou edit box . O formulário é uma janela, e, portanto, possui os atributos de uma janela (menu de controle, botões de maximizar e minimizar, barra de título, bordas redimensionáveis). Quando se inicializa o Delphi, um form em branco com nome de Form1 aparece, como mostrado na Figura 11.
Figura 11: Form em branco
2.6.6.2. Component Palette (Palheta de Componentes) É composto de várias páginas contendo, cada uma, um grupo de componentes reunidos por função ou utilização. Esses componentes são utilizados para construir a interface com o usuário. Um ponto chave do Delphi é que ele permite a criação de seus próprios componentes e personalização da Componente Palette. O usuário pode adicionar ou remover componentes da paleta, bem como criar uma nova página na paleta. A Component Palette aparece abaixo da barra de menu, à direita. Em destaque na Figura 12.
66
Figura 12: Component Palette
Quando se clica com o mouse sobre uma aba de página, é exibido o grupo de componentes da página.
2.6.6.3. Object Inspector (Inspetor de Objetos) O Object Inspector trabalha de acordo com o componente selecionado.
Uma vez selecionado um componente, o Object Inspector
automaticamente exibe as propriedades e eventos que podem ser utilizados para o componente. As propriedades e eventos permitem personalizar os componentes visualmente sem a necessidade de codificação. Os menus são dinâmicos no tocante em que somente as propriedades e eventos que se aplicam aos componentes selecionados aparecerão. Se múltiplos componentes são selecionados, somente as propriedades e eventos compartilhados por todos os componentes aparecerão no Object Inspector. A figura abaixo mostra o Object Inspector.
67
Seletor de Objetos (mostra o nome e o tipo de objeto selecionado) Página de Propriedades
Página de Eventos
Coluna de Propriedades Coluna de Valores
Propriedades aninhadas
Figura 13: Object Inspector
A página propriedades permite que se estabeleça parâmetros de formulários e componentes. Estes parâmetros especificam os valores iniciais de características, como nome do componente e sua posição no formulário. A páginas eventos permite associar os componentes com ações (procedimentos) definidas pelo usuário.
2.6.6.4. Code Editor (Editor de Código) No processo de desenvolvimento, após atribuir propriedades e eventos a cada componente adicionado ao Form, o Code Editor é utilizado. O Code Editor é um editor de texto que exibe o código fonte que o desenvolvedor escreve ou que o Delphi gera para criar uma aplicação. O código fonte aparece
68
em um arquivo chamado UNIT.PAS que é um dos tipos de arquivos que compõe um projeto do Delphi. O Code Editor oferece comandos de edição, Help sensível ao contexto e as seguintes características de edição: sintaxe de destaque colorida, desfazer (undo) ilimitado, marcação de bloco de coluna e toques de teclado personalizáveis. O Code Editor aparece no arquivo unit, que é posicionado atrás do Form1 default quando o Delphi é iniciado. Quando um duplo clique é dado em um evento na página Events do Object Inspector, o Code Editor automaticamente torna-se a janela ativa para que se possa digitar o código para manipular o evento. O Code Editor pode exibir múltiplos arquivos unit. Uma unit é utilizada para organizar as declarações de programação do Delphi. Por exemplo, procedures utilitárias podem ser agrupadas como uma unit. Um form é organizado como uma unit. O arquivo default, Unit1.PAS, aparece na janela do Code Editor, como pode ser visto na Figura 14.
69
Figura 14: Code Editor
2.6.6.5. SpeedBar A SpeedBar é feita de botões que economizam tempo, permitindo que, com um clique, possam ser executadas operações e comandos mais comuns. A SpeedBar aparece abaixo da barra de menu, à esquerda, e consiste dos seguintes botões:
Figura 15: SpeedBar
A SpeedBar é totalmente personalizável. Pode-se adicionar ou remover botões. A Figura 15 representa a configuração default da SpeedBar, cuja descrição de cada um desses botões é mostrada na Tabela 14.
70
Botão New
Descrição Possibilita a criação de um item Abre um arquivo existente
Open File
Grava o arquivo. Arquivos unit e form são ligados. Gravando um, grava-se o outro Salva todas as alterações no projeto e suas unit’s
Save File Save All
Open Project Add File to Project Remove File From Project Help Contents Select Unit From List Select Form From list
Abre um projeto existente Adiciona um novo arquivo ao projeto Remove o arquivo selecionado no Project Manager da cláusula uses do arquivo de projeto corrente Chama a ajuda do sistema Seleciona uma unit da lista das units existentes Seleciona um form da lista de forms existentes
Exibe o from inativo associado com a unit ativa, ou viceToggle Between a Form and versa Unit Cria um form em branco e uma nova unit associada para New form ser adicionado ao projeto Compila e executa sua aplicação Run Interrompe momentaneamente a execução da aplicação Pause Executa um programa, uma linha por vez e executa cada Trace into linha de uma procedure Executa um programa, uma linha por vez e pula as Step over procedures executando-as como uma única unit
Tabela 14: botões do SpeedBar
2.6.6.6. Help On-Line O Help On-Line é uma grande fonte de referência sobre o Delphi. No menu Help, os itens Contents e Topic Search são comuns às aplicações MS Windows, mas documentam o produto tão bem que pode-se utilizá-lo no lugar de uma cópia impressa. O Contents, em particular, inclui um glossário, que é especialmente útil para uma referência rápida sobre o significado de termos. A Figura 16 mostra o menu Help:
71
Figura 16: help
A ajuda sensível ao contexto está disponível para cada elemento na interface. Pressionando F1 sobre um elemento destacado é exibida a descrição deste elemento. Por exemplo, se Form1 estiver destacado e for pressionado a tecla F1, a descrição do componente TForm (tipo de objeto) aparece, incluindo as propriedades, métodos, eventos e tarefas associadas a ele. O Help sensível ao contexto também está disponível quando o Code Editor for exibido e oferece auxílio na sintaxe da linguagem, palavras reservadas, e assim por diante.
2.6.7. Suporte a Programação Orientada a Objeto Como já comentado anteriormente, as características básicas da programação orientada a objetos se resumem em Classes. Cada classe é um tipo de dado definido pelo usuário, contendo métodos como funções e procedimentos. Cada objeto pertence a uma classe e cada componente é um objeto, que contém propriedades, métodos e eventos. A propriedade (property) funciona como se fossem os parâmetros do objeto, como dentre outros: cor, título, texto, alinhamento, tamanho e posição. Algumas propriedades podem ou devem ser modificadas em tempo de projeto, 72
outras são propriedades apenas de leitura, ou seja, só retornam características específicas sobre o objeto atual no momento solicitado. Os métodos (methods) são os comandos de execução do objeto, executando uma determinada operação disponível no mesmo. Alguns exemplos de métodos são: executar, focalizar e localizar. Os eventos (events) são as reações de determinado objeto, toda operação ou modificação neste executa um evento. Através dos eventos disponíveis podemos controlar vários outros objetos.
2.6.7.1. Propriedades Como vimos, eventos podem estar associados a modificações em propriedade de componente e formulário, ou seja, pode-se modificar propriedades de formulários e componentes durante a execução do sistema. Para isto deve-se usar a sintaxe: .; Por exemplo, para modificar a propriedade text de uma caixa de edição Edit1 para “Bom Dia” faz-se: Edit1.Text := ‘Bom Dia’; Se a propriedade do componente tiver sub-propriedades, para acessá-la, utilize a seguinte sintaxe: .. Por exemplo, para modificar a sub-propriedade Name referente a propriedade fonte, de uma caixa de edição Edit1, para ‘Script’, basta fazer: Edit1.Font.name := ‘Script’;
73
2.6.7.2. Eventos Eventos são ações normalmente geradas pelo usuário, como por exemplo: o clicar do mouse, pressionar uma tecla do teclado, mover o mouse, etc. Os eventos podem ser também gerados pelo Windows. Existem eventos associados ao formulário e cada componente inserido neste. Exemplos: o OnShow do formulário ocorre quando mostramos o formulário na tela; o componente botão possui o evento OnClick, que ocorre quando damos um clique com o mouse sobre o botão.
2.7. Delphi Acessando Banco de Dados 2.7.1. Introdução Uma aplicação de bancos de dados pode ser construída utilizando as ferramentas de desenvolvimento de banco de dados do Delphi, componentes da paleta Data Access e Data Control . Para acessar informações do banco de dados, o Delphi possui as paletas: BDE (diversos bancos, acesso através do BDE), Interbase (bancos Interbase e Firebird, acesso direto), dbExprees (diversos bancos, acesso dependente de drivers específicos, os já inclusos são: DB2, Oracle, Interbase e MySQL) e ADO (bancos MS SQL Server e MS Access, acesso direto). A seguir, na Figura 17, será mostrado a conectividade do Delphi com os diversos banco de dados.
74
Figura 17: acesso a banco de dados
O acesso através do BDE é o mais simples e que possibilita acesso a um número maior de diferentes SGBD, mas, em compensação, é o mais lento. As aplicações de banco de dados que utilizam os componentes da paleta BDE se comunicam com o Borland Database Engine (BDE), que, por sua vez, comunica-se com suas outras fontes: dados locais, tais como dBASE, Paradox e InterBase for Windows; e, dados remotos, tais como Oracle, Sybase e InterBase
2.7.2. Relacionamento entre o Delphi e a Conectividade de Banco de Dados O diagrama da Figura 18 mostra as formas de acesso a bases de dados mostrando os elementos envolvidos e suas interações para est e acesso.
75
Figura 18: conectividade do BDE
2.7.3. Ferramentas de Bancos de Dados As seguintes ferramentas a seguir permitem construir aplicações de banco de dados que podem trabalhar com arquivos de dados locais ou em um servidor de rede local: Borland Database Engine (BDE), SQL Links, Database Desktop, Componentes Data Access e Componentes Data Control. Algumas destas ferramentas serão abordadas a seguir.
2.7.4. Borland Database Engine (BDE) O Borland Database Engine (BDE) é construído no Delphi para oferecer uma conexão entre controles Data Access e dados de várias fontes, como Paradox, dBASE, Oracle e InterBase. Bancos de dados, linguagens e ferramentas da Borland compartilham o mesmo Borland Database Engine. Este design em comum permite que os componentes sejam intercambiados para construir um ambiente de aplicação Client/Server que atenda às suas necessidades.
76
O Borland Database Engine (BDE) é uma coleção de DLLs a quem as aplicações de banco de dados irão fazer chamadas. Cada estação de trabalho, que tiver a aplicação de banco de dados instalada, deverá ter também o BDE instalado (o Delphi vem com a instalação do BDE para se adicionar a aplicação). O BDE permite usar tabelas dBase, Paradox ou ODBC em modo multi-usuário. A versão Cliente/Servidor do Delphi também vem com links para servidores de banco de dados como Oracle, Sybase, MS SQL Server, Informix e InterBase.
2.7.5. Relacionamento entre o BDE e Outros Produtos Borland O Borland Database Engine é um componente integral do dBASE for Windows, Paradox for Windows, Delphi e ReportSmith. Também está disponível como biblioteca API de engine de banco de dados para prog ramadores C e C++. O Borland Database Engine permite que ferramentas e aplicações Borland se conectem, transparentemente, a dados residindo no dBASE, Paradox, Oracle, Sybase, Interbase, Informix, DB2 e qualquer banco de dados que utilizem o Open Database Connectivity (ODBC).
2.7.6. Database Desktop O Database Desktop é uma ferramenta de definição e manutenção de banco de dados que permite consultar, criar, reestruturar, modificar, copiar tabelas de banco de dados e copiar dados e informações do dicionário de dados de um formato para outro. O Database Desktop é encontrado no menu do Delphi em Tools. Na Figura 19, é mostrado o Database Desktop com a tabela bdesdd.DB aberta. 77
Figura 19: Database Desktop
2.7.7. Descrição do Componente DataSource O componente DataSource se encontra na página Data Access do Component Palette. Todo dataset (dataset é todo componente que representa informações em colunas e linhas) precisa estar associado a um componente data source se suas informações serão exibidas ou manipuladas em componentes data-aware (componentes que reconhecem informações diretas do banco de
dados). Igualmente, cada componente data-aware precisa estar associado a um componente data source para ser capaz de receber e manipular informações. O componente data source também é responsável por interligar datasets fazendo relacionamento mestre-detalhe (master-detail). Na Figura 20 está a representação esquemática do que foi dito.
78
Figura 20: esquema de ligação entre Dataset, DataSource e Data Controls
2.7.8. Descrição dos Componentes da Guia BDE A Tabela 15 descreve alguns componentes da guia BDE. Ícone Ttable
TQuery
StoredProc TDatabase TBacthMove
Propósito Um objeto Table refere-se a uma tabela de banco de dados. Deve-se indicar o nome do banco de dados que quer usar na propriedade DatabaseName (pode ser próprio nome, um alias ou o caminho do diretório em que estão os arquivos da tabela). O Object Inspector lista os nomes disponíveis, o que depende da instalação do BDE. Deve-se indicar o nome do arquivo que contém a tabela na propriedade TableName. Uma query é mais complexa que uma tabela, porque precisa de uma string de linguagem SQL. O componente Query também tem uma propriedade DatabaseName, mas não uma propriedade TableName. A tabela está indicada dentro da declaração SQL, armazenada na propriedade SQL. Permite que aplicações executem stored procedures do servidor Define uma conexão contínua à um banco de dados. Uma propriedade importante deste componente é LoginPrompt que deve ser alterada para False para que o login de conexão do banco não se abra a cada conexão. Copia a estrutura de uma tabela ou seus dados. Pode ser utilizado para mover tabelas inteiras de um banco de dados a outro. É especialmente útil em migração de um banco de dados para outro.
Tabela 15: componentes BDE
A eficiência de uma tabela ou query depende do banco de dados que estiver sendo utilizado. Dificilmente o componente Table será mais rápido que o Query , principalmente quando a aplicação estiver rodando em rede. Mas, para obter o melhor rendimento da aplicação, deve-se incluir no select da query somente os campos necessários e retornar o mínimo de linhas possível. Caso 79
utilize um comando “select * from tabela” , a velocidade tenderá a ser a mesma do componente Table. As Queries podem ser utilizadas para unir duas ou mais tabelas e ver o resultado como se fosse uma única tabela armazenada no banco de dados. Enquanto um componente Table refere-se somente a uma tabela do banco de dados, uma instrução SQL pode produzir qualquer tabela, interligando as tabelas do banco como resultado. Isso permite que se visualize uma tabela que não esteja no banco de dados, mas que seja o resultado de uma união, uma seleção ou outros cálculos. Quando se opera em um dataset no Delphi (isso se aplica a qualquer componente que derive da classe dataset ), pode-se trabalhar em diferentes estados, indicados por uma propriedade state específica, que pode assumir valores diferentes: dsBrowse (indica que o dataset está em modo normal de visualização, utilizado para ver e pesquisar os dados), dsEdit (indica que está em modo de edição), dsInsert (indica que um novo registro está sendo adicionado), dsInactive (é o estado de um dataset fechado), dsSetKey (indica que está preparando uma pesquisa) e dsCalcFields (enquanto se processa um cálculo de campo, ocorre quando há uma chamada a um manipulador de evento OnCalcField).
2.7.9. Descrição dos Componentes Data Control Os componentes Data Control dão às aplicações Delphi de banco de dados uma interface visual consistente, quer a aplicação acesse um arquivo de banco de dados local ou um servidor remoto.
80
Já vimos que é possível conectar uma fonte de dados a um banco de dados, usando uma tabela ou uma query , mas ainda não sabemos como mostrar os dados. Para isso, o Delphi tem muitos componentes que se parecem com os controles normais do Windows, mas que são relacionados com dados. Por exemplo, o componente DBEdit é similar ao componente Edit , e o componente DBCheckBox corresponde ao componente CheckBox . A Tabela 16 descreve os componentes Data Control na Component Palette: Ícone TDBGrid
TDBNavigator TDBLabel TDBEdit TDBMemo
TDBImage TDBListBox TDBComboBox TDBCheckBox TDBRadioGroup TDBLookupList TDBLookupCombo DBCtrlGrid
Propósito Permite visualizar e editar dados em formato tabular (tipo planilha). Faz uso extensivo das propriedades do Tfield para determinar a visibilidade de uma coluna, modo de exibição, e assim por diante. Ela permite rolagem e navegação e pode-se editar seu conteúdo é um conjunto de botões usados para navegar e executar ações no banco de dados é usado para exibir o conteúdo de um campo que não pode ser modificado. É a versão data-aware do componente TLabel Permite exibir ou editar um campo de um registro ativo. É a versão data-aware do componente TEdit é usado para permitir que o usuário veja e modifique um grande campo de texto, eventualmente armazenado em um campo memo ou BLOB (que significa, em inglês, Grande Objeto Binário).É a versão dataaware do componente TMemo Permite exibir, recortar, ou colar imagens bitmap BLOB para e de um registro ativo. É a versão data-aware do componente TImage Permite exibir valores de uma coluna de uma tabela. É a versão dataaware do componente TListBox Permite exibir ou editar valores de uma coluna de uma tabela. É a versão data-aware do componente TComboBox Permite exibir ou editar um campo de dado Booleano de um registro ativo. É a versão data-aware do componente TCheckBox Permite exibir ou definir valores de colunas. É a versão data-aware do componente TGroupBox populado com radio buttons Permite exibir dados de uma tabela de busca durante a execução. É a versão data-aware do componente TListBox Permite exibir dados de uma tabela de busca durante a exibição. É a versão data-aware do componente TComboBox é uma grade multi-registro, que pode acomodar diversos outros controles relacionados com dados. Estes controles são duplicados para cada registro do data set Tabela 16: componentes Data Controls
Todos esses componentes são conectados à fonte de dados usando a propriedade correspondente, DataSource. Muitos deles referem-se a um campo 81
de dados específico da fonte, com a propriedade DataField. Uma vez a propriedade DataSource é selecionada, a propriedade DataField terá uma lista de valores disponíveis na caixa de opções do Object Inspector. Na Figura 21 é mostrado um esquema de conexão dos componentes Data Control, Data Source, DataSets, BDE e Banco de dados.
Figura 21: conexão entre Data Control, Data Source, DataSets, BDE e Banco de Dados
2.7.10. Usando DataSets As classes de componentes TTable e TQuery são descendentes de TDataset através do TDBDataSet. Esta classe de componente herda uma parte de propriedades, métodos e eventos.
2.7.10.1. Abrindo e Fechando DataSets Antes que uma aplicação possa acessar dados através de um dataset , este deve ser aberto. Existem dois meios para abrir o dataset :
82
•
Ativando a propriedade active para true, isto pode ser feito através do Object Inspector ou programavelmente em tempo de execução, com o seguinte código: Table1.Active := True;
Chamando o método Open em tempo de execução:
•
Table1.open; Para fechar o dataset, usam-se meios semelhantes aos da abertura, alterando-se apenas a pripriedade para false e o método para close.
2.7.10.2. Navegando no Dataset As principais propriedades e métodos de navegação no dataset podem ser vistos na Tabela 17. Método ou Propriedade Método First Método Last Método Next Método Prior Propriedade BOF Propriedade EOF Método MoveBy(n)
Descrição Move o cursor para a primeira linha em um dataset. Move o cursor para a ultima linha em um dataset. Move o cursor para a próxima linha em um dataset. Move o cursor linha anterior em um dataset. True quando o cursor está no inicio do dataset, em outro caso é false. True quando o cursor está no final do dataset, em outro caso é false. Move o cursor para n linhas a frente em um dataset, quando n é um numero inteiro positivo ou negativo.
Tabela 17: propriedades e métodos de navegação
Como exemplo, para mover o cursor para o último registro da tabela, deve-se executar o seguinte comando: Table1.Last;
2.7.10.3. Modificando Dados no Dataset Os métodos mostrados na Tabela 18, abaixo, habilitam uma aplicação para inserir, atualizar e deletar dados no dataset . Método Append
Descrição Comfirma qualquer dado pendente e move um registro em branco para o final do dataset, e coloca o dataset em estado de Insert.
83
Cancel Delete DeleteTable Edit EmptyTable Insert
Cancela a operação corrente e coloca o dataset em estado de Browse. Apaga o registro corrente e coloca o dataset em estado de Browse. Apaga uma tabela Coloca o dataset em estado de edição. Esvazia uma tabela. Confirma qualquer dado pendente, e coloca o dataset em estado de inserção. Tentativa para confirmar um registro novo ou alterado. Se sucesso, o dataset e colocado em estado de Browse; se insucesso, o dataset fica no estado corrente. Atualiza a visão do banco de dados.
Post Refresh
Tabela 18: métodos para modificar um dataset
2.7.10.4. Lendo Valores do Campo Existem algumas maneiras de ler dados de um dataset, algumas delas encontram-se no Exemplo 32. Edit1.text := Table1Nome_Clie.asstring; Edit1.text := Table1.Fields[1].asstring; Edit1.text := Table1.FieldByName(‘Nome_Clie’).asstring;
Exemplo 32: formas de ler dados
Para associar outros tipos de campos, que não texto, a uma caixa de edição (que só aceita valores do tipo string), devemos utilizar propriedades de conversão do componente TField: AsBoolean, AsDataTime, AsFloat (Real), AsInteger, AsString. Para atribuir valores aos campos de um dataset , o procedimento é o mesmo, só que no sentido inverso, desde que a tabela esteja em modo de edição ou inserção.
2.8. Conexão do Delphi com Interbase/Firebird O
Delphi
oferece
acesso
direto
aos
bancos
de
dados
Interbase/Firebird, o que torna as operações mais rápidas e seguras. A paleta de
84
componentes responsável pela interação com bancos de dados Interbase/Firebird é a “InterBase”, como é exibido na figura abaixo.
Figura 22: componentes InterBase
2.8.1. Montando uma Conexão Para estabelecer uma conexão com o banco de dados, precisaremos dos componentes: IBDatabase e IBTransaction. O componente IBDatabase tem como função fazer a conexão com o banco. Ele possui uma janela que facilita sua configuração, como visto na Figura 23. Nela, iremos localizar o banco de dados que iremos nos conectar, definir o User Name e Password, que no Interbase/Firebird tem como padrão sysdba e masterkey respectivamente, escolher o Character Set em que o banco de dados foi criado e desmarcar a opção de exibir o Login Prompt. Confirmando essas informações, toda a configuração deste componente estará concluída. Além da configuração feita neste editor, é necessário definir a propriedade default transaction que fará a associação do IBDatabase ao IBTransaction.
85
Figura 23: propriedades do banco de dados
O componente IBTransaction tem como função controlar as transações das execuções dos comandos SQL no banco de dados. Da mesma forma, teremos uma janela para facilitar a configuração do componente, oferecendo quatro tipos de configurações de transação, como é exibido na Figura 24. Desejando, pode-se definir outros parâmetros de configurações, mas vamos nos ater em explicar os tipos de configuração padrão oferecidos nesta janela: •
Snapshot: por default esta configuração define os parâmetros concurrency e nowait, o que significa que as transações
estarão cientes das outras transações e não irão esperar que os locks nos registros afetados pelas outras transações sejam liberados, retornando um erro quando isto ocorrer. •
Read Committed: esta configuração define os parâmetros read_committed, rec_version e nowait . Assim a transação
86
lerá as mudanças feitas pela transação corrente, poderá ler as informações mais recentes das transações já confirmadas e não irá esperar pela liberação dos registros em lock . •
Read-Only Table Stability: define os parâmetros read e consistency . Isso irá fazer com que a transação leia uma
tabela específica e bloqueie as demais transações. •
Read-Write Table Stability: define os parâmetros write e consistency . Isso irá fazer com que a transação possa ler e
escrever em uma tabela específica e bloqueie as demais transações.
Figura 24: propriedades das transações
2.8.2. Acessando Dados Para acessar e manipular dados das tabelas podemos utilizar os componentes da guia Interbase, que são exibidos na Tabela 19, abaixo: Imagem
Nome IBTable
IBQuery IBDataSet
Descrição É usado para exibir informações de uma única tabela ou view . Se tratando de aplicação Cliente/Servidor não é aconselhado sua utilização por ele sempre trazer todas as colunas e todos os registros quando for ativado. Fornece acesso somente leitura para uma seleção de informações, podendo acessar várias tabelas. Para possibilitar alterações nos dados é necessário associar este componente com TIBUpdateSQL É o componente ideal para ser associado ao DataSource dos componentes Data-Aware (TDBGrid, TDBEdit...).
87
IBSQL
É o componente mais rápido para executar comandos SQL. Não é possível utiliza-lo com componentes Data-Aware e quando utilizado em consultas de seleção é unidirecional.
Tabela 19: componentes InterBase
2.8.2.1. Utilizando o IBDataSet O IBDataSet é utilizado tanto para o acesso como para a manipulação das informações em base de dados Interbase/Firebird. Para utilizá-lo devemos alterar as seguintes propriedades: •
Database: associando a um TIBDatabase;
•
SelectSQL: apertando no botão com reticências que aparece no Object Inspector aparecerá a janela que é exibida na Figura 25. Dando um duplo clique sobre a tabela e em seguida sobre os campos que se deseja consultar, o código SQL será preenchido;
Figura 25: editor de SQL SELECT
88
•
Demais SQL´s: para preencher os comandos SQL´s de update , insert e delete, o próprio componente oferece um
gerador de SQL. Para utilizá-lo, deve-se apertar com o botão direito sobre ele e clicar sobre DatasetEditor. Assim, surgirá a janela que é mostrada na Figura 26. Os botões que aparecem nesta janela têm as seguintes funções: - Get Table Fields - preencherá a lista de Key Fields e Update Fields com todos os campos da tabela do banco de dados; - Dataset Defaults - preencherá a lista de Key Fields e Update Fields com os campos presentes no SelectSQL; - Select Primary Keys - seleciona o campo que é chave na tabela; - Generate SQL – cria os comandos SQL usando as informações de Key Fields e Update Fields; •
Fields: para facilitar o acesso aos campos do dataset e para possibilitar a conexão com alguns componentes data-aware, é necessário criar os fields. Para isto, deve-se dar um duplo clique sobre o componente, apertar com o botão direito e clicar em Add field, selecionar os campos que se deseja adicionar e apertar em Ok.
89
Figura 26: gerador de SQLs •
Active: esta propriedade, quando alterada para true, irá executar o método Open. Desta forma no momento que desejar manipular qualquer informação por este componente, esta propriedade deverá estar True.
Observação 1: Para atualizar o resultado da consulta, deve-se efetuar os métodos Close seguido do Open. Observação 2: Para que as demais transações possam ver as informações alteradas sem que tenham que utilizar o método Commit da transação (que fecha todos os componentes), deve-se utilizar o método IBDatabase.ApplyUpdates([IBDataset]);
2.8.2.2. Utilizando o IBSQL Como já foi dito, o IBSQL tem como função executar comandos SQL. No Exemplo 33 é mostrado como utilizá-lo juntamente com o controle de transação e de exceção. Ao chamar esta função, deve-se passar como parâmetro 90
a ação que ela deve executar, seja ela alteração (update ), inserção (insert ) ou exclusão (insert ), e esta retornará True quando executada corretamente e False quando ocorrer algum erro. function TfmdmAplicacao.ExecutaSQL(acao: string ): boolean; begin result:=true; IBSQL.SQL.Text := acao;
try if IBTransaction.Active then IBTransaction.Commit; IBTransaction.StartTransaction; IBSQL.ExecQuery; IBTransaction.Commit;
except on E: exception do begin result:=false; IBTransaction.Rollback; MessageBox(0,PChar('Não foi possível executar o script:' + #13 + ação + #13 + 'Mensagem: ' + E. Message ), 'Erro', MB_OK+MB_ICONERROR); ; end ; end ; end
Exemplo 33: controle de transação e IBSQL
91
3. METODOLOGIA Para atingir o objetivo almejado no início do estágio, que era desenvolver os sistemas Patho Control e Cyto Control, foram utilizadas como fonte de pesquisa as anotações de aula de disciplinas como banco de dados e linguagem de programação, livros sobre Delphi, guia do desenvolvedor do componente ReportBuilder e, evidentemente, a Internet, através principalmente do site de busca google. Foram utilizados os seguintes softwares no decorrer do estágio: Windows 98 segunda edição: sistema operacional da Microsoft amplamente utilizado por sua praticidade; Delphi 5: ambiente de desenvolvimento integrado criado pela Borland que utiliza a linguagem Pascal e fornece um ambiente simples e intuitivo para o desenvolvimento de aplicações para plataforma Windows; componente Report Builder: componente que se integra ao Delphi para a criação de relatórios, e que possui uma grande quantidade de recursos que o Quick Reports, componentes que o Delphi já traz consigo, não oferece; e, Banco de dados MS Access 2000: apesar de não se tratar de um banco de dados confiável e não ser recomendado para aplicações comerciais, o Access é de simples instalação e manipulação, possibilitando que o próprio usuário final possa manipular seus dados.
92
4. RESULTADOS O objetivo do estágio foi de fazer melhorias nos sistemas Patho Control, sistema de elaboração e emissão de laudos e gerenciamento de laboratórios de Anatomia Patológica, e Cyto Control, sistema de elaboração e emissão de laudos e gerenciamento de laboratórios de Citopatologia. Apesar desses sistemas já estarem em fase de manutenção, havia a necessidade de aumentar a velocidade de implementações e de realizar mudanças exigidas por muitos usuários espalhados por todo o Brasil. Ambos os sistemas eram desenvolvidos em Delphi 5 e utilizavam o banco de dados MS Access 2000. A migração para outro banco de dados era uma necessidade para muitos clientes já que, ao atingir um determinado número de registros (quantidade relativamente pequena), o arquivo do banco de dados corrompia e tornava o sistema extremamente lento. Fazendo um estudo sobre os SGBD existentes, deu-se preferência a SGBD gratuitos, já que o custo das licenças do banco de dados para os clientes seria maior do que com o próprio sistema. Entre os bancos analisados, o Firebird se destacou por sua velocidade e estreita ligação com o Delphi. Para conhecer melhor o sistema e seu propósito foi necessária uma visita a um de seus usuários e uma boa leitura de documentação disponível sobre ele. Dessa forma, poder-se-ia adquirir uma visão mais ampla do sistema em funcionamento. Durante todo o estágio, registrei, diariamente, as atividades que iam sendo realizadas (relatadas a seguir), o que facilitou a elaboração dessa seção do relatório. 93
A primeira tarefa foi implementar um registro de ponto , para controlar melhor a entrada e saída de funcionários. Esse módulo do sistema foi criado como uma aplicação independente, sendo posteriormente acoplado ao Patho Control por Zalkind, o supervisor do estágio. Essa atividade foi desenvolvida entre os dias 3/5/01 a 9/5/01. A Figura 27 a seguir mostra a interface desenvolvida para tal aplicação e um exemplo de relatório que poderia ser obtido com a sua utilização.
Figura 27: ferramenta de ponto
A tarefa seguinte envolveu a criação de um ambiente para o usuário final de criação de relatórios, chamado de “Fábrica de Relatórios”, aproveitando facilidades oferecidas pelo componente de relatório do Report Builder. Após estudar o guia do desenvolvedor do componente foi criada essa nova ferramenta, 94
cuja interface pode ser vista na Figura 28. Essa atividade se deu entre os dias 10/5/01 e 28/5/01.
Figura 28: fábrica de relatórios
Devido à necessidade de melhorar a ferramenta de pesquisa, muito aquém do solicitado pelos usuários, minha atividade seguinte foi aperfeiçoá-la, aumentando sua facilidade de uso e suas funcionalidades, com, inclusive, a possibilidade de exibição de relatórios. O período de realização foi do dia 30/5/01 até o dia 4/6/01. A Figura 29 mostra a nova interface da ferramenta de pesquisa.
95
Figura 29: ferramenta de pesquisa
Outra realização no estágio foi a criação de uma ferramenta que possibilitasse transportar dados (Figura 30), seja entre laboratórios, entre o laboratório e a casa dos médicos, ou entre o laboratório e seus postos de coleta. Por sua aplicação diversificada, a complexidade dessa atividade foi bastante alta, consumindo praticamente metade do tempo do estágio. Essa atividade se deu entre os dias 1/6/01 e 29/8/01.
96
Figura 30: exportação e importação de informações
Já próximo ao fim do estágio, foi criado uma ferramenta para facilitar o gerenciamento dos bancos de dados (Figura 31). Ela era capaz de realizar backup e restaurar o banco, além de fazer a manutenção, compactando e corrigindo os bancos MS Access. Esta tarefa foi realizada entre os dias 30/8/01 e 3/9/01.
Figura 31: gerenciador de backup e manutenção do banco de dados
97
5. CONCLUSÃO Durante o decorrer do estágio, foi cumprido o objetivo tanto da empresa, que necessitava que seus produtos passassem por modificações, como do estagiário, que precisava conhecer a realidade de uma empresa de tecnologia e aprimorar seus conhecimentos.
98
6. RECOMENDAÇÕES E SUGESTÕES O conhecimento teórico obtido no decorrer do curso, tendo em vista sua grade curricular bastante abrangente, foi bastante útil. Mesmo disciplinas que aparentemente não teriam relação com desenvolvimento de software, como é o caso de “Manutenção de Computadores”, foram essenciais para a efetividade da realização do estágio. A impressionante rapidez e o dinamismo da informática, com o constante surgimento de novas e diferentes tecnologias, são pontos que dificultam a definição do conteúdo de diversas disciplinas. Apesar disso, deve-se sempre procurar introduzir uma visão de mercado dentro de cada disciplina. Dentro de seu conteúdo programado, seria interessante fornecer uma visão das necessidades do mercado: o que está sendo mais utilizado, quais as tendências e, inclusive, dando foco em soluções gratuitas que não só são uma realidade, como também, uma forte tendência em todos os setores da infor mática. O curso de Tecnologia em Informática superou minhas expectativas, mostrando-se bem atualizado, um ponto crucial na área da computação; com uma exposição prática, que falta em cursos de graduação; e de uma organização impressionante, o que se contrapõe a realidade de outras instituições de ensino.
99
REFERÊNCIAS BIBLIOGRÁFICAS YONG, Chu Shao. Banco de dados. São Paulo: Atlas, 1988. SETZER, Valdemar W. Banco de dados. 3ª ed. São Paulo: Edgard Blucher, 1995. MACHADO, Felipe; ABREU, Maurício. Projeto de banco de dados. 2ª ed. São Paulo: Érica, 1996. CHEN, Peter. Modelagem de dados: a abordagem entidade-relacionamento para projeto lógico. São Paulo: McGraw-Hill, 1990. CANTU, Marco. Dominando o Delphi – A Bíblia. São Paulo: Makron Books, 2001. BLUE, Ted; KASTER, John; LIEF, Greg; SCOTT, Loren. Desenvolvendo bancos de dados em Delphi. São Paulo: Makron Books,1997. FACUNTE, Emerson. Delphi 5: desenvolvendo aplicações cliente/servidor. Rio de Janeiro: Brasport,1999. IBPhoenix. What is Firebird?. Disponível em: Acesso em: 16 set de 2004. Borland. Interbase. Disponível em: Acesso em: 16 set de 2004. LOZANO, Fernando. Firebird o sucessor do Interbase. Disponível em:. Acesso em: 21 set de 2004. CARDOSO, Rodrigo Aparecido. Conhecendo o Firebird. Disponível em: Acesso em: 21 set de 2004. SANTANA, Gladiston. Firebird Classic x SuperServer. Disponível em: < http://www.firebase.com.br/cgi-bin/firebase.cgi/artigo?ID=949> Acesso em: 21 set de 2004.
100
ANEXO A
Plano de Estágio
101
