protÓtipo de um atualizador de banco de dados...
TRANSCRIPT
UNIVERSIDADE REGIONAL DE BLUMENAU
CENTRO DE CIÊNCIAS EXATAS E NATURAIS
CURSO DE CIÊNCIAS DA COMPUTAÇÃO – BACHARELADO
PROTÓTIPO DE UM ATUALIZADOR DE BANCO DE DADOS
INTERBASE UTILIZANDO XML
RANGEL JOSÉ BORDIN
BLUMENAU 2004
2004/2-41
RANGEL JOSÉ BORDIN
PROTÓTIPO DE UM ATUALIZADOR DE BANCO DE DADOS
INTERBASE UTILIZANDO XML
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ência da Computação — Bacharelado.
Prof. Wilson Pedro Carli – Orientador
BLUMENAU 2004
2004/2-41
PROTÓTIPO DE UM ATUALIZADOR DE BANCO DE DADOS
INTERBASE UTILIZANDO XML
Por
RANGEL JOSÉ BORDIN
Trabalho aprovado para obtenção dos créditos na disciplina de Trabalho de Conclusão de Curso, pela banca examinadora formada por:
______________________________________________________ Presidente: Prof. Wilson Pedro Carli Orientador, FURB
______________________________________________________ Membro: Prof. Alexander Roberto Valdameri, FURB
______________________________________________________ Membro: Prof. Oscar Dalfovo, FURB
Blumenau, dia de mês de ano
Dedico este trabalho a todos os amigos, especialmente aqueles que me ajudaram diretamente na realização deste.
AGRADECIMENTOS
À Deus, pela minha existência e todos os dons que me deu, para mim chegar aqui.
À meus pais Agenor Bordin e Oneida Pratto Bordin, que sempre estiveram juntos
comigo, e depositaram a confiança em mim dando todos os incentivos necessários.
Aos meus irmãos Anderson Bordin e Eduardo Bordin, que me incentivaram e exigiram
de mim.
À todos os professores os professores do Curso de Bacharelado em Ciências da
Computação da Universidade Regional de Blumenau em especial o professor Wilson Pedro
Carli pela orientação deste trabalho.
Aos amigos que acreditaram em mim e me incentivaram direta ou indiretamente para a
execução deste trabalho.
Também quero agradecer a todos os colegas de faculdade que conviveram comigo e
passaram pelas mesmas barreiras que passei, convivendo diariamente comigo.
A todos muito obrigado.
RESUMO
O trabalho apresenta um protótipo que permite atualizar um banco de dados Interbase utilizando XML, o protótipo será utilizado gerar arquivos XML com as estruturas das bases de dados. A partir dos arquivos XML faz a comparação entre as estruturas de dados e gera o script SQL de alteração fazendo a atualização da base de dados desatualizada.
Palavras chaves: Banco de Dados; XML.
ABSTRACT
The work presents a prototype that allows to update a database Interbase using XML, the prototype will be used to generate XML files with the structures of the bases of data. Starting from the files XML to do the comparison among the structures of data and to generate the script alteration SQL making the updating of the base of data no updated.
Key-Words: Databases; XML.
LISTA DE ILUSTRAÇÕES
Figura 1 – Objetos do Banco de Dados....................................................................................16 Quadro 1 – Sintaxe para criação de tabelas....................................................................................17 Quadro 2 – Exemplo de criação de tabelas....................................................................................17 Figura 2: A XML é independente do meio...............................................................................26 Figura 3 – A estrutura de um documento XML .......................................................................27 Figura 4 – A estrutura de um banco de dados em XML...........................................................27 Quadro 3 - Lista de livros em XML..........................................................................................28 Figura 5: Aplicações trocando dados através da Web..............................................................29 Quadro 4 - Declaração do elemento livro.................................................................................30 Quadro 5 – Exemplo elementos e subelementos......................................................................31 Quadro 6 – Exemplo elementos, subelementos aninhados.......................................................31 Quadro 7 – Exemplos de nomes válidos...................................................................................32 Quadro 8 – Exemplos de nomes inválidos................................................................................32 Quadro 9 - Utilização de atributos............................................................................................33 Quadro 10 - Elemento vazio.....................................................................................................33 Figura 6 - A árvore do catálogo de endereços...........................................................................34 Quadro 11 - Elementos pais......................................................................................................34 Figura 7 - Diagrama de Contexto..............................................................................................36 Figura 8 - DBA seleciona base de dados..................................................................................36 Figura 9- Leitura do metadados da base de dados atualização.................................................38 Figura 10: Leitura do metadados da base de dados produção...................................................38 Figura 11: Gerar arquivo XML.................................................................................................39 Figura 12: Gerar arquivo SQL..................................................................................................39 Figura 13: Atualizar base de dados atualização........................................................................39 Figura 14 – Ambiente de desenvolvimento do Delphi .............................................................40 Figura 15 – Banco de dados Interbase......................................................................................41 Quadro 12 – Script SQL que faz a leitura dos dominios..........................................................41 Quadro 13 – Script SQL que faz a leitura das tabelas tabelas..................................................42 Quadro 14 – Script SQL que faz a leitura dos campos das tabelas...........................................42 Figura 16: Procedure que gera a nodo dos domínios no arquivo XML...................................43 Figura 17: Procedure que compara as estruturas de domínios dos arquivos XML..................44 Figura 18: Continuação código fonte comparação de domínios...............................................45 Figura 19: Continuação código fonte comparação de domínios...............................................46 Figura 20: Continuação código fonte comparação de domínios...............................................47 Figura 21: Continuação código fonte comparação de domínios...............................................48 Figura 22: Continuação código fonte comparação de domínios...............................................49 Figura 23: Tela principal do Protótipo......................................................................................50 Figura 24 – Domínios da base antiga .......................................................................................52 Figura 25 – Tabelas da base antiga...........................................................................................52 Figura 26 – Lista de domínios depois da atualização...............................................................52 Figura 27 – Lista de tabelas depois da atualização...................................................................52
LISTA DE TABELAS
Tabela 1 – Uma lista de livros em um banco relacional...........................................................28
LISTA DE SIGLAS
DBA – Administrador de Banco de Dados
DFD – Diagrama de Fluxo de Dados
MER – Modelo Entidade Relacionamento
SGBD – Sistema Gerenciador de Banco de Dados
SGML – Standard Generalized Markup Language
UDF – User-defined Function
XML – Extensible Markup Language
SUMÁRIO
AGRADECIMENTOS...........................................................................................................III
RESUMO.................................................................................................................................IV
ABSTRACT..............................................................................................................................V
LISTA DE FIGURAS.............................................................................................................VI
LISTA DE TABELAS............................................................................................................VI
1 INTRODUÇÃO..................................................................................................................12
1.1 OBJETIVOS......................................................................................................................13
2 SISTEMA DE BANCO DE DADOS................................................................................14
2.1 SISTEMA GERENCIADOR DE BANCO DE DADOS..................................................14
3 INTERBASE ......................................................................................................................16
3.1 CONSTRUINDO BANCO DE DADOS ..........................................................................16
3.2 TABLES............................................................................................................................17
3.3 COLUMNS........................................................................................................................18
3.4 DATA TYPES...................................................................................................................19
3.4.1 TIPOS DE DADOS NUMÉRICOS................................................................................19
3.4.2 TIPOS DE DADOS DE CARACTERES .......................................................................19
3.4.3 TIPOS DE DADOS DE DATA ......................................................................................19
3.4.4 TIPOS DE DADOS BLOB .............................................................................................19
3.4.5 TIPOS DE DADOS ARRAYS........................................................................................20
3.4.6 DOMAINS ......................................................................................................................20
3.5 INTEGRIDADE REFERENCIAL.....................................................................................20
3.6 INDEXES ...........................................................................................................................21
3.8 STORED PROCEDURES..................................................................................................21
3.9 TRIGGERS.........................................................................................................................22
3.10 EVENT ALERTERS........................................................................................................23
3.11 USER-DEFINED FUNCTIONS ......................................................................................23
3.12 GENERATORS................................................................................................................24
3.13 EXCEPTIONS..................................................................................................................24
4 EXTENSIBLE MARKUP LANGUAGE.........................................................................25
4.1 APLICAÇÃO DA XML....................................................................................................26
4.1.1 APLICAÇÕES DE DOCUMENTOS.............................................................................26
4.1.2 APLICAÇÕES DE DADOS...........................................................................................27
4.1.3 ANALISADORES SINTÁTICOS DE XML .................................................................30
4.1.4 ELEMENTOS DO XML ................................................................................................31
4.1.4.1 NOMES EM XML .......................................................................................................32
4.1.4.2 ATRIBUTOS................................................................................................................33
4.1.4.3 ELEMENTOVAZIO ....................................................................................................34
4.1.4.4 ANINHAMENTO DE ELEMENTOS ........................................................................ 34
5 PROTÓTIPO PROPOSTO ..............................................................................................36
6 CONCLUSÕES..................................................................................................................54
REFERÊNCIAS BIBLIOGRÁFICAS .................................................................................56
12
1 INTRODUÇÃO
Atualmente muitas empresas de software trabalham desenvolvendo aplicativos e a
cada tempo determinado pela empresa são lançadas novas versões destes aplicativos. São
várias as empresas que trabalham desta maneira. Uma software house pode ter diferentes
versões de seu sistema instaladas em seus clientes. Quando surge a necessidade de atualizar o
banco de dados de um cliente, caso não houver compatibilidade da nova versão do software
com a base de dados do cliente, é bem possível que ocorram problemas na implantação desta
versão no cliente, daí a necessidade de um atualizador de base de dados. Assim, a empresa
gera o script de alteração para qualquer versão, sem precisar se preocupar com o que será
alterado, apenas executando o programa de atualização.
Para atualizar o banco de dados de um cliente a empresa desenvolvedora necessita ter
um controle preciso de que versão de base de dados está no cliente e o que será necessário
alterar na base do cliente para ficar com a versão a ser implantada. O script de alteração da
base de dados pode variar de cliente para cliente, dependendo da versão em que se encontra o
cliente no momento, tendo assim a necessidade de vários scripts de atualização. Se este
controle não for seguido, a atualização da base de dados será complexa, sendo necessária
comparação com a base que será implantada e alterada de acordo com as diferenças entre
tabelas, campos e procedimentos.
Com isto, surgiu a idéia de desenvolver um aplicativo atualizador de base de dados,
que venha fazer a comparação entre a estrutura da base de dados do cliente e a estrutura da
nova base de dados, indicando as diferenças e gerando o script de alteração da base de dados
automaticamente. O protótipo do programa foi desenvolvido para atualizar bases de dados em
banco de dados Interbase, disponível na Internet fabricado pela Borland utilizado por vários
desenvolvedores. Segundo Oliveira (2000, p. 4), o Interbase contêm definições e valores por
tabelas, índices, validação de dados, gatilhos, procedimentos, que são armazenados em um
único arquivo. Neste arquivo também estão as tabelas do sistema onde contêm todas as
informações das bases de dados.
Através das tabelas do sistema Interbase é possível reunir todas as informações
necessárias para a atualização da Base de Dados. O protótipo permitirá a atualização de uma
base de dados para outra base de dados onde se quer chegar, distinguindo tabelas, campos,
relacionamentos, procedimentos, geradores, domínios, funções e índices. A estrutura do banco
13
de dados, as diferenças e a base de dados atual estarão disponíveis em um arquivo XML, de
fácil visualização ao usuário.
1.1 OBJETIVOS
O objetivo principal desta proposta é desenvolver um protótipo de um atualizador de
base de dados para um SGBD Interbase.
O protótipo tem como objetivos específicos:
a) gerar script SQL para atualização de tabelas, campos, relacionamentos,
procedimentos, geradores, domínios;
b) gerar estruturas das bases de dados em arquivos XML;
c) fornecer opção de atualização automática da base de dados.
1.2 ESTRUTURA DO TRABALHO
O trabalho foi elaborado a fim de demonstrar as tecnologias utilizadas, as etapas do
trabalho e também o código elaborado no desenvolvimento do protótipo. O trabalho segue
dando uma breve apresentação dos sistemas de banco de dados, também apresenta o banco de
dados Interbase. Também são apresentadas noções sobre a linguagem XML utilizada no
protótipo. Após os fundamentos teóricos é apresentado o desenvolvimento do protótipo
proposto e por fim as conclusões sobre o protótipo desenvolvido.
14
2 SISTEMA DE BANCO DE DADOS
Um sistema de banco de dados é um sistema que permite armazenar as informações
relevantes e específicas dos trabalhos dos usuários, mantendo estas informações centralizadas.
O sistema de banco de dados é feito de duas partes: o “Sistema Gerenciador de Banco de
Dados (SGDB)” que gerencia estas informações e outra que é o “aplicativo” um programa
que é responsável pela interface, restauração e atualização destes dados. Os sistemas de
bancos de dados podem estar armazenados no computador onde estão sendo executados,
chamados de locais, ou também podem resistir em outros terminais da rede, chamados assim
de bancos de dados Cliente/Servidor.
2.1 SISTEMA GERENCIADOR DE BANCO DE DADOS
O SGDB é responsável por fornecer um tipo de serviço de definição de dados, com o
intuito de definir os registro e campos, fornece ainda um mecanismo interno para manter estes
dados no disco e saber onde se encontra cada elemento em particular. Ainda fornece uma
maneira de inserir, consultar, atualizar, eliminar estes dados. Estes serviços também podem
ser fornecidos pelo aplicativo de banco de dados.
Segundo Salemi (1993 p. 4), ter os dados em disco e reavê-los quando quisermos não
serve para nada se não acreditarmos que os dados são precisos. O SGBD precisa fornecer
algum tipo de “integridade de dados” para garantir que ele não sejam corrompidos no meio
exterior, como por falhas de disco ou falta de energia. Ele tem, ainda, a difícil tarefa de
proteger o banco de dados contra alterações não intencionais, causas por usuários ou
aplicativos. Esses serviços são particularmente importantes para bancos de dados
multiusuários, no qual um ou mais usuários podem, ao mesmo tempo, atualizar o mesmo
dado. O SGDB tem de garantir que somente uma das alterações realmente aconteça, e deverá
notificar os outros usuários sobre a mudança feita. Um banco de dados pode armazenar
qualquer tipo de informação que o usuário desejar, mas para ser útil, os dados devem ser
armazenados de acordo com seus domínios. Um domínio é a categoria, e o tipo dos elementos
permitidos em um campo particular, como por exemplo, um conjunto de caracteres
alfabéticos, todas as palavras da língua inglesa ou somente números inteiros. De modo geral,
esse serviço é a tarefa mais importante que um SGBD pode ter. Quanto mais responsabilidade
15
ele tem de prover isso, melhor a integridade dos dados de todo o sistema de banco de dados.
Para harmonizar tudo isso, um SGBD oferece os seguintes serviços:
a) definição de dados fornece um método para definir e armazenar uma população de
dados
b) manipulação dos dados fornece serviços que permitem ao usuário inserir, atualizar,
eliminar e classificar dados.
c) apresentação dos dados fornece, opcionalmente, algum método de apresentação dos
dados para o usuário.
d) integridade dos dados fornece um ou mais métodos para assegurar a precisão dos
dados.
16
3 INTERBASE
Segundo Borland (1995 p. 9), o Interbase é um sistema SGBD, que prove
processamento e compartilhamento de dados em monousuário ou multiusuário. O Interbase é
uma tecnologia de servidor que oferece suporte transparente através de redes heterogêneas. O
Interbase é executado sob sistemas Windows 95, Windows NT, Novell NetWare, e em muitas
implementações em sistemas operacionais baseados em Unix.
O Interbase é executado em Windows 95 e Windows NT sob duas formas: Local
Interbase (monousuário) e Interbase Server (remoto, multiusuário). Ambos os servidores vem
com ferramentas clientes Windows: Windows ISQL para definição de e manipulação de
dados e Server Manager para usuários autorizados e administração do banco de dados.
CONSTRUINDO BANCO DE DADOS
Para criar um banco de dados e seus componentes, o Interbase usa uma implementação
do SQL conforme o padrão ANSI SQL-89 e segue especificações SQL-92 e SQL3 beta para
formas avançadas.
De acordo com Borland (1995 p. 24), construir um banco de dados envolve definição
de dados. Para este propósito, o Interbase provê conjunto de declarações chamado de
linguagem de definição de dados.
Um banco de dados de Interbase é um único arquivo que inclui todos os metadados e
dados do banco de dados, cada arquivo possui a estrutura de seus metadados. Para criar um
banco de dados Interbase, usa-se o Windows ISQL ou linha de comando-linha ISQL. Abaixo,
na figura 1 apresenta-se os objetos do banco de dados.
17
Fonte: Borland (1995, p. 24)
Figura 1: Objetos do Banco de Dados.
Um banco de dados consiste em uma variedade de objetos de banco de dados, como
tables, views, domains, stored procedures, triggers, functions e outros objetos. Objetos de
banco de dados contêm toda a informação sobre estrutura do banco de dados, devido
encapsularem informações sobre os dados, objetos de banco de dados algumas vezes são
chamados de metadados.
3.1 TABLE
Para Borland (1995 p.25), bancos de dados relacionais armazenam todos seus dados
em tables (tabelas). Uma tabela é uma estrutura de dados que consiste em um conjunto de
linhas desordenadas horizontais, cada linha contém o mesmo número de colunas verticais. A
intersecção de uma linha individual e uma coluna é um campo que contém um pedaço
específico de informação. Muito do poder de bancos de dados de relacionais vem de definir as
relações entre as tabelas.
Conforme Oliveira (2000 p. 75), a sentença de criação de tabelas no Interbase é
composta de diversos parâmetros, utilizados para configurar o armazenamento físico. Esses
parâmetros devem ser otimizados pelo DBA, que é um profissional com grande experiência e
conhecimento profundo de banco de dados. Para criar tabela, deve-se utilizar o comando
Create Table, que tem a seguinte sintaxe:
18
create table <nome da tabela> [external file <NomedoArquivo]>] ( <DefColuna> [, <Defcoluna > | <Restrição> ...] );
Fonte: Oliveira (2000, p. 75) Quadro 1 – Sintaxe para criação de tabelas
Exemplo:
create table Empregado ( Codigo integer, Nome varchar, Sobrenome varchar, Salário integer, NomeCompleto computed by (Nome || “” || Sobrenome), /*...*/ );
Fonte: Oliveira (2000, p. 75) Quadro 2 – Exemplo de criação de tabelas
onde:
<nome da tabela>: é o nome da tabela que desejamos criar.
<nome do arquivo>: indica o nome do arquivo de dados externo no qual ser guardada a
tabela.
<nome da coluna>: é o nome da coluna (campo) que se deseja criar.
3.3 COLUMNS
Para criar uma tabela envolve principalmente as definições de colunas da tabela. Os
principais atributos de uma coluna incluem:
a) O nome da coluna;
b) O tipo de dados ou o domínio ao qual é definido;
c) Se é permitido ou não gravar nulo em uma coluna;
d) Criação opcional de integridade referencial.
19
3.4 DATA TYPES
Os dados são armazenados em um formato predefinido chamado de um data type (tipo
de dado). Tipos de dados podem ser classificados em quatro categorias: numéricos, caracteres,
data and BLOB. O tipo de dados numérico envolve os tipos inteiros, double-precision e
valores de ponto flutuantes. Tipos de dados de caracteres envolvem string de texto. Tipos de
dados de data são usados para armazenar data e valores de tempo. Interbase também suporta
arrays destes tipos de dados padrões.
3.4.1 TIPOS DE DADOS NUMERICOS
Tipos de dados numéricos são: SMALLINT, INTEGER, FLOAT, DOUBLE
PRECISION, NUMERIC, e DECIMAL. A maioria destes corresponde a um tipo de dado
similar em C. Por exemplo, SMALLINT tipicamente corresponde a short em C, e DOUBLE
PRECISION corresponde a double. Quando comparado ou nomeado para diferentes tipos
numéricos, o Interbase controla muitas conversões automaticamente.
3.4.2 TIPOS DE DADOS DE CARACTERES
Tipos de dados de caracteres são CHAR e VARCHAR. Eles permitem armazenar
múltiplos strings de caracteres em uma coluna. CHAR e VARCHAR diferem do modo que são
tratados caráter extras. O tipo de dado CHAR usam todos os caracteres até o fim da ordem,
mas o tipo de dado VARCHAR difere por aceitar o caractere NULO.
3.4.3 TIPOS DE DADOS DE DATA
O tipo de dado DATE são usados para armazenar datas e valores de tempo. O
Interbase controla o armazenamento e comparação entre strings e datas. Valores em strings
que representam data podem estar em diferentes formatos, como “12-1-94” e “1 de dezembro
de 1994”. Também dá suporte à outras constantes de datas como “HOJE”, “TOMORROW”.
3.4.4 TIPOS DE DADOS BLOBS
De acordo com Borland (1995 p.27), o Interbase da suporte a um tipo de dado BLOB
que pode armazenar dados de tamanho de sem limite. O tipo de dado BLOB é análogo a um
arquivo plano porque podem ser armazenados dados BLOB em qualquer formato (por
20
exemplo, binário ou ASCII). Porém, um BLOB não é um arquivo separado. O tipo BLOB é
armazenado no banco de dados com todos os outros dados. Porque uma coluna BLOB contêm
freqüentemente dados grandes, e variáveis, colunas BLOB são armazenadas e acessadas em
segmentos.
Conversão de dados de BLOB para outros tipos de dados em Interbase não é
diretamente suportado, mas em algumas plataformas, filtros de BLOB podem traduzir dados
BLOB de um formato BLOB para outro.
3.4.5 TIPOS DE DADOS ARRAYS
O Interbase aceita arrays de todos os tipos de dados, exceto BLOB. Um array é uma
coleção de valores, ou elementos, cada um do mesmo tipo de dado. Arrays de elementos
individuais, blocos de elementos contíguos, ou a ordem inteira pode ser acessada usando
declarações de SQL padrões e com chamadas a API.
3.4.6 DOMAINS
Declara os dados a serem inseridos nas colunas, o Interbase permite definições globais
de colunas, ou domains nos quais podem ser feitas certas definições. Um domínio especifica
um tipo de dado, seta atributos e integridades. Subseqüente, outras tabelas podem usar o
domínio definido em suas colunas.
3.5 INTEGRIDADE REFERENCIAL
Conforme Borland (1995 p. 27), o Interbase permite você definir regras de
integridades para uma coluna, chamadas de integridades referenciais. Integridades referenciais
governam relacionamentos de coluna para tabela e tabela para tabela e valida os dados de
entrada. Elas são implementadas através de chaves primárias, chaves estrangeiras, restrições.
Basicamente uma chave primaria, é uma coluna (ou grupo de colunas) que identificam
unicamente uma linha na tabela. Uma chave estrangeira é uma coluna de que o valor precisa
estar inserido em uma coluna de outra tabela. Uma restrição de checagem limita dados de
entrada e especifica o intervalo ou conjunto de valores.
21
3.6 INDEXES
Indexes (Índices), são mecanismos para dar velocidade na consulta aos dados. Um
índice identifica a coluna que pode ser usada para consultar e ordenar as linhas eficientemente
na tabela. Provê um meio para pesquisar apenas um subconjunto de linhas da tabela,
melhorando a velocidade de acesso aos dados.
Segundo Oliveira (2000), o Interbase cria índices de forma automática para manter as
restrições de chave primária e de integridade referencial. Na maioria dos casos, estes índices
são suficientes para que o sistema funcione eficientemente, porém, em algumas condições é
necessário definir índices sobre outras colunas. Esta decisão depende da freqüência com que
se realizem consultas de valores armazenados nelas e a possibilidade de “pedir” que uma
tabela se ordene de acordo com os valores definidos.
Os índices criados pelo Interbase são sensíveis a letras maiúsculas e minúsculas e
todos são mantidos por omissão. O conceito de índice por expressões e condição de filtro é o
mesmo da filosofia SQL, porém este tipo de índices não se adapta facilmente a otimização
automática de consultas.
3.7 STORED PROCEDURES
De acordo com Borland (1995 p. 28), uma stored procedure éum programa auto-
suficiente escrito em procedimento de Interbase, uma extensão do SQL. São partes do
metadado do banco de dados que podem receber parâmetros de entrada e retornar valores para
as aplicações, e podem ser executados explicitamente em aplicações ou substituir o nome de
uma tabela em uma instrução SELECT.
Stored procedure provê:
a) Design Modular: stored procedures podem ser compartilhadas por aplicações que
acessam o mesmo banco de dados, eliminando código duplicado e reduzindo o
tamanho das aplicações.
b) Manutenção de Streamlinead: quando uma procedure é atualizada, as alterações
são refletidas automaticamente em todas as aplicações que usam o banco sem a
necessidade para recompilar ou conectar novamente ao banco.
22
c) Desempenho melhorado: especialmente para acesso de clientes remotos. Stored
procedures são executadas pelo servidor, não no cliente, isto reduz o trafego na
rede.
3.8 TRIGGERS
Em Oliveira (2000 p.106) é colocado que é uma das possibilidades mais importantes
nos bancos de dados relacionais são os triggers, que são Stored Procedures ativadas
automaticamente ao se executar operações de modificação sobre tabelas de bancos de dados.
A diferença para os triggers de outros sistemas de banco de dados é que os do
Interbase se definem para uma só operação sobre uma tabela. Se compartilhar o código para
eventos de atualização de uma ou de várias tabelas, pode-se colocar este código em uma
Stored Procedure e chamá-lo em todos os triggers.
Conforme Borland (1995 p. 29), uma trigger é uma rotina auto-suficiente associada
com uma table ou view que automaticamente executa uma ação quando uma linha na table ou
view é inserida, atualizada, ou apagada.
Triggers podem prover:
a) Execução automática de restrição de dados para assegurar que os usuários entre só
com valores validos em colunas.
b) Manutenção de aplicação reduzida, porque mudanças para um trigger são
automaticamente refletidas em todas as aplicações que usam a mesma tabela sem
necessidade de recompilar a aplicação.
c) Log automático de mudanças em tabelas. Uma aplicação pode manter um tronco de
mudanças por um trigger que é executado quando a tabela for alterada.
d) Alertas de eventos em triggers podem ser automaticamente notificar as aplicações
de alterações no banco de dados.
Quando uma trigger é invocada, tem dados de acesso imediato que são armazenados,
modificados ou apagados. O triggers também podem acessar dados em outras tabelas. Usando
os dados disponíveis, os triggers podem ser projetados para:
23
a) Abortar uma operação, possivelmente com uma mensagem de erro.
b) Atribuir valores ao registro acessado.
c) Inserir, atualizar, ou apagar colunas em outras tabelas.
d) Sinalizar quando um evento ocorreu usando o alerta de eventos.
3.9 EVENT ALERTERS
De acordo com Borland (1995 p. 29), um Event Alerter (Alerta de Eventos) é uma
mensagem passada do banco de dados para a aplicação, sinalizando a ocorrência de um
evento do banco de dados. Um evento é uma modificação ou um conjunto de modificações no
banco de dados que é importante para a aplicação.
Um alerta de evento pode ser enviado diretamente de uma aplicação ou de um trigger.
Se um trigger é usado, pode-se definir o evento de notificação quando houver uma inserção,
atualização, ou apagado algum registro em uma determinada tabela. Pode-se usar de triggers
para determinar as condições específicas do evento. Assim, um evento poderia ser bem desde
“uma linha foi armazenada na tabela X”, ou mais específico, como “o preço de Y excedeu seu
valor avaliado”. Uma aplicação pode deixar de processar e pode esperar por qualquer número
de eventos para acontecer. Alternativamente, a aplicação pode receber notificação de eventos
assincronamente, permitindo executar outro trabalho até ser interrompido pelo alerta de
eventos.
3.10 USER-DEFINED FUNCTIONS
Conforme Borland (1995 p. 30), uma user-defined function (UDF) é um programa
com linguagem de servidor que é executado no servidor e é chamado através de aplicações de
banco de dados. Uma vez declarada a UDF em um banco de dados, qualquer aplicação que
usa o banco de dados pode usar a função ao acessar dados.
UDFs são usados para executar tarefas customizadas, freqüentemente usadas em
aplicações, para computações estatísticas, ou para conversões de dados que não são apoiadas
diretamente pelo Interbase.
24
3.11 GENERATORS
Segundo Oliveira (2000 p. 108), o generator é um recurso do Interbase para
disponibilizar valores seqüenciais. Um generator é criado do mesmo modo que as Stored
Procedures e triggers.
3.12 EXCEPTIONS
De acordo com Oliveira (2000 p. 109), as exceptions (excessões) são utilizadas para
parar instruções SQL, sendo esta operação necessária para simular restrições de propagação
em cascata de integridade referencial. As exceções do Interbase são criadas associando uma
cadeia de mensagens a um identificador.
25
4 EXTENSIBLE MARKUP LANGUAGE (XML)
Segundo Marchal (2000 p. 8), a XML é uma nova linguagem de marcação
desenvolvida pela W3C (World Wide Web Consortium) principalmente para solucionar as
limitações da HTML. A W3C é a organização encarregada em desenvolver e manter a maior
parte dos padrões da Web, principalmente HTML. A HTML é uma linguagem de marcação
extremamente popular, inicialmente para publicação de documentos na Web. No princípio,
em sua primeira versão, a HTML tinha cerca de uma dúzia de tags, com o passar das versões
este número foi aumentando. Hoje a versão mais recente (HTML 4.0) tem cerca de cem tags
(sem contar os tags específicos do navegador). Com isto a HTML não é mais uma linguagem
pequena, as combinações de tags são quase infinitas e os resultados esperados podem ser
diferentes de um navegador para outro.
A XML não surgiu para substituir a HTML, ao menos a curto e médio prazo. A XML
criou novas possibilidades. Segundo Marchall (2000 p. 9), algumas das áreas, a curto prazo
em que o XML será útil são:
a) Manutenção de grande site Web. A XML trabalharia para simplificar a criação de
documentos HTML;
b) Troca de informações entre organizações;
c) Descarga e recarga de bancos de dados;
d) Conteúdo publicado, onde o conteúdo está disponível a diversos sites Web;
e) Aplicações de comercio eletrônico, onde diferentes organizações colaboram para
atender um cliente;
f) Aplicações científicas com novas linguagens de marcação para fórmulas
matemáticas e químicas;
g) Livros eletrônicos com novas linguagens de marcação para expressar direitos e
propriedade;
h) Dispositivos portáteis e telefones inteligentes com novas linguagens de marcação
otimizadas para esses dispositivos alternativos;
26
i) Com a crescente demanda no mercado de dispositivos portáteis como Palm, e pelo
baixo poder de processamento destes equipamentos para processar páginas HTML,
a necessidade de uma linguagem mais simples é necessária. A XML trouxe-se duas
mudanças essenciais em relação ao HTML que são:
- Não predefine tag nenhum, ou seja, o autor cria as tags de que precisar.
- É uma linguagem mais estrita, ou seja, sua sintaxe é mais simples que a do
HTML,
- por exemplo, muitos desenvolvedores de sites utilizam editores HTML, não se
preocupando com o código HTML gerado, tornando estas páginas maiores e
mais lentas, um problema para os dispositivos portáteis que não pode fazer
transferência de navegadores com mais de 10 MB. Uma linguagem mais estrita
resulta em navegadores menores, mais velozes e mais leves.
4.1 APLICAÇÃO DA XML
Segundo Marchal (2000 p. 32), a XML não é uma linguagem feita apenas para
publicação de sites Web. As aplicações da XML são classificadas basicamente em dois tipos:
aplicações de documentos que manipulam informações voltadas principalmente ao consumo
humano; e aplicações de dados que manipulam informações voltadas principalmente para o
consumo do software. O padrão XML é o mesmo para estes dois tipos, implementado com as
mesmas ferramentas mas para atender objetivos diferentes.
4.1.1 APLICAÇÕES DE DOCUMENTOS
A principal vantagem do uso da XML para este tipo de aplicação é que a XML se
concentra na estrutura do documento e o torna independente do meio de distribuição. Desta
maneira é preciso somente editar estes arquivos serão publicados automaticamente nos
diferentes meios, como ilustrado na figura 2.
27
Fonte: Marchal (2000, p. 33)
Figura 2: A XML é independente do meio.
Por exemplo, numa empresa o desenvolvimento de um site pode ser otimizado para
um browser específico como o internet explorer, quando esta empresa tiver um cliente que
necessite este site sem erros de script em outro browser, surge a necessidade de uma nova
versão dos site. Neste sentido seria útil a utilização de um formato independente do meio,
como o XML, basta converte-lo automaticamente para os formatos de publicação HTML.
Quanto maior a quantidade de mídia e quanto maior for o documento, mais importante será o
papel de automatização da publicação.
4.1.2 APLICAÇÕES DE DADOS
Algumas linguagens que vieram surgindo como a Standard Generalized Markup
Language (SGML), tinha o objetivo de fornecer acesso a banco de dados e outras
ferramentas. Segundo Marchal (2000 p. 34), com o XML, o círculo foi fechado, pois ela traz
uma espécie de distribuição de dados para publicação. Isso leva ao conceito de “a aplicação
como o documento”, onde, por fim, não há diferenças entre documentos e aplicações. Na
verdade, se a estrutura de um documento pode ser expressa em XML, como ilustrado na
Figura 3, a estrutura de um banco de dados também pode, conforme ilustrado na Figura 4.
28
Fonte: Marchal (2000, p. 34)
Figura 3 – A estrutura de um documento XML.
Fonte: Marchal (2000, p. 34)
Figura 4 – A estrutura de um banco de dados em XML.
29
Na Tabela 1, abaixo, temos uma lista de livros em um banco de dados relacional:
Código Título Autor Páginas
01 Projetos de Bancos de Dados Relacionais Jan L. Harrington 360
02 Fundamentos do Desenho Orientado a
Objeto com UML
Larry L. Constantine 462
03 Strategic XML W. Scott Means 245
04 Princípios de Análise e Projeto de
Sistemas com UML
Eduardo Bezerra 286
05 Criando uma Loja Virtual em ASP Adelize Oliveira 283
Tabela 1: Uma lista de livros em um banco relacional.
Abaixo na tabela 2, mesma lista de livros em XML:
<?xml version=”1.0”?> <livros>
<livros cod=”01”>
<titulo>Projetos de Bancos de Dados Relacionais</titulo>
<autor>Jan L. Harrington</autor>
<paginas>360</paginas>
</livro>
<livros cod=”02”>
<titulo>Fundamentos de Desenho Orientado a Objeto com UML</titulo>
<autor>Larry L. Constantine</autor>
<paginas>462</paginas>
</livro>
<livros cod=”03”>
<titulo>Strategic XML</titulo>
<autor>W. Scott Means</autor>
<paginas>245</paginas>
</livro>
<livros cod=”04”>
<titulo>Princípio de Análise e Projetos de Sistemas com UML</titulo>
<autor>Eduardo Bezerra</autor>
<paginas>286</paginas>
30
</livro>
<livros cod=”05”>
<titulo>Criando uma Loja Virtual em ASP</titulo>
<autor>Jan L. Harrington</autor>
<paginas>283</paginas>
</livro>
Quadro 3 - Lista de livros em XML
Aplicando estes conceitos podemos fazer troca de informações entre as empresas, bem
como a publicação de alguns destes dados na Web,.com uma extensão das extranets. Segundo
Marchal (2000 p. 35), a XML na Web é um grande banco de dados onde aplicações podem se
comunicar, como ilustrado na figura 5.
Fonte: Marchal (2000, p. 36)
Figura 5: Aplicações trocando dados através da Web.
No banco de dados de uma empresa podem estar informações de seus produtos que
estão disponíveis a usuários da internet assim como empresas. Com a utilização da XML
pode-se fazer uma atualização dinâmica destas informações, deixando estes usuários sempre
atualizados e o aplicativo das empresas clientes pode se comunicar com a XML e importar
estas informações atualizadas.
4.1.3 ANALISADORES SINTÁTICOS DE XML
São responsáveis por processar os documentos XML. Os aplicativos que quiserem
utilizar a XML devem ter seus próprios analisadores sintáticos de acordo com a estrutura da
31
XML. Esta analise sintática de documento pode ser feita de dois métodos diferentes: pela
análise sintática baseada em fluxo (stream) e pela análise sintática baseada em árvore (tree).
Os analisadores baseados em fluxo utilizam o documento como um fluxo de dados,
onde este fluxo é armazenado em um buffer de memória que a medida que forem encontrados
elementos XML eles são tratados e processados de acordo com o que o programador quer
fazer. O principal fato de uso de analisadores baseados em fluxo é por serem rápidos e
utilizarem pouca memória. O modelo mais popular de análise por fluxo é o SAX, ou Simple
Application Progamming Interface for XML.
Os analisadores baseados em árvores constroem o documento XML como se fosse
uma árvore formada por raiz, nós e subnós. Este é a análise mais utilizada, e a mais fácil,
porém apresenta algumas desvantagens em relação a análise baseada em fluxo que seria o
consumo da memória. Quanto maior for o documento XML mais memória precisará ser
alocada. O DOM ou Document Object Model é o mais popular dos modelos de análise
baseada em Arvore.
4.1.4 ELEMENTOS DO XML
Segundo Martinsson (2002 p. 25), os documentos XML são constituídos por
elementos do XML. O elemento do XML é um contêiner de informações com nome e
descritivo. Esse contêiner é formado por uma marca (tag) de abertura e uma marca de
fechamento, e entre as marcas, encontra-se o conteúdo, ou valor, do elemento do XML.
Abaixo, podemos ver a declaração do elemento Livro com o conteúdo Banco de Dados
Interbase com Delphi:
<?xml version=”1.0”?> <Livro>Banco de Dados Interbase com Delphi</Livro>
Quadro 4 – Declaração do elemento livro
Estes elementos podem conter subelementos. Esses subelementos devem estar
envolvidos por um único elemento chamado de elemento de nível mais alto ou nível-raiz.
Abaixo temos um exemplo onde podemos ver o elemento raiz “Livro” com seus subelementos
“Titulo” e “Autor”:
32
<?xml version=”1.0”?> <Livro>
<Titulo>Banco de Dados Interbase com Delphi</Titulo> <Autor>Wilson José de Oliveira</Autor>
</Livro>
Quadro 5 – Exemplo elementos e subelementos
Se tivéssemos mais Livros o documento XML se tornaria mais complexo, e os
elementos livros deverão ser aninhados adequadamente. Se aninhados apropriadamente, o
documento XML se torna organizado e auto-explicativo. Se fossemos inserir mais um livro no
exemplo anterior, nosso elemento de alto nível seria perdido. O analisador sintático reclama,
quando não existe o elemento de nível raiz. Desta maneira teríamos que criar um novo
elemento de nível mais alto chamado “Livros”. Tornando assim nosso documento mais
extensível:
<?xml version=”1.0”?> <Livros>
<Livro> <Titulo>Banco de Dados Interbase com Delphi</Titulo> <Autor>Wilson José de Oliveira</Autor> </Livro> <Livro> <Titulo>Banco de Dados Cliente/Servidor</Titulo> <Autor>Joe Salemi</Autor> </Livro>
</Livros> Quadro 6 – Exemplo elementos, subelementos aninhados
4.1.4.1 NOMES EM XML
Os nomes em XML seguem certas regras, necessariamente tem que começar com o
caractere sublinado (_) ou com uma letra. Os demais caracteres devem ser letras, sublinados,
ponto (.) ou hífen (-). Não são permitidos espaços em branco e o nome não pode começar com
a string ‘xml’, que é reservada para a própria especificação XML. Letras maiúsculas e
minúsculas são diferenciadas em XML.
33
Alguns exemplos de nomes válidos são:
<livro>
<a>
<nome.cliente>
<pré-nome>
Quadro 7 – Exemplos de nomes válidos
Alguns exemplos de nomes inválidos, que não devem ser usados:
<123>
<nome cliente>
<joão&silva>
Quadro 8 – Exemplos de nomes inválidos
Existem algumas convenções utilizadas para nomenclatura dos elementos. Aqui vou
descrever as mais comuns, mas existem outras convenções. Por convenção, os elementos
HTML nos documentos XML aparecem sempre em maiúsculas, os elementos XML são
escritos em minúsculas. Quando um elemento possui um nome com várias palavras, estas
palavras normalmente por convenção são separadas por hífen como “Código-Cliente”, outra
convenção é iniciar com maiúscula a primeira letra de cada palavra como em
“CodigoCliente”.
4.1.4.2 ATRIBUTOS
Os elementos podem conter atributos que descrevem os objetos, anexando
informações. Os atributos possuem um nome e um valor, os nomes utilizando as mesmas
regras de nomes dos elementos. Os elementos podem ter vários atributos, os atributos são
declarados na tag de início e o nome do atributo deve ser separado de seu valor pelo sinal de
igualdade (=). O valor deve estar entre aspas ou apóstrofos. Abaixo um exemplo da utilização
de atributos em elementos, o elemento “Livro” possui um atributo classificação com o valor
“Bom”:
34
<?xml version=”1.0”?> <Livros>
<Livro Classificação=”Bom”> <Titulo>Banco de Dados Interbase com Delphi</Titulo> <Autor>Wilson José de Oliveira</Autor>
</Livro> </Livros>
Quadro 9 – Utilização de atributos
4.1.4.3 ELEMENTO VAZIO
Os elementos que não possuem conteúdo são considerados “elementos vazios”. Um
elemento vazio normalmente é usado para utilizar o valor de seu conteúdo. Existe uma
notação diferente para elementos vazios, onde é omitida a tag de fechamento e simplesmente
colocada uma barra antes da marca de fechamento da tag de inicio. No exemplo a seguir tem-
se o elemento email com o atributo href que possui o valor [email protected].
<?xml version=”1.0”?> <email href=”[email protected]”/>
Quadro 10 – Elemanto vazio
4.1.4.4 ANINHAMENTO DE ELEMENTOS
O documento XML é uma árvore de elementos, onde os elementos podem conter texto
ou outros elementos. Necessariamente todos os elementos do documento devem ser filhos de
um elemento que é o elemento raiz do documento XML e não existe um limite para o número
de elementos e nem um limite para a profundidade da árvore. Os elementos podem ter um
mesmo nome, veja na figura 6 abaixo:
35
Fonte: Marchal (2000, p.53)
Figura 6: A árvore do catálogo de endereços.
Os elementos que possuem outros elementos são chamados de pais, e os elementos
contidos nestes elementos pais são chamados de filhos. Os tags de fim dos elementos filhos
nunca aparecerão depois dos elementos pai, ficando sempre no limite de seu pai, como no
exemplo:
<?xml version=”1.0”?> <Clientes> <Cliente Cód=”01”> <Nome>João da Silva</Nome> <Sexo>Masculino</Sexo> <Idade>38</Idade> </Cliente>
<Cliente Cód=”02”> <Nome>Cláudia Machado</Nome> <Sexo>Feminino</Sexo> <Idade>20</Idade> </Cliente> </Clientes>
Quadro 11 – Elementos pais
36
5 DESENVOLVIMENTO DO TRABALHO
O interesse de desenvolver um protótipo de atualizador de banco de dados surgiu no
dia a dia onde se usava o Interbase como banco de dados numa aplicação que vários
estabelecimentos comerciais utilizavam. Os clientes usavam uma versão de um software
comercial enquanto era desenvolvida na empresa uma nova versão do sistema. Quando havia
a necessidade de atualizar um cliente, por solicitação de uma rotina nova, correções, ou
qualquer outro motivo, e quando estas atualizações envolviam alterações no banco de dados,
essas alterações deviam ser muito bem documentadas para na atualização serem efetuadas no
cliente. Com a idéia do atualizador, apenas executando o aplicativo no cliente bastaria para
deixar o banco de dados do cliente exatamente como deve ficar para a nova versão a ser
implantada.
Neste capítulo, serão apresentadas as etapas de desenvolvimento do aplicativo,
descrevendo todas as etapas de desenvolvimento, iniciando pela especificação, depois
implementação e desenvolvimento.
5.1 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO
Os principais requisitos do aplicativo atualizador de base de dados são:
a) permitir escolha das bases de dados a serem comparadas;
b) manter informações do banco de dados;
c) gerar documentos XML com as informações dos bancos de dados;
d) gerar script SQL de alteração;
e) permitir atualização automática;
f) atualizar banco de dados;
Seu principal foco é voltado para a atualização do banco de dados, com o aplicativo de
atualização, o usuário (DBA) não irá se preocupar com as estruturas, apenas atualizar os
dados.
37
5.3 ESPECIFICAÇÃO
A metodologia utilizada foi a análise estruturada, utilizando a ferramenta Power
Designer para representação. A especificação segue até o diagrama de fluxo de dados, não
havendo necessidade de uma representação do modelo entidade relacionamento (MER).
5.3.1 DIAGRAMA DE CONTEXTO
No diagrama estão representadas as entidades externas envolvidas.
Figura 7: Diagrama de Contexto
5.3.2 DIAGRAMA DE FLUXO DE DADOS
Na figura 8, temos o DFD que representa o DBA selecionando as bases de dados:
Figura 8: DBA seleciona base de dados.
38
Na Figura 9, abaixo, está representando o aplicativo fazendo a leitura do metadados da
base de dados da atualização:
Figura 9: Leitura do metadados da base de dados atualização.
Na figura 11, representa o aplicativo fazendo a leitura do metadados da base de dados
produção, que servirá de modelo para a base dados de atualização:
Figura 10: Leitura do metadados da base de dados produção.
39
Na figura 11, tem-se o DFD representando o arquivo XML que deverá ser gerado para o DBA:
Figura 11: Gerar arquivo XML
Na figura 12, tem-se o DFD representando o arquivo SQL que deverá ser gerado para
o DBA:
Figura 12: Gerar arquivo SQL.
Na figura 13, o DFD representando a atualização da base de dados de atualização:
Figura 13: Atualizar base de dados atualização.
40
5.3.1 TÉCNICAS E FERRAMENTAS UTILIZADAS
Para implementação do protótipo foram utilizadas as ferramentas Delphi 7 (na figura
7), onde mostra o ambiente de desenvolvimento desta ferramenta e os componentes utilizados
para conexão com o banco de dados Interbase e também o componente utilizado para gerar os
arquivos XML.
Figura 14: Ambiente de desenvolvimento do Delphi
41
Na figura 8, é apresentado o IBConsole do Banco de dados Interbase que permite o
gerenciamento do banco de dados. Nesta figura é visualizado os objetos do banco de dados, e
mostrando mais em específico as tabelas de um banco de dados exemplo.
Figura 15: Banco de dados Interbase
Com o Delphi, através dos componentes da paleta Interbase, foi possível fazer a
conexão com os bancos de dados, e utilizar queries com scripts SQL que permitem a extração
dos metadados dos bancos de dados. Abaixo no quadro 12 tem-se o script utilizado para
retirar as informações referentes aos domínios:
SELECT * FROM RDB$FIELDS WHERE RDB$SYSTEM_FLAG<>1 AND
RDB$FIELD_NAME NOT LIKE 'RDB$%' ORDER BY RDB$FIELD_NAME
Quadro 12 – Script SQL que faz a leitura dos dominios
No quadro 13 abaixo está o script para retirar as informações do metadado das tabelas:
42
SELECT RDB$RELATION_NAME from RDB$RELATIONS WHERE
RDB$RELATION_NAME NOT LIKE 'RDB$%' ORDER BY
RDB$RELATION_NAME
Quadro 13 – Script SQL que faz a leitura das tabelas.
No quadro 14 está o script para retirar as informações do campo da tabela, onde é
passado como parâmetro o nome da tabela, através da propriedade master source da query.
Trazendo assim informações referentes aos campos da tabela passada como parâmetro:
SELECT * FROM RDB$RELATION_FIELDS where RDB$SYSTEM_FLAG<>1
AND RDB$RELATION_NAME = :RDB$RELATION_NAME ORDER BY
RDB$FIELD_POSITION
Quadro 14 – Script SQL que faz a leitura dos campos das tabelas.
Existe no Delphi um componente da paleta Internet chamado de “XML Document”,
que permite criar e manipular arquivos do tipo XML. Percorrendo a query após feita a leitura
e manipulando o componente XML Document foi possível criar os nodos das estruturas lidas.
43
No figura 16 abaixo está o código fonte para gerar as estruturas dos domínios:
Figura 16: Procedure que gera a nodo dos domínios no arquivo XML
As estruturas para generators, tabelas e campos de tabelas foram feitas de maneira
semelhante, apenas obedecendo suas partivularidades.
Depois de gerados os arquivos XML das duas estruturas de dados, é feita então a
comparação entre as estruturas destes arquivos através da manipulanção o componente XML
Document.
Abaixo, na figura 17, está o código fonte que faz a comparação entre os domínios:
44
Figura 17: Procedure que compara as estruturas de domínios dos arquivos XML.
45
Figura 18: Continuação código fonte comparação de domínios.
46
Figura 19: Continuação código fonte comparação de domínios.
47
Figura 20: Continuação código fonte comparação de domínios.
48
Figura 21: Continuação código fonte comparação de domínios.
49
Figura 22: Continuação código fonte comparação de domínios.
3.4 APRESENTAÇÃO DO PROTÓTIPO
Nesta etapa, será demonstrada a utilização do aplicativo passo a passo, de acordo com
a funcionalidade do mesmo.
O protótipo do aplicativo atualizador dispõe apenas de uma tela principal, onde estão
todas as informações necessárias para o processo de atualização. Na tela principal, o DBA irá
escolher o banco de dados do cliente a ser atualizado e também o banco de dados ao qual se
quer comparar, entrando com os respectivos usuários e senhas. Também nesta tela estarão
disponíveis opções para o DBA escolher o que atualizar no banco de dados como tabelas,
índices, domínios, etc. A tela também permite uma visualização em grids de quais
informações estão sendo extraídas. O DBA poderá escolher em que diretório serão gerados os
arquivos XML, gerar um arquivo SQL com os scripts de alteração de base, também pode
50
escolher uma opção de atualização automática de banco de dados. Quando o aplicativo é
executado, a primeira janela, sua janela principal e única abrirá. A Figura 16 abaixo mostra a
janela principal do protótipo:
Figura 23: Tela principal do Protótipo.
De acordo com a numeração na tela da figura acima será demonstrada a
funcionalidade da tela do atualizador. As funcionalidades são as seguintes:
a) O DBA irá selecionar o arquivo de extensão (*.GDB) do banco de dados atual
(modelo de banco de dados).
b) Nome do usuário do banco de dados atual;
51
c) Senha do usuário do banco de dados atual;
d) O DBA selecionará o banco de dados que será atualizando, selecionando o arquivo e
(*.GDB).
e) Nome do usuário do banco de dados que será atualizado;
f) Senha do usuário do banco de dados que será atualizado;
g) O DBA irá escolher um diretório para serem armazenados os arquivos XML e
também o script SQL se posteriormente ele optar por esta opção. O nome dos
arquivos XML gerados serão “BaseAtual.xml“ para a base atual e “BaseAntiga.xml”
para a base de dados que será atualizada. O nome do arquivo SQL será
“CriaBanco.sql”;
h) O DBA irá escolher as estruturas do banco de dados a serem atualizadas;
i) O DBA irá utilizar está opção se quiser que o sistema forneça um script SQL de
alteração;
j) Se marcar está opção o programa irá fazer uma atualização automática da base de
dados a ser atualizada.
k) Permite visualizar as estruturas que estão sendo geradas. Só para fins de visualização.
Após as etapas acima é só pressionar o botão rodar para que o aplicativo execute de
acordo com as opções selecionadas. No lado direito, é possível visualizar as estruturas que
estão sendo geradas no arquivo XML.
Na figura 17 e 18 abaixo, está o banco de dados que será atualizado, nota-se que o
banco de dados não apresenta nenhum domínio e nenhuma tabela criada.
52
Figura 24: Domínios da base antiga. Não existe domínio criado
Figura 25: Tabelas da base antiga. Não existe nenhuma tabela no banco de dados.
53
Após o DBA pressionar o botão “rodar”, o programa cria as estruturas exatamente
como se encontra no banco de dados exemplo do Interbase Employee. Podemos verificar na
figura 19 e figura 20.
Figura 26: Lista de domínios depois da atualização
Figura 27: Lista de tabelas depois da atualização
54
6 CONCLUSÕES
Após o término deste trabalho, concluiu-se que os objetivos foram atingidos. Os
arquivos XML foram gerados a partir dos bancos de dados selecionados pelo DBA. Os scripts
SQL de alteração foram gerados para domínios, generators, exceptions, e criação de tabelas.
Mas bastou para demonstrar a técnica utilizada, sendo que para as outras estruturas o princípio
é o mesmo, apenas mudariam as regras de comparação. À partir do arquivo SQL gerado foi
possível fazer a atualização automática. Foi efetuada a criação dos documentos XML e
posteriormente a comparação entre as estruturas criadas nestes documentos. Pode-se verificar
como válida a utilização da linguagem XML para armazenar as estruturas de bases de dados,
bem como a comparação entre elas, manipulando os documentos criados. A geração dos
scripts de alteração foram feitas para algumas estruturas como generators, domínios. Outras
estruturas funcionam de maneira parcial, como as tabelas, que devido a complexidade e
quantidade de restrições de integridades referenciais dificultaram o estudo. Foi de grande
dificuldade também descobrir os campos necessários (o que cada campo significava) para a
atualização na estrutura do banco de dados Interbase, algumas sendo sanadas através do guia
de usuário. Outra dificuldade encontrada foi na maneira de manipular o arquivo XML, ainda
desconhecidas no princípio, mas de fácil domínio depois da aprendizagem. Foram criados
scripts de SQL, estes um pouco dificultosos, mas precisos, que possibilitaram extrair as
informações das bases de dados e após este armazenagem no documento XML.
Acredita-se que aplicações possam ser criadas a partir desta. Um exemplo seria um
aplicativo que pode utilizar dos arquivos XML gerados para importar as informações do
metadados utilizado para um controle de versões. A utilização de uma ferramenta deste porte
se tornará viável a empresas que utilizam o banco de dados Interbase e tem suas bases de
dados ou de seus clientes alteradas constantemente.
Com este trabalho pode-se ter um melhor entendimento dos objetos que compõe um
banco de dados relacional, mas especificamento o Interbase. Sugestões para trabalhos futuros
seria criar os scripts de alteração das estruturas não geradas, e criar as rotinas que gerem o
arquivo XML, e o script SQL de criação/alteração de views, permitindo atualizar
automaticamente.
Quanto às ferramentas utilizadas para fins de implementação, a ferramenta Rational
Rose possibilitou a criação do diagrama de casos de usos , assim como o Power Designer
55
mostrando-se eficiente na implementação das demais etapas da metodologia da análise
estruturada. O ambiente de programação Delphi deu todos os recursos necessários para a
criação e manipulação dos documentos XML.
56
REFERÊNCIAS BIBLIOGRÁFICAS
BORLAND INTERBASE. Data Definition Guide. Scotts Valley: Borland International, 1995.
CANTU, Marco. Dominando o Delphi 3. São Paulo: Makron Books, 1997.
CARDOSO, Caíque. UML na prática: do problema ao sistema. Rio de Janeiro: Ciência Moderna, 2003.
DEITEL, et al. XML : como programar. Tradução Luiz Augusto Salgado e Edson Furmankiewicz. São Paulo: Bookman, 2003. 972 p.
HARRIGTON, Jan L. Projetos de bancos de dados relacionais: teoria e prática. Rio de Jameiro: Campus, 2002.
HEUSER, Carlos Alberto. Projeto de banco de dados. Porto Alegre: Sagra Luzzato, 2000.
KERN, Vinícius Medina. Bancos de dados relacionais: teoria e prática de objetos. São Paulo: Èrica, 1994.
KORTH, Henry F; SILBERSCHATZ, Abraham. Sistema de banco de dados. São Paulo: Makron Books, 2. edição, 1993. 748p.
LIGHT, Richard. Iniciando em XML . São Paulo: Makron Books, 1999. 404 p.
MARCHAL, Benoît. XML: conceitos e aplicações. Tradução Daniel Vieira. São Paulo: Berkeley, 2000.
MARTINSSON, Tobias. Desenvolvendo Scripts XML e WMI para o Microsoft SQL Server 2000. São Paulo: Makron Books, 2002.
MEANS, Scott. Strategic XML. Indianápolis: Sams, 2002. 247 p.
MULLER, Robert. Projeto de banco de dados: usando UML para modelagem de dados. Tradução Bazan Tecnologia e Lingüística. São Paulo: Berkeley Brasil, 2002.
OLIVEIRA, Wilson. Banco de dados Interbase com Delphi. Florianópolis: Visual Books, 2000.
PAGE-JONES, Melir. Fundamentos do desenho orientado a objeto com UML. São Paulo: Makron Books, 2001.
57
RUMBAUGH, James et. al. Modelagem e Projetos baseados em Objetos. Rio de Janeiro: Campus, 1994.
SILVA, Ivan. Interbase 6: guia do desenvolvedor. Rio de Janeiro: Book Express, 2000.
SONNINO, Bruno. Desenvolvendo aplicações em Delphi 5. São Paulo: Makron Books, 2000.