Ferramenta de Gerenciamento de Metadados para BD Oracle.pdf
80
-
Upload
lourival-silva-jr -
Category
Documents
-
view
10 -
download
1
Transcript of Ferramenta de Gerenciamento de Metadados para BD Oracle.pdf
UNIVERSIDADE REGIONAL DE BLUMENAU
CENTRO DE CIÊNCIAS EXATAS E NATURAIS
CURSO DE CIÊNCIAS DA COMPUTAÇÃO – BACHARELADO
FERRAMENTA DE GERENCIAMENTO DE METADADOS
PARA BANCO DE DADOS ORACLE
CHARLES RISTOW
BLUMENAU2007
2007/2-06
CHARLES RISTOW
FERRAMENTA DE GERENCIAMENTO DE METADADOS
PARA BANCO DE DADOS ORACLE
Trabalho de Conclusão de Curso submetido à Universidade Regional de Blumenau para a obtenção dos créditos na disciplina de Trabalho de Conclusão de Curso II do curso de Ciências da Computação — Bacharelado.
Profª. Joyce Martins, Mestre - Orientadora
BLUMENAU2007
2007/2-06
FERRAMENTA DE GERENCIAMENTO DE METADADOS
PARA BANCO DE DADOS ORACLE
Por
CHARLES RISTOW
Trabalho aprovado para obtenção dos créditos na disciplina de Trabalho de Conclusão de Curso II, pela banca examinadora formada por:
______________________________________________________Presidente: Profª. Joyce Martins, Mestre – Orientadora, FURB
______________________________________________________Membro: Prof. Alexander Roberto Valdameri, Mestre, FURB
______________________________________________________Membro: Prof. Adilson Vahldick, Especialista, FURB
Blumenau, 21 de Novembro de 2007
Dedico este trabalho a todas as pessoas que sempre me incentivaram, especialmente ao meu avô paterno, meu pai e minha mãe.
AGRADECIMENTOS
A Deus, pela minha vida.
À minha família, que sempre me apoiou.
À minha orientadora Joyce Martins, pelo incentivo, pela cobrança e por ter acreditado
na conclusão deste trabalho.
À Operacional Têxtil Ltda. pela compreensão em função de todo o tempo dedicado a
elaboração do trabalho.
Aos meus amigos e professores que de alguma forma contribuíram para a conclusão
deste trabalho.
O forte é mais forte sozinho.
Adolf Hitler
RESUMO
Este trabalho tem como objetivo apresentar o desenvolvimento de uma ferramenta que auxilia o processo de desenvolvimento de sistemas. A ferramenta permite o gerenciamento do dicionário de dados de um banco de dados Oracle gerando scripts SQL para as alterações nas definições dos dados. Também possibilita a geração de código fonte para classes de acesso a dados. A criação do código fonte é realizada de forma dinâmica, possibilitando gerar código para diversas linguagens a partir de templates.
Palavras-chave: Oracle. Geração de código. Templates.
ABSTRACT
This work has an objective to present the specification and implementation of support tool to software development. The tool is able to execute metadata management in Oracle databases using SQL scripts for changes manipulation. Also, the tool allows code generation to build data access layer. Code generation is performed with dynamic behavior supporting any programming language with template use.
Key-words: Oracle. Code generation. Templates.
LISTA DE ILUSTRAÇÕES
Figura 1 – Entrada e saída de um gerador de classes ...............................................................21
Quadro 1 – Principais características dos trabalhos correlatos.................................................25
Figura 2 – Visão geral da ferramenta .......................................................................................26
Quadro 2 – Requisitos funcionais.............................................................................................28
Quadro 3 – Requisitos não-funcionais .....................................................................................28
Figura 3 – Diagrama de casos de uso .......................................................................................29
Quadro 4 – Definições regulares e tokens ................................................................................30
Quadro 5 – Gramática e ações semânticas ...............................................................................30
Quadro 6 – Template para linguagem Object Pascal................................................................32
Quadro 7 – Código de saída esperado ......................................................................................32
Quadro 8 – Caso de uso Gerar código ...................................................................................33
Figura 4 – Diagrama de classes do motor de templates ...........................................................34
Quadro 9 – Métodos da classe TTemplateEngine ...................................................................35
Figura 5 – Interface do motor de templates ..............................................................................35
Figura 6 – Diagrama de seqüência do motor de templates.......................................................36
Quadro 10 – Trecho do método para geração de código fonte.................................................38
Quadro 11 – Caso de uso Editar Metadados .........................................................................40
Quadro 12 – Caso de uso Acessar Configurações ...............................................................41
Figura 7 – Diagrama de classes do módulo de edição de metadados.......................................42
Quadro 13 – Principais métodos da classe TEdicao..................................................................43
Figura 8 – Diagrama de classes do módulo de configuração de parâmetros............................43
Quadro 14 – Métodos da classe TConfiguracoes ...................................................................43
Figura 9 – Diagrama de classes do editor de metadados e do gerador de código ....................44
Quadro 15 – Principais métodos de controle de interface ........................................................45
Figura 10 – Diagrama de seqüência para edição do metadados ...............................................46
Figura 11 – Diagrama de seqüência do caso de uso Acessar Configurações ......................47
Quadro 16 – Trecho do código utilizado para carga dos parâmetros .......................................48
Quadro 17 – Método de conexão com o banco de dados .........................................................49
Quadro 18 – Método para carga do metadados do banco de dados .........................................50
Quadro 19 – Método para salvar dicionário em arquivo XML................................................50
Figura 12 – Tela principal da ferramenta .................................................................................51
Figura 13 – Módulo de configuração de parâmetros................................................................52
Figura 14 – Janela de escolha do arquivo de template .............................................................53
Figura 15 – Lista de erros do arquivo de template ...................................................................54
Figura 16 – Módulo do editor de dicionário.............................................................................55
Figura 17 – Janela de escolha do arquivo do dicionário...........................................................56
Figura 18 – Estrutura do dicionário de dados...........................................................................57
Figura 19 – Detalhes da tabela MAQ_PROD ................................................................................58
Figura 20 – Edição do campo...................................................................................................59
Figura 21 – Inclusão do novo campo .......................................................................................60
Figura 22 – Detalhes dos índices da tabela...............................................................................61
Figura 23 – Edição do índice....................................................................................................61
Figura 24 – Módulo do gerador de código ...............................................................................62
Figura 25 – Janela de seleção do arquivo do dicionário...........................................................63
Figura 26 – Tabelas para geração de código ............................................................................64
Figura 27 – Seleção do diretório para geração de código.........................................................64
Figura 28 – Seleção das tabelas para geração de código..........................................................65
Figura 29 – Geração de código concluída ................................................................................66
Figura 30 – Diagrama de casos de uso do sistema ...................................................................67
Figura 31 – Modelo entidade-relacionamento das tabelas .......................................................67
Quadro 20 – Script SQL para criação da tabela PRODUTO ........................................................68
Quadro 21 – Código original da classe TCadMaquina..............................................................68
Quadro 22 – Métodos da classe TCadastroGenerico .............................................................69
Figura 32 – Tela de cadastro de produtos.................................................................................69
Figura 33 – Tela de programação das ordens de produção ......................................................70
Quadro 23 – Trecho do código da tela de cadastro de produtos...............................................71
Quadro 24 – Comparativo das principais características das ferramentas ...............................72
Quadro 25 – Template para linguagem Java ............................................................................77
Quadro 26 – Código de saída esperado ....................................................................................77
LISTA DE SIGLAS
ANSI - American National Standards Institute
BNF - Backus Naur Form
CASE - Computer- Aided Software Engineering
CSV - Comma-Separated Values
DDL - Data Definition Language
DER – Diagrama E ntidade-Relacionamento
DML - Data Manipulation Language
GLC - Gramática Livre de Contexto
HTML - HyperText Markup Language
RAD - Rapid Application Development
SGBD - Sistema Gerenciador de Banco de Dados
SQL - Structured Query Language
UML - Unified Modeling Language
XML - eXtensible Markup Language
SUMÁRIO
1 INTRODUÇÃO..................................................................................................................13
1.1 OBJETIVOS DO TRABALHO ........................................................................................14
1.2 ESTRUTURA DO TRABALHO ......................................................................................14
2 FUNDAMENTAÇÃO TEÓRICA....................................................................................16
2.1 ESTRUTURA DE DADOS DE UM SGBD.....................................................................16
2.2 GERADOR DE CÓDIGO.................................................................................................18
2.3 TRABALHOS CORRELATOS........................................................................................22
2.3.1 Power Designer ...............................................................................................................23
2.3.2 Rational Rose ..................................................................................................................23
2.3.3 Oracle SQL Developer....................................................................................................23
2.3.4 Ferramenta para a geração automática de código Java ...................................................24
2.3.5 Gerador de código baseado em dicionário de dados.......................................................24
2.3.6 Comparações entre as ferramentas..................................................................................25
3 DESENVOLVIMENTO....................................................................................................26
3.1 VISÃO GERAL.................................................................................................................26
3.2 ETAPAS PARA DESENVOLVIMENTO DA FERRAMENTA.....................................27
3.3 LEVANTAMENTO DOS REQUISITOS.........................................................................27
3.4 ESPECIFICAÇÃO DA LINGUAGEM DO MOTOR DE TEMPLATES .........................29
3.5 ESPECIFICAÇÃO DO MOTOR DE TEMPLATES .........................................................32
3.5.1 Casos de uso....................................................................................................................33
3.5.2 Diagrama de classes ........................................................................................................33
3.5.3 Diagrama de seqüência ...................................................................................................36
3.6 IMPLEMENTAÇÃO DO MOTOR DE TEMPLATES .....................................................36
3.7 ESPECIFICAÇÃO DO EDITOR E DO GERADOR DE CÓDIGO ................................39
3.7.1 Casos de uso....................................................................................................................39
3.7.2 Diagrama de classes ........................................................................................................41
3.7.3 Diagrama de seqüência ...................................................................................................46
3.8 IMPLEMENTAÇÃO DO EDITOR E DO GERADOR DE CÓDIGO.............................47
3.8.1 Técnicas e ferramentas utilizadas....................................................................................47
3.8.2 Implementação ................................................................................................................48
3.9 OPERACIONALIDADE DA IMPLEMENTAÇÃO........................................................51
3.10ESTUDO DE CASO .........................................................................................................66
3.11RESULTADOS E DISCUSSÃO ......................................................................................71
4 CONCLUSÕES..................................................................................................................73
4.1 EXTENSÕES ....................................................................................................................74
REFERÊNCIAS BIBLIOGRÁFICAS .................................................................................75
APÊNDICE A – Exemplo de template e código de saída para a linguagem Java.............77
APÊNDICE B – Aplicação da ferramenta no desenvolvimento de um sistema ...............78
13
1 INTRODUÇÃO
O mercado exige cada vez mais qualidade dos produtos e serviços oferecidos pelas
empresas de informática. A cada dia que passa, essas empresas procuram aperfeiçoar o
desenvolvimento de softwares através da pesquisa de métodos e/ou ferramentas que venham a
facilitar esse processo. Esse esforço pela contínua evolução tecnológica torna-se transparente
ao cliente final, pois seu único interesse são as vantagens que o produto oferecido pode trazer
às suas tarefas cotidianas.
Desenvolver sistemas é uma tarefa de alta complexidade e suscetível a erros. Para
evitar erros e melhorar a produtividade, as empresas vêm aplicando conceitos e metodologias
propostas pela Engenharia de Software. Como as empresas necessitam ser competitivas, o
prazo de entrega não deve ser longo e a organização é um fator que contribui para o sucesso
da empresa, sendo que a utilização de métodos, como por exemplo o RAD, têm facilitado tal
tarefa.
O RAD é um método para implementação de software interativo e incremental que
enfatiza um ciclo de trabalho curto e propõe a reutilização de código. A reutilização de
código, além de melhorar o índice de produtividade, tem como vantagens a redução de custos
e tempo. Obtém-se flexibilidade na estrutura do software facilitando sua manutenção e
evolução. Como aplicação de reutilização cita-se a utilização de classes de acesso a banco de
dados. Em uma arquitetura de três camadas, essas classes são responsáveis pela inclusão,
edição, consulta e exclusão, além de efetuarem a comunicação com a camada de regras de
negócio. A manutenção dessas classes despende de um trabalho repetitivo para o
desenvolvedor quando a estrutura1 do banco de dados sofre alterações devido às mudanças
nos requisitos do sistema.
Para auxiliar nesse trabalho de manutenção, é proposto o desenvolvimento de uma
ferramenta que gerencie as alterações do metadados de um banco de dados e disponha de um
gerador de código para as classes de acesso ao banco de dados de acordo com templates
previamente formatados. Como o código de saída depende unicamente do formato dos
templates, pode-se dizer que poderão ser gerados arquivos para qualquer linguagem de
programação compatível com o tipo de banco de dados contemplado. Inicialmente a
ferramenta contempla as linguagens Object Pascal e Java para a geração de classes e o banco
1 Estrutura, dicionário de dados e metadados são utilizados no decorrer do texto como sinônimos.
14
de dados Oracle para gerenciamento do dicionário de dados. O processo de gerenciamento é
realizado através de um editor que identifica a estrutura do banco de dados e permite
alterações na mesma, gerando os scripts SQL necessários para sua manutenção. O gerador de
código, a partir do metadados do banco de dados e dos templates dos arquivos de saída, cria
as classes de acesso. Adicionalmente foi construído um motor de templates para auxiliar na
tarefa de geração de código, uma vez que não foi encontrado um motor de templates
adequado para ser utilizado com a linguagem Object Pascal com a qual a ferramenta foi
implementada.
1.1 OBJETIVOS DO TRABALHO
O objetivo deste trabalho é desenvolver uma ferramenta para auxiliar no processo de
manutenção do dicionário de dados de um banco de dados Oracle e, conseqüentemente, das
alterações necessárias para a manutenção do software que utiliza o banco.
Os objetivos específicos do trabalho são:
a) disponibilizar um editor para criar uma estrutura de dados para banco de dados
Oracle ou efetuar alterações na mesma;
b) construir um motor de templates;
c) utilizar templates para formatação do código de saída para a linguagem Object
Pascal, Java e SQL ANSI;
d) gerar código de saída SQL para as alterações no metadados do banco de dados;
e) gerar código de saída para as linguagens Object Pascal e Java para
desenvolvimento de softwares.
1.2 ESTRUTURA DO TRABALHO
Este trabalho está estruturado em quatro capítulos. No segundo capítulo são
apresentados alguns aspectos teóricos estudados para o desenvolvimento do trabalho. São
abordados temas como estrutura de dados de um SGBD e geradores de código. É apresentada
uma breve descrição e são enumeradas algumas características de bancos de dados
15
relacionais, mais especificamente do Oracle, dando-se ênfase para os arquivos de metadados.
Também são apresentados alguns conceitos a respeito de geradores de código e suas
aplicações, além de discutir a importância da utilização de motores de templates.
Adicionalmente são apresentados trabalhos correlatos ao trabalho proposto.
No terceiro capítulo são descritos os passos seguidos para o desenvolvimento do
trabalho. Primeiro é apresentada uma descrição geral da ferramenta e seus requisitos. Na
seqüência é apresentada a especificação da linguagem do motor de templates, do motor de
templates, do editor e do gerador de código. Posteriormente é discutida a implementação da
ferramenta e os resultados obtidos.
Para concluir, no quarto capítulo são apresentadas as conclusões e algumas sugestões
para continuidade da ferramenta.
16
2 FUNDAMENTAÇÃO TEÓRICA
Este capítulo apresenta alguns conceitos relevantes ao desenvolvimento deste trabalho.
São apresentadas algumas características de bancos de dados relacionais e realizado um
estudo sobre o dicionário de dados, dando-se ênfase para o banco de dados Oracle. É
apresentada uma breve descrição sobre a utilização de comandos SQL para manipulação e
consulta da estrutura de dados. Também são consideradas as vantagens da aplicação de
ferramentas como geradores de código e motores de templates e discutidas algumas técnicas
de análise de linguagem. Finalmente, são analisadas algumas características de trabalhos
correlatos ao trabalho proposto.
2.1 ESTRUTURA DE DADOS DE UM SGBD
Um banco de dados é um conjunto de dados2 estruturados e organizados. Cox (1995, p.
2) afirma que um “banco de dados estritamente refere-se a uma coleção de informações”.
Finalmente pode-se descrever banco de dados como um sistema informatizado para
armazenamento de informações onde usuários podem executar operações como busca,
inclusão, alteração e exclusão de registros. Essas operações são gerenciadas através de um
programa de computador, o SGBD. Segundo Date (1990, p. 5), “um SGBD é basicamente um
sistema de manutenção de registros por computador, ou seja, um sistema cujo objetivo global
é manter as informações e torná-las disponíveis quando solicitadas”.
Um banco de dados divide-se em dois componentes principais: o hardware,
responsável pelos volumes de armazenamento, e o software, responsável pelo gerenciamento
das operações, ou seja, o SGBD. O SGBD é de longe o componente mais importante de todo
o sistema (DATE, 1990, p. 6-7). Adicionalmente, Date (1990, p. 5) cita que “os recursos
oferecidos por qualquer sistema são determinados, até certo ponto, pelo tamanho e capacidade
da máquina subjacente”, o que reflete no conjunto de hardware e software utilizados, somado
à capacidade do computador no qual estão instalados.
Outro conceito sobre banco de dados está relacionado com modelos de dados. Há três
2 Dados e informações são tratados no texto como sinônimos.
17
tipos de modelos de dados: o conceitual, o lógico e o físico. O modelo conceitual é uma
representação dos requisitos de um negócio independente de qual banco de dados será
utilizado. O modelo lógico é a representação do modelo conceitual em uma estrutura de banco
de dados mais simplificada, e o modelo físico é a implementação do banco de dados, ou seja,
efetivamente quais entidades serão criadas no banco de dados e quais são seus
relacionamentos.
Para entender um pouco mais sobre banco de dados, é necessário saber de que forma
as informações são armazenadas, e isso depende do tipo de banco de dados utilizado. Um dos
modelos de dados mais utilizado atualmente é o modelo relacional. Nesse modelo as
informações estão organizadas em tabelas, mais precisamente tabelas relacionais, compostas
de colunas que representam os atributos e de linhas que representam os valores
correspondentes a cada registro inserido na tabela. Pode-se dizer que no caso de bancos de
dados relacionais, a informação é percebida pelo usuário como tabelas. Date (1990, p. 52)
explica que “as tabelas são a estrutura lógica em um sistema relacional, não a estrutura física.
No nível físico, de fato, o sistema é livre para armazenar os dados do modo que preferir”.
Nesse caso, a estrutura lógica são os modelos de dados conceitual e lógico.
Porém, para acessar as informações armazenadas é necessário saber de que forma elas
estão organizadas. O banco de dados contém definições sobre os objetos armazenados no
sistema. Essas definições são chamadas de dicionário de dados ou simplesmente metadados.
Metadados são dados que descrevem outros dados ou objetos. Date (1990, p. 173) afirma que
“Metadados pode ser chamado de descritores relativos a diversos objetos do interesse do
próprio sistema.” Os tipos de informações contidas em um dicionário de dados são:a) definições de colunas que compõem cada tabela;b) restrições de integridade impostas sobre relações;c) as informações de segurança (qual usuário tem o direito de realizar qual
operação sobre qual tabela);d) definições de outros elementos estruturais de um banco de dados, como
visualizações e domínios definidos pelo usuário. (HARRINGTON, 2002, p. 79).
Em um banco de dados relacional, essas informações também são armazenadas em
tabelas, e essas tabelas têm nomes distintos conforme o SGBD (DATE, 1990, p. 59). No
banco de dados Oracle, por exemplo, as descrições a respeito das tabelas do banco e seus
atributos estão armazenados em várias tabelas. Porém é necessário ressaltar algumas tabelas
como: user_tables, user_tab_columns, user_indexes, user_ind_columns e
user_constraints. As tabelas user_tables e user_tab_columns contêm informações
sobre a estrutura das tabelas em si, isto é, nome e tipo de dados para cada campo. As tabelas
18
user_indexes e user_ind_columns contêm as informações sobre os índices de cada tabela e
os campos que fazem parte de cada índice. Finalmente a tabela user_constraints contém
informações a respeito de integridade de cada tabela, como por exemplo chave primária,
chaves estrangeiras e índices únicos. Essas informações podem ser consultadas com as
mesmas ferramentas utilizadas para consultas das demais relações de dados.
Para realizar tais consultas é utilizada a linguagem SQL. Segundo Date (1990, p. 71),
“SQL é a linguagem padrão para se lidar com bancos de dados relacionais, e é aceita por
quase todos os produtos no mercado”. Através da SQL, o usuário pode executar operações de
manipulação e definição de dados. As operações de manipulação são do tipo consulta,
inclusão, alteração e exclusão de dados. As operações de definição são aquelas que interferem
na estrutura do dicionário de dados do banco. Por exemplo, pode-se criar uma tabela ou
alterar o tipo de dado de uma coluna.
As alterações no dicionário de dados também são controladas pelo SGBD. Durante o
processo de alteração da estrutura das tabelas, o SGBD consulta o dicionário de dados com
objetivo de procurar restrições de integridade que podem ter sido colocadas previamente. Se
as restrições são atendidas, a alteração será efetuada, caso contrário, o SGBD retorna uma
mensagem de erro.
2.2 GERADOR DE CÓDIGO
Segundo Herrington (2003, p. 3), geração automática de código é escrever programas
que escrevem outros programas.Um gerador de código é uma ferramenta de software desenvolvida para a partir de um artefato de entrada flexível, gerar o código fonte de uma aplicação. Este código pode servir como base do desenvolvimento de uma aplicação ou simplesmente se tornar um protótipo. (LEAL, 2005, p. 22).
Gerador de código é uma das ferramentas CASE que presta apoio às atividades da
Engenharia de Software. O investimento de recursos na construção desse tipo de ferramenta
possibilita no futuro um ganho significativo de produtividade e redução do tempo e custo de
desenvolvimento de softwares. São perceptíveis as vantagens da utilização de geradores de
código, seja para gerar partes específicas do código ou código completo. Herrington (2003, p.
15-16) cita os principais benefícios da utilização de geradores de código:
19
a) produtividade: é obtida através da agilidade na geração de código massivo, seja
para projetos pequenos ou até mesmo com grandes quantidades de arquivos fonte;
b) qualidade: é alcançada através da padronização do código gerado e reutilização de
código. No caso de alterações no projeto, é necessário apenas alterar os templates e
gerar o código novamente;
c) consistência: como o código é padronizado, fica mais fácil a compreensão e
correções;
d) abstração: através de uma boa especificação de projeto, pode-se gerar código para
diferentes linguagens. Um modelo abstrato significa ganhos em portabilidade do
aplicativo, seja referente à linguagem, tecnologia ou plataforma.
Adicionalmente, Orsi (2006, p. 20) afirma que “deve-se levar em conta que erros no
projeto também são mais facilmente corrigidos utilizando-se um gerador de código. Em
códigos escritos à mão uma gama considerável de erros pode levar a re-codificação de todo o
projeto.”
No processo de desenvolvimento de software, existe a possibilidade de utilizar
geradores de código com diversas finalidades. Acerca da utilização de geradores de código, o
primeiro passo é verificar o problema existente e então decidir se a geração de código é a
solução adequada para a resolução desse problema. Geralmente geradores são aplicados
quando o tempo de desenvolvimento de determinadas tarefas é longo ou quando essa tarefa é
repetitiva e monótona (HERRINGTON, 2003, p. 17).
Na construção de um gerador de código, seja ele de qual tipo for, existem vários
critérios a serem verificados durante a especificação do projeto. Herrington (2003, p. 18)
descreve alguns dos critérios mais importantes que deverão ser analisados:
a) escopo do projeto: deve estar bem claro e definido o formato do código a ser
gerado e quais as limitações do gerador. Deve haver um planejamento para
aperfeiçoamento futuro de modo que a implementação inicial deve estar preparada
para receber as novas melhorias;
b) aplicação: deve-se definir em qual etapa do ciclo de desenvolvimento o gerador
deverá ser utilizado e se a utilização do gerador é uma solução temporária ou
definitiva;
c) manutenção: é necessário haver uma pessoa responsável pelas correções e
aperfeiçoamentos da ferramenta;
d) ferramentas: é preciso definir quais as ferramentas que serão utilizadas na
construção do gerador.
20
Outro detalhe a ser considerado é o tempo para o desenvolvimento do gerador.
Herrington (2003, p. 25) afirma que inicialmente é investido um tempo razoável de
desenvolvimento até que o gerador produza algum código útil. Durante a fase do projeto,
quando é especificado o escopo, é necessário atentar para o tipo de geração de código.
Herrington (2003, p. 28) descreve dois tipos de geradores de código: passivo e ativo. No
modelo passivo, o gerador de código produz um conjunto de código que posteriormente
poderá ser alterado, sem responsabilidade do gerador de código sobre as alterações realizadas.
E no modelo ativo, o gerador mantém responsabilidade sobre o código, podendo ser acionado
várias vezes para gerar sempre a mesma saída. Caso sejam necessárias alterações no código
de saída, é necessário alterar o template, ou em último caso, alterar o projeto do gerador.
Conforme o tipo de geração (ativa ou passiva), existem diversas aplicações para a
utilização de geração de código. Geradores de código do tipo passivo geralmente são
utilizados em wizards, enquanto os do tipo ativo são empregados como geradores de interface,
de classes de acesso a banco de dados ou de documentação, entre outros, pois as
possibilidades de aplicação desse tipo de ferramenta são ilimitadas. Herrington (2003, p. 35)
enfatiza que nunca deve-se alterar o código de saída a não ser que a geração foi utilizada
como objetivo de expansão do código3.
Dentre as várias opções anteriormente citadas, é conveniente destacar os geradores de
classes de acesso a banco de dados. Nesse modelo, o gerador deve ler uma definição abstrata
das tabelas existentes em um banco de dados e seus respectivos relacionamentos, o que é
suficiente para gerar um conjunto de classes. Tais definições geralmente são carregadas a
partir de arquivos. Dentre os vários formatos de arquivos existentes, normalmente é optado
por utilizar arquivos do tipo binário ou texto, como por exemplo arquivos separados por
vírgula (CSV) ou separados por marcação (XML). Herrington (2003, p. 191) cita algumas
vantagens para utilização desse tipo de geradores:
a) tempo de construção: dependendo do projeto, é possível implementar um gerador
de classes em pouco tempo hábil, o que economiza semanas de trabalho com
codificação manual;
b) definição abstrata: a utilização de definições abstratas de tabelas é importante para
obter sucesso na geração de código, pois elas são os parâmetros de entrada para o
gerador de código;
3 Expansão de código pode ser entendida como o aumento obtido a partir do código fonte original.
21
c) código repetitivo: a codificação de classes de acesso a banco de dados é um
trabalho estritamente repetitivo o que torna ideal a utilização de geradores de
código;
d) o banco de dados é a principal parte do sistema: após a criação do banco de dados e
a geração do código de acesso ao banco, torna-se fácil a implementação das outras
camadas da arquitetura do sistema.
A figura 1 ilustra a utilização de um gerador de classes no processo de geração de
código.
Fonte: adaptado de Herrington (2003, p.87).Figura 1 – Entrada e saída de um gerador de classes
Conforme ilustrado na figura 1, a partir dos parâmetros de entrada (definições e
templates), é gerado um arquivo de saída, a classe base. Na seqüência, a classe base é
derivada e ambas são compiladas para geração do aplicativo.
A partir de uma mesma definição abstrata é possível gerar códigos de saída distintos.
22
Essa flexibilidade na geração de código é obtida com a utilização de templates para
formatação do código de saída. Segundo Rocha (2005), “templates são arquivos que contém
[sic] variáveis e blocos especiais que serão dinamicamente transformados [...]”. São utilizados
para descrever uma estrutura de formatação ou seqüência de ações que devem ser seguidas
por um determinado programa. Herrington (2003, p. 38) descreve que a utilização de um
template significa manter a formatação do código separada da lógica como o código deve ser
gerado. Na geração de código fonte, os templates definem o layout do arquivo a ser gerado. O
layout do formato do arquivo pode conter código estático, que são estruturas fixas declaradas
pelo usuário, e código dinâmico, que será alterado pelo programa conforme os valores
correspondentes para cada identificador utilizado. O motor de templates é o responsável pela
identificação do código dinâmico e estático.
Finalmente, é importante ressaltar que para cada motor de templates é necessário
definir uma linguagem através da qual os templates deverão ser escritos. Uma linguagem é
um conjunto de palavras formadas por símbolos de um determinado alfabeto4 (PRICE;
TOSCANI, 2001, p. 17). É através dessa linguagem que os templates serão analisados léxica e
sintaticamente. A análise léxica deve identificar e classificar as seqüências de caracteres em
entidades ou tokens, ou seja, os símbolos básicos da linguagem (PRICE; TOSCANI, 2001, p.
7-9). Nesse processo são desprezados os comentários e os espaços em branco. A análise
sintática deve agrupar os tokens identificados pelo analisador léxico em estruturas sintáticas
(PRICE; TOSCANI, 2001, p. 9-11).
2.3 TRABALHOS CORRELATOS
Existem várias ferramentas disponíveis que auxiliam no processo de manutenção de
um banco de dados e geração de código compatível. Foi realizado um estudo com três das
principais ferramentas existentes no mercado: Power Designer, Rational Rose e Oracle SQL
Developer. Adicionalmente foram pesquisados dois trabalhos de conclusão de curso com
escopo similar ao do trabalho proposto. As ferramentas possuem funcionalidade semelhante
ao trabalho proposto, diferindo apenas em termos das linguagens nas quais foram
implementadas ou nas linguagens disponíveis para geração de código.
4 Alfabeto é um conjunto finito de símbolos (MENEZES, 1998, p. 21).
23
2.3.1 Power Designer
É uma ferramenta comercial desenvolvida pela Sybase para criação e gerenciamento
da estrutura de um banco de dados (SYBASE INC, 2007). Através do desenvolvimento de
modelos conceituais5 e físicos6, é possível gerar scripts SQL para diversos tipos de banco de
dados. A partir desses modelos, é possível gerar documentação da estrutura de um banco de
dados. Adicionalmente a ferramenta oferece algumas facilidades como opção de engenharia
reversa, para casos onde o banco de dados foi criado sem nenhum processo de modelagem, e
geração de classes Java, C++, C#, entre outras, com base em modelos orientados a objetos.
2.3.2 Rational Rose
É uma ferramenta CASE que auxilia o processo de desenvolvimento de softwares
orientados a objetos. O foco da ferramenta está na construção de diagramas UML para
modelagem e projeto de software. Além de auxiliar no processo de modelagem e análise de
sistema, a construção de diagramas permite a compreensão das regras de negócio e
identificação de problemas antes mesmo deles acontecerem (BOGGS; BOGGS, 2002, p. 27).
Adicionalmente pode-se construir um modelo de dados com suporte para geração de código,
documentação e também engenharia reversa. Rational Rose permite gerar classes para
linguagens como Object Pascal, Java, C++ e Visual Basic. É uma ferramenta comercial de
custo elevado.
2.3.3 Oracle SQL Developer
É um aplicativo que faz parte do pacote de ferramentas integradas com o SGBD da
5 Modelos conceituais são modelos com a estrutura lógica do banco, independente da especificação do SGBD e da forma de armazenar as informações.6 Modelos físicos são modelos com a estrutura que será definitivamente criada no banco de dados, considerando a forma de armazenamento e o tipo de SGBD.
24
Oracle e tem sua distribuição gratuita. Foi desenvolvido exclusivamente para simplificar o
processo de manipulação do banco de dados. É uma ferramenta gráfica para criação e
identificação da estrutura de dados, eliminando o moroso trabalho de efetivar as alterações
através de linhas de comando (ORACLE CORPORATION, 2006). A ferramenta tem suporte
para geração de scripts SQL para efetuar as alterações na estrutura de dados e também para
criação de consultas e relatórios, onde o usuário pode selecionar as tabelas e campos
desejados.
2.3.4 Ferramenta para a geração automática de código Java
Santos (2005) descreve uma ferramenta CASE para geração de código em Java que
importa informações do metadados do Oracle Designer. Para realizar tal tarefa, utiliza um
dicionário de dados para armazenar as definições das entidades, tabelas e módulos. O
aplicativo permite a construção de um projeto através da definição de diagramas. Os
diagramas possibilitam uma visão gráfica do modelo de dados, das estruturas dos módulos e
da hierarquia de chamada dos mesmos. As principais funcionalidades resumem-se à
construção de um projeto de banco de dados e geração de formulários compatíveis com a
linguagem Java permitindo realizar inclusão, edição, consulta e exclusão de registros.
2.3.5 Gerador de código baseado em dicionário de dados
Segundo Coelho (2006), o objetivo deste aplicativo é gerar código fonte para
aplicações web. O software permite gerar scripts SQL para a manipulação dos dados no banco
e também o código HTML para construir páginas dinâmicas e em tempo de execução. Através
da leitura de informações cadastradas em um dicionário de dados, são geradas páginas que
possibilitam inclusão, alteração e exclusão dos registros do banco de dados. A ferramenta
possibilita definir a forma como as páginas do sistema serão apresentadas, através de
informações que são armazenadas no dicionário de dados. Pode-se configurar para cada
atributo das tabelas as páginas onde o mesmo deverá aparecer, a descrição e a formatação.
Utiliza templates para definição do layout das páginas, o que traz uma certa facilidade na
25
manutenção, não sendo necessário alterar o código fonte da aplicação.
2.3.6 Comparações entre as ferramentas
Para uma melhor visualização das características presentes nos trabalhos correlatos,
abaixo segue um quadro comparativo (quadro 1).
Aplicativos
Características
Power Designer
Rational Rose
Oracle SQL
Developer
Santos (2005)
Coelho (2006)
diagramas UML S S N N Nsuporte a vários BD S S S N Sscripts SQL DDL7 S S S N Nscripts SQL DML8 N N S N Nengenharia reversa BD S S S S Sgeração de código fonte S S N S Sutilização de templates N N N N Ssuporte linguagem Object Pascal
N S N N N
suporte linguagem Java S S N S Nsuporte linguagem HTML N N N N Ssuporte linguagem C++ S S N N Ndistribuição gratuita N N S S S
Quadro 1 – Principais características dos trabalhos correlatos
7 DDL são scripts SQL para gerenciamento do metadados de um banco de dados.8 DML são scripts SQL para manipulação e consulta de dados em um banco de dados.
26
3 DESENVOLVIMENTO
Neste capítulo são apresentadas as etapas do desenvolvimento da ferramenta, um
exemplo de aplicação do código gerado na construção de um sistema e os resultados obtidos .
3.1 VISÃO GERAL
A partir da identificação do metadados de um banco de dados Oracle, a ferramenta
(EditDB) permite gerenciar a criação e manutenção do dicionário de dados do banco e
também facilitar o processo de desenvolvimento de softwares através da geração de código de
acesso à camada de dados. A figura 2 demonstra o funcionamento da ferramenta:
a) configuração dos parâmetros: o usuário configura o banco de dados, template e
tipo de geração;
b) pesquisa do metadados: a ferramenta acessa o banco de dados configurado e
carrega o dicionário de dados;
c) alterações do metadados: o usuário cria/altera tabelas, campos e índices;
d) geração de scripts SQL: a ferramenta gera código para alterar o banco de dados;
e) geração de código fonte: a partir de templates, a ferramenta gera classes de acesso
ao banco.
Figura 2 – Visão geral da ferramenta
Tanto para o gerenciamento de alterações na estrutura de um banco de dados como
27
para geração de código de um aplicativo a partir dessa estrutura, devem ser carregadas as
informações do metadados do banco. No caso de modificações na estrutura, após concluir as
alterações e gerar os scripts SQL, o usuário deve executar os scripts para efetivar as
alterações no banco de dados. Para a tarefa de gerar código para uma aplicação, após carregar
o dicionário, basta o usuário selecionar as tabelas para as quais deseja gerar código fonte.
Outro detalhe importante da ferramenta, é a divisão da mesma em três módulos:
configurações, editor de dicionário e gerador de código. Os módulos podem ser executados
separadamente, porém, é conveniente ressaltar que os módulos de edição e geração são
dependentes do módulo de configurações. Dessa forma, inicialmente é necessário configurar
os parâmetros para então na seqüência utilizar os módulos de edição de metadados e geração
de código.
3.2 ETAPAS PARA DESENVOLVIMENTO DA FERRAMENTA
A partir da análise dos critérios para a construção de um gerador de código citados no
capítulo anterior, este trabalho foi dividido nas seguintes etapas:
a) levantamento dos requisitos;
b) especificação da linguagem do motor de templates;
c) especificação do motor de templates através dos diagramas UML de casos de uso,
de classes e de seqüência;
d) implementação do motor de templates;
e) especificação do editor e do gerador de código através dos diagramas UML de
casos de uso, de classes e de seqüência;
f) implementação do editor e do gerador de código.
3.3 LEVANTAMENTO DOS REQUISITOS
A partir dos parâmetros de entrada, a ferramenta desenvolvida nesse trabalho é capaz
de gerar um ou mais arquivos de código fonte ou scripts SQL. Os parâmetros iniciais são:
arquivos de template (com o formato de saída desejado), configuração do banco de dados e
28
determinação do tipo de geração que deverá ser executada (apenas classes, apenas scripts
SQL e ambos). Com base nessas informações iniciais foram especificados os requisitos que
devem ser atendidos, definindo o escopo do aplicativo. Na seqüência são apresentados os
requisitos funcionais e não funcionais. No quadro 2 podem ser observados os requisitos
funcionais. Já no quadro 3 podem ser observados os requisitos não funcionais.
REQUISITOS FUNCIONAIS CASO USORF01. O sistema deve acessar o banco de dados Oracle. UC03RF02. O sistema deve identificar a estrutura de dados (tabelas, campos, índices e chaves estrangeiras) do respectivo banco acessado.
UC02
RF03. O sistema deve criar e/ou alterar a estrutura do metadados, gerando código SQL para realizar tal procedimento.
UC02
RF04. O sistema deve permitir o usuário configurar o banco de dados desejado e os arquivos de template que serão utilizados.
UC03
RF05. O sistema deve permitir o usuário indicar em que diretório deverão ser gerados os arquivos.
UC01
RF06. O sistema deve permitir que o usuário selecione para quais tabelas deseja gerar código.
UC01
RF07. O sistema deve permitir gerar código para as linguagens Object Pascal e Java para a camada de acesso a dados.
UC01
Quadro 2 – Requisitos funcionais
REQUISITOS NÃO-FUNCIONAISRNF01. Deve ser utilizada a ferramenta Borland Delphi 7 para o desenvolvimento da interface.RNF02. A interface deve ser de fácil compreensão permitindo acesso a todas as funcionalidades através de menus e botões de atalho.RNF03. As consultas ao banco devem ser rápidas, sendo que o tempo de carga da consulta precisa ser inferior a 30 segundos.RNF04. Devem ser utilizados templates para a geração do código de saída.
Quadro 3 – Requisitos não-funcionais
Após o detalhamento dos requisitos, foi especificado o diagrama de casos de uso da
ferramenta. Conforme dito nesse capítulo, o presente trabalho possui três módulos e para cada
módulo foi criado um caso de uso detalhado. A figura 3 apresenta o diagrama de casos de uso.
O detalhamento dos cenários será apresentado juntamente com a especificação da ferramenta.
29
Figura 3 – Diagrama de casos de uso
3.4 ESPECIFICAÇÃO DA LINGUAGEM DO MOTOR DE TEMPLATES
A especificação da linguagem do motor de templates objetiva a construção dos
analisadores léxico, sintático e semântico. Os analisadores léxicos são, usualmente,
especificados através de notações para a descrição de linguagens regulares tais como
expressões regulares (PRICE; TOSCANI, 2001, p. 24). Inicialmente foi definido o conjunto
de tokens9 que formam a linguagem. Nesse conjunto encontram-se as palavras reservadas,
identificadores e símbolos especiais, os quais fazem parte da linguagem e que devem ser
identificados pelo analisador léxico (quadro 4).
9 Tokens são símbolos léxicos que constituem uma linguagem regular (PRICE; TOSCANI, 2001, p. 17).
30
DEFINIÇÕES REGULARES TOKENSchar : [^<]char2 : [a-z A-Z]digit : [0-9]
//palavras reservadasvar : "<" {char2} ({char2} | {digit} | _ )* ">"
template = var : "<template>"endtemplate = var : "<endtemplate>"tablename = var : "<tablename>"fields = var : "<fields>"endfields = var : "<endfields>"fieldname = var : "<fieldname>"fieldtype = var : "<fieldtype>"
//identificadoresidentifier : {char}+
//símbolos especiais"<"
Quadro 4 – Definições regulares e tokens
Conforme visualizado no quadro 4, as palavras reservadas iniciam com o símbolo
menor (<) e deve ser seguido de pelo menos um caractere, podendo ser letra, dígito ou o
símbolo underline ( _ ). A construção é finalizada com o símbolo maior (>). Essas construções
são utilizadas na elaboração do código dinâmico do template. O caractere menor (<) é
considerado um símbolo especial pois ele faz parte da definição das palavras reservadas e
também pode ser utilizado como código estático do template. Os espaços em branco são
desconsiderados e qualquer construção diferente é classificada como um identificador
qualquer. Os identificadores são utilizados para especificar o código estático do template. A
linguagem foi escrita em inglês e suas construções não consideram diferenças entre letras
maiúsculas e minúsculas (case sensitive).
Após a definição dos tokens, foi especificada uma GLC (quadro 5), utilizando a
notação BNF. Nessa etapa foram construídas as regras de produção (sintaxe) da linguagem.
Com base nas regras de produção, o analisador sintático verifica a presença de erros. Na
seqüência, foram definidas as ações semânticas da gramática. Diferentemente das verificações
semânticas habituais, essas ações servem como referência para que o motor de templates
identifique as declarações que serão substituídas e então possa gerar o código corretamente.
Através das ações semânticas, o analisador semântico pode classificar as declarações de
tabelas, campos e seus respectivos tipos.
No quadro 5 pode-se visualizar a gramática e as ações semânticas especificadas.<Template> ::= template #1 <Body> endtemplate #2 <Body> ::= <Text> <Body_> <Body_> ::= î | <Body> <Text> ::= identifier #3 | <TableName> | <Fields> | "<" #3<TableName>::= tablename #4 <Fields> ::= fields #5 <Value> endfields #6 <Value> ::= <Element> <Value_> <Value_> ::= î | <Value><Element> ::= identifier #7 | fieldname #7 | fieldtype #7 | <TableName> | "<" #7
Quadro 5 – Gramática e ações semânticas
31
Para cada ação semântica existe um procedimento associado que é responsável pelo
controle e armazenamento das informações. Após a análise da gramática, tais informações
serão utilizadas pelo motor de templates para gerar o código fonte. Conforme visualizado no
quadro 5, as ações semânticas são:
a) ações #1 e #2: delimitam o início e o final do template, após, respectivamente, as
palavras reservadas <template> e <endtemplate>;
b) ação #3: responsável pelo reconhecimento dos identificadores;
c) ação #4: identifica o nome da tabela que deve ser substituído na geração de
código;
d) ações #5 e #6: especificam o trecho de código que deve ser repetido para cada
campo existente na tabela;
e) ação #7: declaração do nome e tipo do campo que deve ser substituído na geração
de código.
Após a especificação da GLC e das ações semânticas, foi definido um arquivo de
template que deveria ser reconhecido pelo analisador léxico e sintático. O primeiro template
foi criado para a linguagem Object Pascal com o objetivo de construir uma classe simples que
publicasse os campos existentes em uma tabela. A partir desse objetivo foram estabelecidos
alguns critérios:
a) o nome da classe é composto de um prefixo mais o nome da tabela;
b) para cada campo da tabela, existe uma variável de controle, uma propriedade
publicada e uma constante literal;
c) os identificadores das construções (variáveis, propriedades e métodos) definidas a
partir dos campos da tabela são compostos por um prefixo mais o nome de cada
campo e seu respectivo tipo;
d) é necessário delimitar o início e fim do arquivo de template.
Com base nos critérios definidos, os quadros 6 e 7 mostram, respectivamente, um
exemplo de template válido e o código de saída esperado para a linguagem Object Pascal.
32
<template>
unit uclaCad<tablename>;
interfaceuses SqlExpr, SysUtils;
type TCad<tablename> = class
private <fields> f<fieldname> : <fieldtype> ; <endfields> public Constructor Create(const coSqlConection : TSQLConnection); virtual; abstract; Destructor Destroy; virtual; abstract; <fields> property <fieldname> : <fieldtype> read f<fieldname>; <endfields> end;
implementationend.
<endtemplate>Quadro 6 – Template para linguagem Object Pascal
unit uclaCadTABELA1;
interfaceuses SqlExpr, SysUtils;
typeTCadTABELA1 = class
private fCAMPO1 : integer;
fCAMPO2 : string; public Constructor Create(const coSqlConection : TSQLConnection); virtual; abstract; Destructor Destroy; virtual; abstract; property CAMPO1 : integer read fCAMPO1; property CAMPO2 : string read fCAMPO2; end;
implementationend.
Quadro 7 – Código de saída esperado
No apêndice A é apresentado um exemplo de template e o código de saída esperado
para a linguagem Java.
3.5 ESPECIFICAÇÃO DO MOTOR DE TEMPLATES
Para especificar o motor de templates foi utilizada a ferramenta Enterprise Architect.
Com base em conceitos de orientação a objetos foram definidos os seguintes diagramas da
UML: diagrama de casos de uso, diagrama de classes e diagrama de seqüência.
33
3.5.1 Casos de uso
Inicialmente é apresentado o caso de uso referente ao motor de templates, responsável
pela geração de código. Para o caso de uso Gerar Código foi detalhado o cenário principal
do gerador de código (passos para execução do procedimento) e três cenários de exceção, os
quais podem ser visualizados no quadro 8.
UC01 – Gerar código: permite o usuário gerar código fonte e scripts SQL para as tabelas desejadas.Pré-condições As opções de geração de código devem estar configuradas (através do menu de
configurações). O arquivo de template deve estar configurado.
Cenário Principal
01) O usuário seleciona o dicionário de dados.02) O sistema apresenta uma lista das tabelas existentes.03) O usuário seleciona as tabelas desejadas, indica o diretório onde serão salvos os arquivos e clica no botão GERAR.04) O sistema gera o código para as tabelas selecionadas conforme as opções da configuração.
Exceção 01 No passo 03, caso não seja apontado um diretório válido para gravação dos arquivos, o sistema gerará uma mensagem de exceção.
Exceção 02 No passo 03, caso não exista pelo menos uma tabela selecionada, o sistema gerará uma mensagem de exceção.
Exceção 03 No passo 04, caso existam erros léxicos ou sintáticos no arquivo de templateindicado o sistema gerará uma mensagem de exceção.
Pós-condições Classes de acesso ao banco de dados e scripts SQL foram gerados.Quadro 8 – Caso de uso Gerar código
3.5.2 Diagrama de classes
O diagrama apresenta as classes que compõem o módulo de geração de código, ou
seja, o motor de templates. Além de apresentar a estrutura das classes, também mostra seus
relacionamentos. As classes do motor de templates podem ser visualizadas na figura 4.
34
Figura 4 – Diagrama de classes do motor de templates
A classe principal deste módulo é a TTemplateEngine, que está diretamente
relacionada com a classe do analisador sintático. Por sua vez, a classe do analisador sintático
associa as classes do analisador léxico e semântico, e a partir desta classe são executados os
métodos de verificação de erros (análise léxica e sintática) do arquivo do template. As classes
de análise permitem a identificação das estruturas do template e também o mapeamento dos
35
erros encontrados, classificando o tipo de problema encontrado e a posição do texto onde
ocorre o problema. Convém mencionar que as classes TSintatico, TLexico e as demais
classes de tratamentos de erros descendentes da classe AnalysisError foram criadas pelo
GALS e estão destacadas conforme visualizado na figura 4. A classe TTemplateEngine é
responsável pela geração de código fonte e scripts SQL através da execução das ações
semânticas da linguagem do motor de templates. No quadro 9 podem ser visualizados os
principais métodos da classe e uma breve descrição sobre sua funcionalidade.
MÉTODO DESCRIÇÃOCarregaParametros Carrega as configurações iniciais para geração do código, como por
exemplo o diretório do arquivo de template, a configuração do banco de dados e o tipo de geração de código.
AbreArquivoTemplate Carrega arquivo com as informações do template.Executa Gera código fonte conforme parâmetros configurados.VerificacaoErros Verifica a presença de erros léxicos e sintáticos no arquivo do template.
Quadro 9 – Métodos da classe TTemplateEngine
Para que os métodos de geração de código fossem executados adequadamente, a
classe do gerador foi acoplada com outras classes de interface visual complementando o
módulo do motor de templates (figura 5).
Figura 5 – Interface do motor de templates
Conforme apresentado na figura 5, a classe TFuncaoGeracao realiza a interface entre o
formulário do motor de templates e a classe TGeracao. A classe TGeracao contém as regras
de negócio do gerador de código, sendo responsável pela chamada dos métodos de análise e
geração.
36
3.5.3 Diagrama de seqüência
Através da análise do diagrama de seqüência, pode-se visualizar as interações do
usuário com o sistema e o comportamento das classes. Conforme ilustrado na figura 6, o
diagrama mostra as atividades do usuário no procedimento de geração de código e seqüência
de métodos executados pelas classes envolvidas.
Figura 6 – Diagrama de seqüência do motor de templates
3.6 IMPLEMENTAÇÃO DO MOTOR DE TEMPLATES
Nesta seção são apresentadas as ferramentas e técnicas utilizadas e também descrito o
processo de implementação. O motor de templates foi implementado com a linguagem Object
Pascal utilizando o ambiente de programação Delphi 7, pelo fato de permitir criar telas
gráficas rapidamente. Também foram utilizadas técnicas de programação orientada a objetos.
Dessa forma, o motor de templates foi organizado em classes. A partir da linguagem
especificada, o GALS foi utilizado para gerar as classes que contêm os analisadores léxico,
sintático e semântico, respectivamente identificados pelas classes TLexico, TSintatico e
37
TSemantico. As classes dos analisadores léxico e sintático não foram alteradas. Porém, no
caso do analisador semântico, o GALS gera apenas a assinatura do método executeAction,
sendo necessário implementar manualmente as ações semânticas. O motor de templates foi
estruturado da seguinte forma:
a) a classe TParametros é responsável pela carga dos parâmetros para geração de
código;
b) TCampo, TIndice e TTabela são as classes que contêm as informações dos
campos, índices e tabelas, respectivamente;
c) TXML_Interface é a classe utilizada para carga do metadados a partir de arquivos
XML;
d) a classe TConnection realiza a carga do metadados a partir da conexão com o
banco de dados;
e) as classes TLexico, TSintatico e TSemantico implementam os analisadores
léxico, sintático e semântico, respectivamente;
f) TTemplateEngine é a classe de regras de negócio, que reúne as funcionalidades
das demais classes e é responsável pela geração de código;
g) as classes TGeracao e TFuncaoGeracao que realizam a interface com o usuário e
executam os métodos de análise e geração de código.
Dentre as classes que fazem parte do motor de templates, é importante destacar a
classe TSemantico, uma vez que esta classe é responsável por gerar o código fonte com base
no arquivo de template. As demais classes possuem apenas funcionalidades simples, como
rotinas de tela e tratamento de erros, o que não convém detalhar. No quadro 10 segue o trecho
do método executeAction da classe TSemantico e dois dos principais métodos associados às
ações semânticas da gramática.
38
procedure TSemantico.executeAction(action : integer; const token : TToken);begin case action of 1: Inicializacao;
2: Finalizacao; 3: ArmazenaTexto(token); 4: SubstituiVarTabela(token); 5: InicioRepeticao; 6: FimRepeticao; 7: SubstituiVariavel(token); end;end;
procedure TSemantico.FimRepeticao;var ix : Integer; Linha : String; Posicao : Integer;
lsTipo : String;begin
for ix := Low(fTabela.Campos) to High(fTabela.Campos) do begin Linha := fTextoRepeticao; //verifica fieldname while pos('<fieldname>',Linha) > 0 do begin Posicao := pos('<fieldname>',Linha); delete(Linha,Posicao, length('<fieldname>')); if fParametros.Linguagem = tlPascal then
insert(Trim(fTabela.Campos[ix].NomeLogico),Linha,Posicao) else insert(' '+Trim(fTabela.Campos[ix].NomeLogico),Linha,Posicao);
end; //verifica fieldtype while pos('<fieldtype>',Linha) > 0 do begin Posicao := pos('<fieldtype>',Linha); delete(Linha,Posicao, length('<fieldtype>'));
lsTipo := RetornaTipoLinguagem(Trim(fTabela.Campos[ix].Tipo), fParametros.Linguagem); if fParametros.Linguagem = tlPascal then insert(Trim(lsTipo),Linha,Posicao) else insert(' '+Trim(lsTipo),Linha,Posicao); end; fTexto := fTexto + Linha + #13#10 + ' ';
end;end;
procedure TSemantico.Finalizacao;var ix : Integer; Arquivo : TextFile; NomeArquivo : String;begin //valida diretorio if fDiretorio[length(fDiretorio)] = '\' then Delete(fDiretorio, length(fDiretorio)-1, 1); //atribui nome arquivo case fParametros.Linguagem of tlPascal : NomeArquivo := fDiretorio+'\uclacad'+fTabela.NomeLogico+'.pas'; tlJava : NomeArquivo := fDiretorio+'\TTAB'+fTabela.NomeLogico+'.java'; end;
//gera arquivo de saída AssignFile(Arquivo, NomeArquivo); Rewrite(Arquivo); Writeln(Arquivo, fTexto); Flush(Arquivo); CloseFile(Arquivo);end;
Quadro 10 – Trecho do método para geração de código fonte
39
3.7 ESPECIFICAÇÃO DO EDITOR E DO GERADOR DE CÓDIGO
A especificação do editor e gerador de código foi realizada com a ferramenta
Enterprise Architect e foram definidos os seguintes diagramas da UML: diagrama de casos de
uso, diagrama de classes e diagrama de seqüência.
3.7.1 Casos de uso
O editor e o gerador de código têm três funcionalidades principais que são:
configuração dos parâmetros, edição do metadados e geração de código. A funcionalidade da
geração de código está diretamente ligada ao motor de templates e compartilha o mesmo caso
de uso. Esta seção apresenta os casos de uso referentes à configuração dos parâmetros e
edição do metadados, tendo em vista que o diagrama de casos de uso e o caso de uso do motor
de templates foram apresentados anteriormente.
O caso de uso Editar Metadados mostra o cenário principal para editar o dicionário
de dados detalhando a seqüência de passos a serem executados. Além do cenário principal
também são detalhados um cenário alternativo e quatro cenários de exceção. Os cenários
podem ser visualizados no quadro 11.
40
UC02 – Editar Metadados: permite o usuário criar e editar a estrutura de um metadados.Pré-condições Deve ter sido estabelecida uma conexão com um banco de dados.Cenário Principal
01) O usuário seleciona a opção de carregar o metadados do banco através do botão CARREGAR.02) O sistema realiza uma varredura no banco de dados e apresenta a estrutura de tabelas, campos e índices encontrados.03) O sistema apresenta a tela do editor de metadados.04) O usuário seleciona a opção de criar/editar uma tabela.05) O sistema apresenta as opções de criação de tabelas.06) O usuário preenche o nome da tabela e descrição. Insere um novo campo na tabela ou edita as propriedades de um campo existente. Insere um novo índice na tabela ou edita as propriedades de um índice existente.07) O usuário salva a estrutura em um arquivo do tipo XML através do botão SALVAR.08) O sistema apresenta uma janela para salvar o arquivo.09) O usuário indica o diretório e o nome do arquivo.10) O sistema salva a estrutura lógica das tabelas para posterior geração de scriptsSQL.
Cenário Alternativo 1
No passo 01 o sistema recupera as informações do metadados a partir de um arquivo do tipo XML.01.1) O sistema apresenta a tela do editor de metadados.01.2) O usuário seleciona a opção de carregar o metadados do banco através do botão CARREGAR ARQUIVO.01.3) O sistema apresenta uma janela para escolha do arquivo.01.4) O usuário seleciona o arquivo desejado.01.5) O sistema acessa o arquivo, importa as informações, apresenta a estrutura encontrada (estrutura de tabelas, campos e índices) e segue para o passo 04.
Exceção 01 No passo 01 caso exista algum problema de conexão com o banco de dados será gerada uma exceção.
Exceção 02 No passo 06 para os campos de nome (tabela, campo e índice) caso sejam inseridos caracteres especiais, acentos ortográficos ou espaços em branco, o sistema gerará uma exceção.
Exceção 03 No passo 06, caso não exista campos na tabela, o sistema gerará uma exceção.Exceção 04 No passo 01.5 do cenário alternativo, caso o arquivo seja de um formato inválido
ou apresente erros de construção, o sistema gerará uma exceção.Pós-condições O metadados do banco de dados foi identificado/criado.
Quadro 11 – Caso de uso Editar Metadados
O caso de uso Acessar Configurações detalha o cenário principal para configuração
dos parâmetros e três cenários de exceções, os quais podem ser visualizados no quadro 12.
41
UC03 – Acessar Configurações: permite que o usuário tenha acesso ao menu de configurações.Pré-condições NenhumaCenário Principal
01) O usuário seleciona a opção para configurar o banco de dados.02) O sistema apresenta uma lista com as configurações de banco de dados disponíveis.03) O usuário seleciona uma configuração.04) O sistema verifica a conexão com o banco de dados selecionado.05) O usuário seleciona a opção para configurar o template de geração de código.06) O sistema apresenta um diálogo de seleção de arquivos.07) O usuário seleciona um arquivo.08) O usuário indica a linguagem do template (Object Pascal ou Java).09) O sistema verifica a presença de erros léxicos e sintáticos no template.10) O usuário seleciona uma das opções (scripts SQL, classes ou ambos) para configurar o tipo de geração.11) O usuário seleciona o botão para salvar a configuração.12) O sistema grava as configurações realizadas.
Exceção 01 No passo 04, caso a conexão com o banco de dados apresente problemas, o sistema gerará uma exceção.
Exceção 02 No passo 07, caso o formato do arquivo seja inválido, o sistema gerará uma exceção. Arquivos do tipo TXT são considerados arquivos válidos.
Exceção 03 No passo 09, caso o arquivo de template apresente erros léxicos ou sintáticos, o sistema gerará uma exceção.
Pós-condições Os parâmetros iniciais foram configurados.Quadro 12 – Caso de uso Acessar Configurações
3.7.2 Diagrama de classes
Nesta seção são apresentadas as funcionalidades do editor de metadados e
configuração dos parâmetros, sendo que a funcionalidade do gerador de código foi
apresentada anteriormente juntamente com a descrição da implementação do motor de
templates. Na figura 7 pode-se visualizar o diagrama de classes do módulo de edição de
metadados.
42
Figura 7 – Diagrama de classes do módulo de edição de metadados
A principal classe do módulo de edição de metadados é a classe TEdicao. A classe
TEdicao implementa os métodos de acesso ao banco de dados e leitura do metadados e
também o método de carga do dicionário de dados a partir de um arquivo XML. Além dos
métodos de carga existem também os métodos de edição. Os métodos de edição permitem a
criação e manutenção da estrutura de tabelas, campos e índices no dicionário de dados.
Adicionalmente a classe TFuncaoEdicao realiza o controle de interface do módulo,
relacionando o formulário e os métodos implementados na classe TEdicao. No quadro 13 é
apresentada uma breve descrição de alguns métodos da classe TEdicao.
43
MÉTODO DESCRIÇÃOCarregaParametros Carrega os parâmetros configurados.AbreDicionario Abre um arquivo de dicionário de dados do tipo XML.NovoDicionario Cria um novo dicionário de dados vazio.SalvaDicionario Salva as informações do dicionário de dados em um arquivo do tipo
XML.PesquisaBancoDados Acessa banco de dados configurado nos parâmetros e carrega estrutura
do dicionário de dados.Quadro 13 – Principais métodos da classe TEdicao
Na seqüência o diagrama de classes do módulo de configuração de parâmetros é
apresentado na figura 8.
Figura 8 – Diagrama de classes do módulo de configuração de parâmetros
Conforme pode-se visualizar na figura 8, no módulo de configuração a classe
TFuncaoConfiguracoes é responsável pelo relacionamento entre o formulário e as regras de
negócio que estão contidas na classe TConfiguracoes. A classe TConfiguracoes possui os
métodos para leitura e gravação dos parâmetros. No quadro 14 são descritos os principais
métodos da classe TConfiguracoes.
MÉTODO DESCRIÇÃOEscolheTemplate Indica a localização e o nome do arquivo de template.ValidaTemplate Verifica se o template possui erros léxicos ou sintáticos.ValidaBancoDados Verifica a conexão com o banco de dados através dos parâmetros
configurados.GravaParametros Grava os parâmetros no registro do Windows.
Quadro 14 – Métodos da classe TConfiguracoes
O diagrama de classes da figura 9 apresenta a estrutura criada para controle das
funcionalidades da ferramenta.
44
Figura 9 – Diagrama de classes do editor de metadados e do gerador de código
A classe TAmbiente está relacionada com o formulário TFormAmbiente que é o
formulário ancestral da aplicação e contém os componentes visuais onde devem ser criados os
menus e os atalhos. Para cada módulo da ferramenta é adicionada uma chamada de menu e
45
criado um atalho numa estrutura do tipo árvore. Desta forma, o usuário pode executar os
módulos a partir dos menus ou a partir dos atalhos.
A configuração dos menus deve ser realizada a partir do método abstrato CriaFuncoes
da classe TFormAmbiente. O método CriaFuncoes cria os menus e atalhos dinamicamente e
adiciona as funcionalidades10 na classe TAmbiente onde elas são armazenadas numa lista
(TFuncoes), permitindo a classe TAmbiente controlar a execução de cada módulo
independentemente. Quando um menu é adicionado, é executado o método AddFuncao
passando como parâmetro uma classe do tipo TFuncao. A classe TFuncao possui o método
Executa, o qual permite a classe TAmbiente executar uma determinada funcionalidade a partir
da chamada de menu.
Cada vez que um módulo é executado, a classe TAmbiente verifica se a classe de
controle do módulo (TFuncao) já está criada e em caso negativo então ela é executada. Em
seguida o formulário do módulo é visualizado. No quadro 15 são descritos os principais
métodos das classes de controle de interface.
CLASSE MÉTODO DESCRIÇÃOGetName() Retorna o nome da funcionalidade.TFuncaoExecuta() Executa a funcionalidade.
TFuncoes Add(TFuncao) Adiciona uma função à lista de funções.AddFuncao(TFuncao) Chama a classe TFunções e adiciona uma funcionalidade.TAmbienteExecutaFuncao() Executa uma funcionalidade da lista.
TFormAmbiente CriaFuncoes() Adiciona funcionalidades ao menu.Quadro 15 – Principais métodos de controle de interface
A partir do formulário TFormAmbiente foi criado o formulário principal da aplicação
(TFormAmbienteEditor) e nesse formulário são configurados os módulos. Para cada módulo,
foi criada uma estrutura de controle. Inicialmente existe uma classe que herda as
características da classe TFuncao. Essa classe é responsável pelo relacionamento entre o
formulário do módulo e a classe de regras de negócio. O arquivo fonte do formulário não
possui nenhum código, sendo que a implementação de todos os eventos é realizada na classe
de controle. Quando o método CriaFuncoes do formulário do ambiente é executado, essa
classe é passada como parâmetro.
10 Funcionalidade e módulos são utilizados como sinônimos.
46
3.7.3 Diagrama de seqüência
O diagrama de seqüência permite a visualização dos passos executados pelo usuário e
seqüência de atividades executadas pelo sistema. A figura 10 ilustra o diagrama de seqüência
do caso de uso Editar Metadados. Pode-se visualizar as atividades do usuário no
procedimento de edição do dicionário de dados e a seqüência de métodos executados pelas
classes envolvidas.
Figura 10 – Diagrama de seqüência para edição do metadados
Na seqüência é apresentado o diagrama do caso de uso Acessar Configurações. A
figura 11 mostra o diagrama com todos os passos a serem executados para configurar os
parâmetros da ferramenta.
47
Figura 11 – Diagrama de seqüência do caso de uso Acessar Configurações
3.8 IMPLEMENTAÇÃO DO EDITOR E DO GERADOR DE CÓDIGO
Esta seção tem como objetivo apresentar as ferramentas utilizadas para implementação
do editor e do gerador de código, bem como descrever o processo da implementação.
3.8.1 Técnicas e ferramentas utilizadas
Assim como no processo de implementação do motor de templates, foi utilizada a
linguagem Object Pascal e o ambiente de programação Delphi 7. A técnica de programação
adotada foi a orientação a objetos.
48
3.8.2 Implementação
O editor de metadados e o gerador de código foram desenvolvidos a partir do código
do motor de templates que já tinha sido implementado anteriormente. A primeira tarefa
executada foi a construção da interface da ferramenta. O objetivo era construir um ambiente
que permitisse a adição de funcionalidades (módulos) de forma que elas fossem executadas
independentemente e pudessem ser alternadas sem perder as informações processadas, não
sendo necessário carregar todas as informações novamente.
Uma vez que os requisitos da interface estavam definidos, foi construído o ambiente
que iria adicionar as funcionalidades: configurações, editor de dicionário e gerador de código.
Inicialmente foram criados o formulário principal do ambiente e a estrutura de controle do
ambiente que realiza a comunicação com o formulário. As principais classes do controle do
ambiente são: TAmbiente e TFormAmbiente.
Depois que o controle da interface estava pronto, iniciou-se a implementação dos
módulos. Para cada módulo foi criada uma estrutura de três classes: uma classe de regras de
negócio, uma classe do formulário e uma classe que realiza a interface do formulário com a
classe de regras de negócio e com o ambiente da ferramenta.
Começando pelo módulo de configurações e obedecendo a estrutura definida, foram
criadas as classes: TConfiguracoes, TFormConfiguracoes e TFuncaoConfiguracoes. No
quadro 16 é apresentado um trecho do código da função para carregar os parâmetros.function LeParametros: TParametros;begin result := TParametros.Create; result.Banco := getStringRegistryValue('Parametros\','Banco'); result.UserName := getStringRegistryValue('Parametros\','UserName'); result.Password := getStringRegistryValue('Parametros\','Password'); result.TipoGeracao :=
TTipoGeracao(getIntegerRegistryValue('Parametros\','TipoGeracao')); result.Linguagem :=
TTipoLinguagem(getIntegerRegistryValue('Parametros\','Linguagem')); result.Template := getStringRegistryValue('Parametros\','Template'); result.ArquivoOracle := GetOracleRegistryValue('ORACLE_HOME');end;
Quadro 16 – Trecho do código utilizado para carga dos parâmetros
No quadro 17 é apresentado o método de validação da conexão com o banco de dados.
49
function TConnection.Conecta: Boolean;begin fDB.DriverName:= 'Oracle'; fDB.ConnectionName:= 'Oracle'; fDB.GetDriverFunc:= 'getSQLDriverORACLE'; fDB.LibraryName:= 'dbexpora.dll'; fDB.VendorLib:= 'OCI.DLL'; fDB.KeepConnection:= True; fDB.LoginPrompt:= False; fDB.Params.Values['DataBase'] := fAlias; fDB.Params.Values['User_Name']:= fUserName; fDB.Params.Values['Password'] := fPassWord;
fDB.Close; try fDB.Connected:= True; result := fDB.ConnectionState = csStateOpen;
except on E:exception do
begin result := False; Application.MessageBox(pchar(e.Message), pchar('Atenção'), MB_ICONERROR); end;
end;end;
Quadro 17 – Método de conexão com o banco de dados
Em seguida, foi desenvolvido o módulo do editor de dicionário de dados. O editor
permite carregar um dicionário de dados ou criar um dicionário novo e, a partir deste
dicionário, criar, alterar ou excluir tabelas, campos e índices. As classes TEdicao,
TFormEdicao e TFuncaoEdicao foram criadas para construção do módulo e são,
respectivamente, classe de regras de negócio, formulário e classe de interface. No quadro 18
pode-se visualizar o método de carga do dicionário de dados a partir do banco de dados
configurado.
50
function TConnection.PesquisaMetadados: TTabelas;var Tabelas : TTabelas; Tabela : TTabela; tbNames : TStringList; ixTab : Integer;begin SetLength(Tabelas, 0); tbNames := TStringList.Create; //pega nomes tabelas fDB.GetTableNames(tbNames);
for ixTab := 0 to tbNames.Count -1 dobegin
//preenche info tabela Tabela := TTabela.Create; Tabela.NomeLogico := Trim(tbNames.Strings[ixTab]); Tabela.Apelido := Trim(tbNames.Strings[ixTab]); Tabela.Descricao := 'TAB_'+Trim(tbNames.Strings[ixTab]);
getTableFields(Tabela); getTableIndexes(Tabela);
//adiciona tabela na listaSetLength(Tabelas, Length(Tabelas)+1);
Tabelas[Length(Tabelas)-1] := Tabela; end; result := Tabelas;end;
Quadro 18 – Método para carga do metadados do banco de dados
Adicionalmente, o quadro 19 apresenta o método que permite salvar o dicionário de
dados em um arquivo do tipo XML.procedure TEdicao.SalvaDicionario;begin if not Assigned(fXML) then fXML := TXML_Interface.Create; if fSalvarArquivo.Execute and (Trim(fSalvarArquivo.FileName) <> '') then begin
fXML.WriteToFile(fSalvarArquivo.FileName, fTabelas); fAlteracoesPendentes := False; fAlteracoesPendentesTabela := False; Application.MessageBox(pchar('Alterações salvas com sucesso'),
pchar('Atenção'), MB_ICONINFORMATION); end;end;
Quadro 19 – Método para salvar dicionário em arquivo XML
Nas classes de regras de negócio foram implementadas apenas as funções mais simples
e chamadas para funções de outras classes. Dessa forma, foram criadas classes separadas para
implementar os métodos mais complexos. Por exemplo, a classe TXML_Interface possui os
métodos para carregar e salvar a estrutura do dicionário em um arquivo do tipo XML e está
diretamente ligada ao módulo do editor de dicionário e também ao módulo do gerador de
código.
Para o módulo do gerador de código foram criadas as classes TGeracao,
TFormGeracao e TFuncaoGeracao. A classe TGeracao é a classe de regras de negócio. Ela é
responsável pela chamada dos métodos de análise e geração de código implementados na
51
classe TTemplateEngine, que é a classe do motor de templates, apresentados anteriormente
nesse capítulo.
3.9 OPERACIONALIDADE DA IMPLEMENTAÇÃO
Nesta seção é apresentada a operacionalidade da ferramenta desenvolvida. A figura 12
mostra a tela principal e informações sobre as funcionalidades da ferramenta.
Figura 12 – Tela principal da ferramenta
Para executar um dos três módulos disponíveis é necessário um duplo clique em um
dos atalhos ou selecionar o módulo através do menu do sistema. Existe a opção de ocultar a
região dos atalhos clicando no botão que habilita a visualização dos atalhos. Também é
permitido visualizar o formulário de um módulo em tela cheia clicando no botão de tela cheia.
Neste caso, os menus e atalhos da tela principal ficarão ocultos. Para voltar ao modo normal
basta fechar o formulário através de um clique no ícone de sistema localizado no canto
superior direito de cada formulário. O ícone de sistema de cada módulo somente é visualizado
52
quando o formulário do módulo está sendo executado em modo tela cheia. Ao executar o
módulo de configurações, será exibido o formulário dos parâmetros do sistema (figura 13).
Figura 13 – Módulo de configuração de parâmetros
Conforme visualizado na figura 13, o módulo de configurações está dividido em três
partes:
a) configuração do banco de dados: permite configurar qual servidor e usuário do
banco o aplicativo deverá conectar para carregar o metadados;
b) configuração do arquivo de template: permite indicar o arquivo de template que
será utilizado;
c) configuração do tipo de geração de código: permite escolher se a ferramenta irá
gerar código para classes, scripts SQL ou ambos.
Para configurar o banco de dados, primeiro o usuário deve selecionar o alias entre as
opções apresentadas. A ferramenta carrega automaticamente uma lista com as possíveis
conexões de banco especificadas no arquivo TNSNAMES.ORA. Na seqüência o usuário deve
preencher os campos do usuário e senha. Após realizar a configuração, existe a opção de
testar se a conexão é válida. Para tanto, basta clicar no botão correspondente. A ferramenta irá
53
realizar um teste de conexão e irá apresentar uma mensagem informando se a operação obteve
êxito ou se encontrou algum erro e qual o erro encontrado.
A configuração das opções de template inicia com a escolha do arquivo de template.
Para indicar o arquivo de template basta clicar no botão ao lado do campo do arquivo. Após
clicar no botão, o sistema apresentará a janela da figura 14 para escolha do arquivo.
Figura 14 – Janela de escolha do arquivo de template
A ferramenta aceita arquivos de texto do formato TXT como arquivos de template.
Após a escolha do arquivo é possível verificar se existe a presença de erros. Clicando no
botão de verificação de erros, o arquivo será analisado léxica e sintaticamente. Ao final da
verificação será mostrada uma mensagem de êxito se não foram encontrados erros. Caso
exista a presença de erros, será mostrada uma mensagem de alerta com o objetivo de informar
ao usuário que foram encontrados erros no arquivo e questionar o usuário se deseja verificar a
lista de erros. Se o usuário confirmar a exibição de erros, é apresentada uma nova janela com
a lista dos erros encontrados (figura 15).
54
Figura 15 – Lista de erros do arquivo de template
Conforme visualizado na figura 15, a janela mostra uma lista dos erros e a posição do
texto onde cada erro foi encontrado. Para concluir a configuração do arquivo de template, é
necessário selecionar o tipo de linguagem (Pascal ou Java) para qual as classes deverão ser
geradas. Finalmente, a configuração dos parâmetros é concluída com a escolha do tipo de
geração de código. Basta escolher uma das opções para indicar se a ferramenta deverá gerar
código apenas para classes de acesso, apenas para scripts SQL ou para ambos.
Após a configuração dos parâmetros, o usuário deve acessar o módulo do editor do
dicionário. A figura 16 apresenta a tela do módulo selecionado.
55
Figura 16 – Módulo do editor de dicionário
O módulo do editor de dicionário permite o usuário alterar a estrutura do metadados de
um banco de dados. Inicialmente é necessário carregar a estrutura do dicionário de dados que
pode ser realizada de três formas diferentes:
a) criar arquivo novo: cria uma estrutura do dicionário em branco;
b) criar arquivo a partir do banco de dados: a ferramenta conecta no banco de dados
configurado nos parâmetros e carrega o metadados;
c) abrir arquivo do dicionário: abre uma estrutura do dicionário salva anteriormente
em arquivo do tipo XML.
Cada opção de carga do dicionário está associada com um botão de atalho. O exemplo
da figura 17 ilustra a carga de um arquivo salvo a partir do botão de abrir arquivo do
dicionário.
56
Figura 17 – Janela de escolha do arquivo do dicionário
Após clicar no botão para abrir arquivo do dicionário, o usuário visualiza a janela de
escolha de arquivo conforme visto na figura 17. Basta selecionar o arquivo desejado e clicar
no botão de abrir. A ferramenta aceita arquivos do tipo XML como arquivos de dicionário
válidos. Após a escolha do arquivo, a estrutura do dicionário é carregada e visualizada no
formulário do módulo (figura 18).
57
Figura 18 – Estrutura do dicionário de dados
A estrutura do dicionário é apresentada em forma de árvore (figura 18). O primeiro
elemento da árvore possui o nome do arquivo do dicionário. A partir desse elemento são
adicionadas as tabelas e sua estrutura de campos (nome dos campos e tipo) e dos índices
(nome dos índices). Para alterar as informações da tabela é necessário dar um duplo clique no
nome da tabela apresentado na estrutura do dicionário. Após dar o duplo clique é apresentada
uma janela com os detalhes da tabela (figura 19).
58
Figura 19 – Detalhes da tabela MAQ_PROD
A figura 19 mostra as informações da tabela MAQ_PROD. O usuário pode alterar as
informações de documentação (nome, apelido e descrição da tabela) e também pode alterar a
estrutura de campos e índices da tabela. Para incluir um campo na tabela basta clicar no botão
de incluir campos. Ao clicar no botão, o usuário tem acesso à janela de edição do campo
(figura 20).
59
Figura 20 – Edição do campo
Após o usuário preencher as informações (nome, título, descrição, tipo, tamanho,
decimais e permite nulo) e confirmar a edição, o novo campo será incluído na tabela. A
inclusão do campo KGMAX na tabela MAQ_PROD pode ser visualizada na figura 21.
60
Figura 21 – Inclusão do novo campo
Para alterar um campo da tabela é necessário selecionar o campo na lista dando um
duplo clique. Da mesma forma que no procedimento de inclusão do campo, o usuário tem
acesso à janela de edição do campo. Após alterar as informações desejadas, basta clicar no
botão confirmar para concluir a alteração do campo. Caso o usuário deseje excluir um campo,
é necessário selecionar o campo da lista e clicar no botão de exclusão, conforme apresentado
detalhe na figura 19.
A figura 22 mostra uma lista com os índices que fazem parte da tabela. A partir da
seleção de um índice da lista é exibida outra lista com os campos que fazem parte do índice.
Para incluir um novo índice na tabela é necessário clicar no botão de inclusão de índices.
Após clicar no botão, o usuário tem acesso à janela de edição dos índices (figura 23).
61
Figura 22 – Detalhes dos índices da tabela
Figura 23 – Edição do índice
A janela de edição de índices permite o usuário preencher as informações do índice
62
(nome, título, chave primária e índice único) e também escolher os campos e definir a
seqüência dos mesmos na criação do índice. Após concluir o preenchimento e a escolha dos
campos basta clicar no botão de confirmação para incluir o índice na tabela.
Caso o usuário deseje alterar um índice, é necessário selecionar o índice na lista dando
um duplo clique, para que a janela de edição de índices seja exibida. Assim como no
procedimento de inclusão, o usuário deve preencher/alterar as informações necessárias e
confirmar a alteração. Adicionalmente, para excluir um índice é necessário apenas selecionar
o índice na lista e clicar no botão de exclusão.
Uma vez conhecidas as operações de edição das tabelas, campos e índices, o usuário
pode alterar a estrutura do dicionário de dados e posteriormente gerar código. Para executar
tal tarefa, o usuário deve acessar o módulo do gerador de código. A figura 24 apresenta a tela
inicial do módulo.
Figura 24 – Módulo do gerador de código
Para gerar código, o usuário inicialmente deve carregar o dicionário de dados com a
estrutura das tabelas. O procedimento de carga pode ser realizado de duas formas:
a) carga a partir do banco de dados;
b) carga a partir de arquivo do dicionário.
63
Se o usuário optar por abrir um arquivo do dicionário de dados, o aplicativo apresenta
uma janela para seleção de um arquivo do tipo XML previamente editado conforme visto na
figura 25.
Figura 25 – Janela de seleção do arquivo do dicionário
Caso o usuário opte pela carga do dicionário através do banco de dados, a ferramenta
acessa o banco de dados configurado nos parâmetros e carrega o metadados. Uma vez que o
dicionário esteja carregado, o sistema apresenta as informações do dicionário e uma lista com
as tabelas do metadados. A figura 26 mostra os detalhes da carga do dicionário através do
arquivo PROJETO.XML.
64
Figura 26 – Tabelas para geração de código
Após carregar o dicionário de dados, o usuário deve indicar em qual diretório a
ferramenta deve salvar os arquivos ao gerar código. Depois de o usuário clicar no botão para
indicar o diretório, o aplicativo apresenta uma janela (figura 27).
Figura 27 – Seleção do diretório para geração de código
65
Após confirmar a seleção do diretório onde os arquivos de código serão salvos, o
usuário deve selecionar para quais tabelas deseja gerar código. Na lista de tabelas do
dicionário, na coluna do ID da tabela, ao lado do número de identificação da tabela existe uma
caixa para seleção conforme pode ser visualizado na figura 28.
Figura 28 – Seleção das tabelas para geração de código
Assim que as tabelas forem selecionadas, basta o usuário clicar no botão de geração de
código para que a ferramenta gere o código conforme opção configurada nos parâmetros.
Caso o usuário tenha configurado a ferramenta para gerar scripts SQL, a ferramenta
apresentará um diálogo. Nesse diálogo o usuário decide se deseja gerar scripts para criação ou
manutenção do banco de dados. No caso de manutenção, a ferramenta irá conectar no banco
de dados configurado nos parâmetros e gerar código correspondente. Ao término da geração
de código é apresentada uma mensagem (figura 29).
66
Figura 29 – Geração de código concluída
3.10 ESTUDO DE CASO
Além dos testes realizados durante o processo de desenvolvimento da ferramenta, com
o objetivo de verificar os resultados e torná-los mais evidentes, foi necessário aplicar a
ferramenta proposta na implementação de um pequeno sistema com acesso a banco de dados.
Após a especificação do escopo e requisitos, foram detalhados os casos de uso (figura 30) e
definido o DER das tabelas que compõe o sistema (figura 31).
67
Figura 30 – Diagrama de casos de uso do sistema
Figura 31 – Modelo entidade-relacionamento das tabelas
Para implementação do sistema foram seguidos os passos:
a) definição do dicionário de dados: com a utilização da ferramenta, foi construída a
estrutura das tabelas, campos e índices que compõem o sistema;
b) geração de código: a partir do dicionário de dados, foram gerados scripts SQL e
classes de acesso ao banco de dados;
c) criação do banco de dados: os scripts SQL foram utilizados para criar o banco de
dados;
68
d) implementação: utilizando como base o código gerado pela ferramenta, foi
desenvolvido um pequeno sistema de controle de produção.
O quadro 20 mostra um exemplo de script SQL gerado para criar a tabela PRODUTO no
banco de dados da aplicação e o quadro 21 apresenta um exemplo do código gerado para a
classe da tabela MAQUINA. A construção das classes das tabelas utiliza o padrão de projeto
Active Record.CREATE TABLE PRODUTO (CODIGO_PRODUTO NUMBER(10),DESCRICAO CHAR(30),TIPO_PRODUTO NUMBER(10)) TABLESPACE &NOMETABLESPACE;
ALTER TABLE PRODUTO ADD CONSTRAINT PK_PRODUTO PRIMARY KEY (CODIGO_PRODUTO) USING INDEX TABLESPACE &NOMETABLESPACE;
Quadro 20 – Script SQL para criação da tabela PRODUTOunit uclaCadMAQUINA;
interfaceuses uDefinicao, SqlExpr, SysUtils;type TCadMAQUINA = class(TCadastroGenerico) private fNUMERO : STRING ; fNOME_MAQUINA : STRING ; fCARGA_MAXIMA : DOUBLE ; fCARGA_MINIMA : DOUBLE ;
public Constructor Create(const coSqlConection : TSQLConnection); Override; Destructor Destroy; Override; property NUMERO : STRING read fNUMERO write fNUMERO; property NOME_MAQUINA : STRING read fNOME_MAQUINA write fNOME_MAQUINA; property CARGA_MAXIMA : DOUBLE read fCARGA_MAXIMA write fCARGA_MAXIMA; property CARGA_MINIMA : DOUBLE read fCARGA_MINIMA write fCARGA_MINIMA;
end;
implementationuses DB;
constructor TCadMaquina.Create(const coSqlConection: TSQLConnection);begin inherited;end;
destructor TCadMaquina.Destroy;begin inherited;end;
end.Quadro 21 – Código original da classe TCadMaquina
Para cada tabela do banco de dados foi criada uma classe. As classes são utilizadas
para acessar os campos que fazem parte da tabela a partir de um registro posicionado. Os
métodos de acesso a dados foram criados na classe TCadastroGenerico, a qual cada classe de
tabelas herda (quadro 22).
69
TCadastroGenerico = classprivate fAcessoDados : TSQLQuery;protected
procedure AtribuiSQL(const csSQL: String); procedure ExecutaSQL; function TemRegistros: Boolean; procedure Primeiro;
procedure Ultimo; procedure Proximo;
procedure Anterior; public
Constructor Create(const coSqlConection : TSQLConnection); virtual;Destructor Destroy; Override;property AcessoDados : TSQLQuery read fAcessoDados write fAcessoDados;
end;Quadro 22 – Métodos da classe TCadastroGenerico
Depois de todas as classes de acesso a dados serem codificadas, as regras de negócio
foram implementadas. A implementação do sistema foi concluída com o desenvolvimento da
interface para o usuário.As principais telas do sistema são as telas de cadastro de produtos e
de programação das ordens, ilustradas respectivamente pelas figuras 32 e 33.
Figura 32 – Tela de cadastro de produtos
70
Figura 33 – Tela de programação das ordens de produção
O quadro 23 apresenta um trecho do código implementado na construção da tela de
cadastro de produtos, exemplificando como foi utilizada a classe TCadProduto.
71
procedure TfrmCadastroProduto.plGrava;
Function ConsisteCampos: Boolean;Begin
Result:= False;if fCadastro.CodigoProduto = 0 Then
Raise Exception.Create('Código do produto em branco ou igual a zero. ') else if Trim(fCadastro.Descricao) = EmptyStr Then
Raise Exception.Create('Descrição do produto em branco. ') else if fCadastro.Tipo_Produto = -1 Then Raise Exception.Create('Tipo do produto não selecionado. ')
elseResult:= True;
End;begin
TryIf ConsisteCampos Then
BeginIf fAlteracao Then
fCadastro.AtribuiSQL('UPDATE TABLE PRODUTO SET DESCRICAO = ' +fCadastro.Descricao+', TIPO_PRODUTO = '
+InttoStr(fCadastro.Tipo_Produto)+' WHERE CODIGOPRODUTO = '+InttoStr(fCadastro.CodigoProduto))
ElsefCadastro.AtribuiSQL('INSERT INTO TABLE PRODUTO VALUES('
+InttoStr(fCadastro.CodigoProduto)+','+fCadastro.Descricao+','+InttoStr(fCadastro.Tipo_Produto)+')');
fCadastro.ExecutaSQL;fAlteracao:= False;Application.MessageBox(pchar('Cadastro efetuado!'),
pchar(''),MB_ICONINFORMATION); plLimparCampos;plCarregarSmlv;
End;Except
On E:Exception Do Application.MessageBox(pchar(e.Message),
pchar('Atenção'), MB_ICONERROR); End;end;
Quadro 23 – Trecho do código da tela de cadastro de produtos
3.11 RESULTADOS E DISCUSSÃO
A implementação desse pequeno sistema mostrou-se adequada para a avaliação da
aplicação da ferramenta. Os resultados mais importantes obtidos foram:
a) facilidade para criação e manutenção do banco de dados;
b) geração de código fonte;
c) padronização e qualidade do código;
d) agilidade na implementação e suporte do sistema.
72
Tarefas repetitivas como a codificação de classes de acesso a dados, foram eliminadas
com a utilização da ferramenta. É importante enfatizar que mesmo com a alteração de
requisitos durante o desenvolvimento do sistema, o processo de manutenção do sistema e do
banco de dados foi realizado rapidamente através da geração de scripts SQL e de código
fonte. Outro detalhe que convém mencionar é que o código gerado pela ferramenta não
obedece nenhum padrão de geração e depende exclusivamente do arquivo de template
fornecido pelo usuário. O processo detalhado de como utilizar a ferramenta para desenvolver
um sistema está descrito no apêndice B. O quadro 24 mostra um comparativo da ferramenta
desenvolvida (EditDB) com trabalhos correlatos comerciais (Power Designer, Rational Rose e
Oracle SQL Developer) e acadêmicos (SANTOS, 2005; COELHO, 2006).
Aplicativos
Características
Power Designer
Rational Rose
Oracle SQL
Developer
Santos (2005)
Coelho (2006) EditDB
diagramas UML S S N N N N
suporte a vários BD S S S N S N
scripts SQL DDL S S S N N S
scripts SQL DML N N S N N S
engenharia reversa BD S S S S S S
geração de código fonte S S N S S S
utilização de templates N N N N S S
suporte linguagem Object Pascal N S N N N S
suporte linguagem Java S S N S N S
suporte linguagem HTML N N N N S N
suporte linguagem C++ S S N N N N
distribuição gratuita N N S S S SQuadro 24 – Comparativo das principais características das ferramentas
73
4 CONCLUSÕES
No processo de desenvolvimento de softwares geralmente dispende-se considerável
trabalho com a implementação das rotinas de acesso a dados. Essa situação é agravada
principalmente com o transtorno ocasionado com alterações da estrutura do banco de dados.
A partir da análise dos problemas relativos ao processo de implementação de sistemas e
manutenção de banco de dados, foi construída uma ferramenta capaz de minimizar esse
trabalho automatizando algumas tarefas como a geração das classes e dos scripts SQL para
manutenção do banco de dados.
A ferramenta desenvolvida permite ao usuário, através de um editor, criar ou alterar a
estrutura de um banco de dados. Além da manipulação da estrutura, também é permitido gerar
classes de acesso ao banco de dados a partir de tabelas selecionadas pelo usuário. O aplicativo
desenvolvido utiliza templates para definição do código de saída. Dessa forma obtém- se
flexibilidade na geração de código e é possível gerar classes para várias linguagens de
programação. Para facilitar o processo de geração de código, foi construído um motor de
templates, tendo em vista que não foi encontrada uma ferramenta adequada para ser utilizada
com a linguagem Object Pascal.
A utilização da linguagem Object Pascal juntamente com o ambiente de
desenvolvimento Delphi 7 mostrou-se adequada para a construção e depuração da ferramenta.
Os conceitos de programação orientada a objetos utilizados permitiram que o código fosse
escrito de forma organizada facilitando o entendimento e o suporte.
Em relação a outras ferramentas similares, o presente trabalho possui um diferencial
que é permitir a geração de classes para qualquer linguagem desde que seja fornecido um
template para o código de saída.
A respeito dos resultados alcançados, a utilização da ferramenta mostrou-se eficaz. A
aplicação da mesma para o desenvolvimento de software obteve agilidade durante a fase de
codificação e qualidade com a padronização do código gerado. A única limitação apresentada
é o fato de a ferramenta reconhecer apenas o banco de dados Oracle, tendo em vista a
necessidade de permitir conexão com outros tipos de banco de dados.
74
4.1 EXTENSÕES
Como sugestão para trabalhos futuros, tem-se as seguintes:
a) permitir a utilização de outros bancos de dados como o PostGreSQL, SQLServer e
o MySQL;
b) permitir o reconhecimento das chaves estrangeiras de cada tabela no banco de
dados;
c) permitir construir e editar o arquivo de template na própria ferramenta;
d) alterar a linguagem do motor de templates de forma que o template possua
variáveis para informar a linguagem de programação desejada e seus respectivos
tipos de dados;
e) alterar a linguagem do motor de templates de forma que possa criar os scripts SQL
juntamente com a geração das classes;
f) permitir o usuário executar os scripts SQL na própria ferramenta;
g) permitir integração com diagramas DER de ferramentas comerciais como o Power
Designer e o Rational Rose;
h) criar um controle de histórico de alterações para facilitar a visualização de quais
tabelas foram alteradas e necessitam gerar código novamente.
75
REFERÊNCIAS BIBLIOGRÁFICAS
BOGGS, W.; BOGGS, M. Mastering UML with Rational Rose 2002. San Francisco: Sybex, 2002.
COELHO, L. F. Gerador de código HTML baseado em dicionário de dados utilizando banco de dados. 2006. 52 f. Trabalho de Conclusão de Curso (Bacharelado em Ciências da Computação) – Centro de Ciências Exatas e Naturais, Universidade Regional de Blumenau, Blumenau.
COX, T. B.Oracle workgroup server handbook. Berkeley: Osborne McGraw-Hill, 1995.
DATE, C. J. Introdução a sistemas de banco de dados. Tradução Contexto Traduções Ltda. Rio de Janeiro: Campus, 1990.
HARRINGTON, J. L. Projetos de banco de dados relacionais: teoria e prática. Rio de Janeiro: Campus, 2002.
HERRINGTON, J. Code generation in action. Greenwich, CT: Manning, 2003.
LEAL, M. D. ClassGenerator: um gerador de artefatos multiplataforma. 2005. 76 f. Trabalho de Conclusão de Curso (Bacharelado em Ciência da Computação) – Centro de Ciências Exatas e Naturais, Universidade Federal do Pará, Belém. Disponível em: <http://www.marcelioleal.net/marcelio/sapp/conteudo/presentation/TccFinal.pdf>. Acesso em: 17 mar. 2007.
MENEZES, P. F. B. Linguagens formais e autômatos. 2. ed. Porto Alegre: Sagra Luzzato, 1998.
ORACLE CORPORATION. Oracle SQL Developer. [S.l.], 2006. Disponível em: <http://www.oracle.com/global/tr/partner/04_Oracle_SQL_Developer.pdf>. Acesso em: 11 abr. 2007.
ORSI, V. Gerador de documentação para linguagem C, utilizando templates. 2006. 99 f. Trabalho de Conclusão de Curso (Bacharelado em Ciências da Computação) – Centro de Ciências Exatas e Naturais, Universidade Regional de Blumenau, Blumenau.
PRICE, A. M. A.; TOSCANI, S. S. Implementação de linguagens de programação: compiladores. 2. ed. Porto Alegre: Sagra Luzzatto, 2001.
ROCHA, L. APE: plataforma para o desenvolvimento de aplicações web com PHP. [Salvador], 2005. Disponível em: <http://twiki.im.ufba.br/bin/view/Aside/ProjetoConclusaoDeCursoAPEMonografia#4_2_Motores_de_templates>. Acesso em: 11 abr. 2007.
76
SANTOS, A. B. Desenvolvimento de ferramenta e processos para a geração automática de código Java a partir de um banco de dados. 2005. 90 f. Trabalho de Conclusão de Curso (Bacharelado em Informática) – Universidade do Vale do Rio dos Sinos, São Leopoldo. Disponível em: <http://www.inf.unisinos.br/alunos/arquivos/TC_AndersonBestteti.pdf>. Acesso em: 11 abr. 2007.
SYBASE INC. PowerDesigner. [S.l.], 2007. Disponível em: <http://www.sybase.com/products/modelingmetadata/powerdesigner>. Acesso em: 11 abr. 2007.
77
APÊNDICE A – Exemplo de template e código de saída para a linguagem Java
Além do template criado para a linguagem Object Pascal, foi criado um template para
a linguagem Java (quadro 25). O objetivo era analisar o código gerado, complementando os
testes do motor de templates.<template>public class TTAB<tablename>{<fields> public <fieldtype> <fieldname>; <endfields>
public void carrega_propriedades(){
}} <endtemplate>
Quadro 25 – Template para linguagem Java
public class TTABMAQUINA{ public String NUMERO;
public String NOME_MAQUINA; public int TIPO_MAQUINA; public float CARGA_MAXIMA; public float CARGA_MINIMA; public int VELOCIDADE;
public void carrega_propriedades(){
}}
Quadro 26 – Código de saída esperado
78
APÊNDICE B – Aplicação da ferramenta no desenvolvimento de um sistema
A utilização de ferramentas de apoio durante o processo de desenvolvimento de
softwares possibilita melhorar o índice de produtividade. Dessa forma é possível reduzir
tempo e custos para codificação do aplicativo. Também é obtida qualidade do software com a
padronização do código e a conseqüente redução de erros.
As etapas para o desenvolvimento de um software podem variar conforme a
complexidade do projeto. Para um melhor desempenho ao utilizar a ferramenta, sugere-se as
seguintes etapas:
a) especificação do software e detalhamento dos requisitos;
b) definição do dicionário de dados;
c) geração de código: scripts SQL para criação do banco de dados e classes de acesso
a dados;
d) implementação e testes.
Depois de especificar o software e detalhar os requisitos funcionais, é necessário criar
o dicionário de dados. O dicionário de dados contém a estrutura das tabelas que fazem parte
do sistema. A ferramenta permite criar as tabelas com seus respectivos campos e índices. Uma
vez que a estrutura de tabelas esteja definida, é possível gerar código.
Uma alternativa para criação do metadados é a utilização de ferramentas como o
Power Designer. O Power Designer permite a confecção de diagramas DER e, a partir dos
diagramas, gera scripts SQL para criação do banco de dados. Assim como o Power Designer,
a ferramenta apenas gera os scripts SQL para criação do banco de dados, sendo que é
responsabilidade do usuário executá-los, para que o metadados seja criado efetivamente.
Programas como o SQL Plus, Acqua Data Studio ou PLSQL Developer podem ser utilizados
para execução dos scripts.
Para que a ferramenta execute a geração de código é necessário indicar qual arquivo de
template deve ser utilizado e a respectiva linguagem de programação para o qual serão
geradas as classes. Também é necessário indicar a opção de geração. Nesse caso deve-se
selecionar a opção para gerar scripts SQL e classes.
Após o código ser gerado, é possível criar o metadados do banco de dados e iniciar a
codificação do sistema. Com base nas classes geradas pela ferramenta o usuário deve concluir
o processo de implementação. O código das classes geradas pela ferramenta depende
unicamente do template fornecido pelo usuário, isto é, o usuário deve definir qual a finalidade
79
para a utilização do código. Segundo Herrington (2003, p. 28), os exemplos mais comuns da
utilização de geradores de código são:
a) geração passiva : o código gerado deve ser modificado pelo usuário, sem que o
gerador tenha responsabilidades pelo código alterado;
b) geração ativa: o código gerado é completo. Caso o usuário necessite modificar o
formato do código de saída, deve alterar o código do arquivo de template.
Sugere-se optar pela geração de código ativo. Dessa forma qualquer alteração do
dicionário de dados ou alteração de algum requisito não implicará em perda de código
implementado. Finalmente, após a conclusão da codificação das classes de acesso ao banco de
dados, o usuário deve implementar e testar o restante do sistema.
![[SAYÃO] Metadados para Preservação Digital](https://static.fdocumentos.com/doc/165x107/55cf97f8550346d03394c3a8/sayao-metadados-para-preservacao-digital.jpg)
![SESSÃO DE PÔSTERES - ABEDabed.org.br/congresso2013/trabalhos/APRESENTACOES_SESSAO_POSTER... · bd 12 - Trabalho Científico WIZIQ COMO FERRAMENTA AUDIOVISUAL EM CURSOS ON-LINE [A]](https://static.fdocumentos.com/doc/165x107/5c04151009d3f2a5198e2fea/sessao-de-posteres-bd-12-trabalho-cientifico-wiziq-como-ferramenta-audiovisual.jpg)
