Cache

CACHÉ
Banco de Dados Pós-Relacional
Flávio Rubens de Carvalho Sousa

frcsousa@gmail.com
Copyright (c) – 2005 – Flávio Sousa

Este trabalho está licenciado sob uma Licença Creative Commons
Atribuição – UsoNãoComercial – Compartilhado pela mesma licença.
Para ver uma cópia desta licença, visite
http://creativecommons.org/licences/by-nc-sa/2.0/br/ ou envie
uma carta para Creative Commons, 559 Nathan Abbott Way,
Stanford, California 94305, USA.
Dedico este trabalho aos meus pais.
2
“Primeiro faça o necessário;
Depois faça o possível;
e, de repente, você vai perceber
que pode fazer o impossível”
São Francisco de Assis
3
Agradecimentos
Agradeço:
• a Deus, por está sempre ao meu lado, dando-me coragem para enfrentar
todos os obstáculos da vida.
• aos meus pais, Francisco de Sousa Isidório e Maria Edileusa de Carvalho,
que jamais pouparam esforços na abençoada tarefa de me fazer feliz.
• A minha namorada, Kaluce Gonçalves, a cujo amor e dedicação, devo alto
percentual de minhas realizações.
• aos professores Flávio Ferry, Francisco Vieira, Kelson Aires, Vinícius
Machado, Raimundo Moura e aos demais professores do DIE pelo
incentivo e pela dedicação à atividade docente.
• a Igor Feliciano e Thiago Correia por toda a atenção comigo e a todos os
meus amigos que de alguma forma contribuíram nesta jornada.
• a Amir Samary e a InterSystems do Brasil pelo apoio e confiança no
desenvolvimento desse trabalho.
4
Resumo
Atualmente pode-se notar que vem se tornando cada vez mais difundido o
uso da tecnologia de orientação a objetos no desenvolvimento de aplicações. No
entanto, a maior parte dos sistemas gerenciadores de banco de dados (SGBDs)
utilizados nos últimos anos são baseados no modelo relacional.
O modelo relacional é baseado na relação entre tabelas. Entretanto, esse
modelo não atende à demanda, cada vez mais complexas das aplicações, que
utilizam imagens e multimídia.
Para suprir as limitações do modelo relacional surgiram várias soluções, como
Frameworks, os sistemas gerenciadores de bancos de dados orientados a objetos
(SGBDOO) e o objeto-relacional (SGBDOR).
Os Frameworks realizam o mapeamento de objeto para SBBDs relacionais.
Contudo, seu uso é especifico e acrescenta mais camadas ao sistema.
O modelo orientado a objetos é baseado no conceito de classes e utilizam
encapsulamento, herança e polimorfismo. A grande vantagem do uso de um
SGBDOO consiste em que os objetos podem ser armazenados de forma
transparente. Porém, os SGBDOOs ainda apresentam pouca maturidade e robustez.
Os SGBDs objeto-relacionais dão suporte ao modelo relacional estendido
com certos conceitos de orientação a objetos. Contudo, esse modelo não apresenta
as características da orientação a objetos de forma simples, o que faz com que ele
termine sendo utilizado como o SGBD relacional.
Neste contexto, a melhor solução seria unir as características dos modelos
relacionais e orientados a objetos de forma eficiente, permitindo ao SGBD um ganho
substancial de performance.
O Caché é um banco de dados banco de dados pós-relacional que realiza
esta união, pois possui suporte a objetos e tabelas.
Este trabalho apresenta um estudo sobre o SGBD Caché, destacando a
arquitetura unificada de dados, a integração com tecnologias e o desenvolvimento
de aplicações.
Palavras-chaves : Orientação a Objetos, Banco de Dados, Caché.
5
Sumário
1 Introdução........................................................................................ 13
2 Noções de Orientação a Objetos...................................................16
2.1 Abstração...............................................................................................16
2.2 Objeto......................................................................................................16
2.3 Identidade de Objeto............................................................................ 17
2.4 Obetos Compexos................................................................................ 17
2.5 Classes.......................................................................... ....................... 17
2.6 Herança................................................................................................. 18
2.7 Métodos e Mensagens..........................................................................18
2.8 Polimorfirmo......................................................................................... 19
2.9 Encapsulamento.......................................................................... ........ 19
3 Modelo Pós-Relacional Caché....................................................... 20
3.1 Arquitetura............................................................................................ 20
3.2 Características............................................................................ ......... 21
3.3 Objetos.................................................................................................. 22
3.4 Tipos de Classes.................................................................................. 22
3.4.1 Dados........................................................... ...................................... 23
3.4.2 Objetos............................................................................ ................... 23
3.4.3 Não-Registradas................................................................................. 23
3.4.4 Registradas............................................................................ ............ 23
3.4.5 Embutidas........................................................................................... 24
3.4.6 Persistentes........................................................................................ 24
3.5 Linguagens........................................................... ................................ 24
3.5.1 Programação............................................................................ .......... 24
3.5.1.1 Caché ObjectScript...........................................................................24
3.5.1.2 Caché Basic............................................................................ ........ 25
3.5.2 Consulta............................................................................ ................. 25
3.6 Elementos de Classes........................................................... .............. 25
3.6.1 Métodos.............................................................................................. 26
3.7 Referências e Identidades................................................................... 26
3.8 Relacionamento entre Classes........................................................... 26
3.8.1 Referencias Simples........................................................................... 26
3.8.2 Relacionamentos........................................................................... ..... 27
3.8.3 Composição........................................................................................ 28
3.8.4 Foreing Key Relacional....................................................................... 28
3.9 Objetos e Tabelas ........................................................... .................... 28
4 Ambiente de Desenvolvimento.................................................... . 29
4.1 Namespaces............................................................................ ............. 29
4.2 Caché Studio............................................................................ ............ 30
4.3 Integração com Tecnologias ...............................................................30
4.3.1 Rose Link............................................................................................ 31
4.3.2 SQL Gateway.................................................................. ................... 32
4.3.3 ActiveX.................................................................. ............................. 32
4.3.3.1 Visual Caché............................................................................ ....... 32
4.3.4 Java.................................................................. .................................. 32
6
4.3.5 XML.................................................................. .................................. 33
4.3.5.1 Importação do XML...........................................................................33
4.3.5.2 Exportação do XML...........................................................................34
4.3.6 Web Services.......................................................................................34
5 CSP (Caché Server Pages)..............................................................34
5.1 Arquitetura CSP.................................................................... ............... 34
5.2 Caché Application Tags....................................................................... 36
5.3 Caché Web Form...................................................................................36
6 Estudo de Caso................................................................................37
6.1 Aspectos da Implementação................................................................37
6.2 Exportação do Diagrama de Classes................................................ . 38
6.3 Análise do Código Gerado................................................................... 39
6.4 Geração de Páginas CSP..................................................................... 40
7 Consideraçoes Finais..................................................................... 43
7.1 Conclusões........................................................................................... 43
7.2 Sugestões de Trabalhos Futuros........................................................ 43
8 Referências bibliográficas.............................................................44
Anexo: Código do estudo de caso.......................................................46
Índice de figuras
Figura 3.1: Arquitetura Caché ..................................................................................... 20

Figura 3.2: Formas de Acesso..................................................................................... 22
Figura 3.3: Tipos de Classes........................................... ............................................ 23
Figura 4.1: Namespaces.............................................................................................. 30
Figura 4.2: Caché Studio........................................................ ..................................... 30
Figura 4.3: SQL Gateway........................................................ .................................... 32
Figura 4.4: Projeção de Classes.................................................................................. 33
Figura 5.1: Arquitetura CSP......................................................................................... 35
Figura 6.1: Diagrama de Caso de Uso ........................................................ ............... 37
Figura 6.2: Etapas da Construção ........................................................ ...................... 38
Figura 6.3: Diagrama de Classe........................................................ .......................... 38
Figura 6.4: Exportação do Diagrama de Classe.......................................................... 39
Figura 6.5: Seleção de Propriedades........................................................ .................. 41
Figura 6.6: Página Pessoa........................................................ .................................. 41
Figura 6.6: Página de Pesquisa................................................................................... 42
Figura 6.6: Página Pedido........................................................ ................................... 42
8
Índice de listagens de código
Listagem 6.1: Classe Pessoa............................................................................... .......39

Listagem 6.2: Classe Endereco....................... ........................................................... 39
Listagem 6.3: Classe Cliente....................................................................................... 40
Listagem 6.4: Classe Pedido ...................................................................................... 40
Listagem 6.5: Pessoa.csp........... ................................................................................ 41
9
Índice de tabelas
Tabela 3.1: Objetos e Tabelas ....................... ............................................................. 28

Tabela 4.1: Componentes do Ambiente....................................................................... 29
Tabela 4.2: Ferramentas Integráveis ....................... ................................................... 31
Tabela 4.3: Correspondência de tipos com Rational Rose ......................................... 31
10
1 Introdução
Atualmente pode-se notar que vem se tornando cada vez mais difundido o
uso da tecnologia de orientação a objetos no desenvolvimento de aplicações[8].
Contudo, o modelo de dados mais utilizado por SGBDs (Sistemas Gerenciadores de
Banco de Dados) é o relacional[15].
A necessidade de armazenar e processar dados complexos em bancos de
dados relacionais vem aumentando à medida que surgem sistemas de informação
mais sofisticados, tais como aplicações multimídia para Web.
O modelo relacional está baseado em uma única estrutura de dados: a
relação. Uma relação é uma tabela com linhas (tuplas) e colunas (atributos), as
quais contêm um tipo de dado simples especificado (integer, character, string,...)[15].
Suporta uma pequena quantidade de tipos de dados que se mostram adequados
para aplicações convencionais. Isto provoca problemas no desenvolvimento de
aplicações que utilizam tecnologia de objetos. Os objetos podem ter estruturas
complexas e, neste caso, será necessário um esforço adicional de programação
para adaptá-los ao modelo relacional antes de armazená-los e outro para adequá-
los novamente ao modelo de objetos no momento de recuperá-los.
Para suprir as limitações do modelo relacional surgiram várias soluções, como
Frameworks, os sistemas gerenciadores de banco de dados orientados a objetos
(SGBDOO) e o objeto-relacional (SGBDOR).
Os frameworks são capazes de realizar o mapeamento objeto-relacional[9].
Um framework é uma aplicação reusável destinada ao mapeamento de objetos para
bancos de dados relacionais, o qual permite ao desenvolvedor concentre-se apenas
no modelo de objetos[13]. Contudo, diminuem o desempenho das aplicações,
atrasam significativamente o desenvolvimento das mesmas e acrescentam mais
camadas ao sistema.
Os SGBDOOs implementam de forma natural o modelo orientado a objeto,
isto é, os conceitos de classe, objeto, tipo, identidade, encapsulamento, herança,
agregação, método e polimorfismo[14] . Eles mantém uma correspondência direta
entre o mundo real e objetos de banco de dados de forma que objetos não percam
sua integridade e identidade e possam ser facilmente identificados e operados[16].
Além disso, possuem mecanismos especiais para controlar transações entre objetos
11
e técnicas de armazenamento que facilitam a recuperação rápida de objetos
complexos (clustering)[11]. O acesso aos objetos é mais versátil quando se utiliza
um SGBDOO, já que é possível fazê-lo de forma navegacional ou por meio de
linguagens do tipo SQL[5]. Usando SGBDRs, a única maneira de acessar os dados
é através de linguagens de consulta. Alguns fabricantes deste modelo fornecem o
acesso a dados através da linguagem Objetc Query Language (OQL). No entanto,
essa linguagem não têm aceitação generalizada[1].
Os SGBDORs são evolucionários, herdando transação robusta e
características de gerenciamento de performance da tecnologia relacional e adiciona
a flexibilidade da tecnologia orientada a objetos[16]. Pode-se trabalhar com
estruturas tabulares familiares, enquanto adiciona novas possibilidades de
gerenciamento de objetos[10]. No entanto, este modelo não foi concebido para
armazenar objetos, tornando a modelagem destes uma tarefa difícil. A linguagem de
consulta é SQL com extensões para cada banco, já que não existe um padrão.
Neste contexto, a melhor solução seria unir as características dos modelos
relacionais e orientados a objetos. Assim, as aplicações desenvolvidas poderiam
acessar dados de várias formas, permitindo uma integração entre as mesmas.
O SGBD Caché realiza esta união, pois possui suporte a tabelas e objetos. O
Caché é um banco de dados pós-relacional, com estrutura de dados
multidimensional, que combina as tecnologias de orientação a objetos e relacional
[4]. A arquitetura unificada de dados constrói uma camada de descrição para objetos
e tabelas relacionais que são mapeados diretamente em sua estrutura
multidimensional. Assim, aplicações relacionais podem coexistir com novos
componentes de negócios construídos com a tecnologia de objetos.
Todos os SGBDs desenvolvidos após o modelo relacional podem ser
chamados de pós-relacional. Esse é um termo freqüentemente utilizado para
designar bancos de dados multidimensionais que apresentam orientação a objetos.
Mas isso não é o suficiente. Eles refletem uma imagem do mundo real e atendem as
necessidades das aplicações atuais que apresentam dados complexos[7].
Cada uma das diversas tecnologias contidas no Caché é aplicada a
determinadas tarefas. A tecnologia de objetos é ideal para a modelagem de dados
complexos e a relacional favorece a análise de dados e a geração de relatórios.
12
Este trabalho apresenta um estudo sobre o SGBD Caché, destacando a
arquitetura unificada de dados, a integração com tecnologias e o desenvolvimento
de aplicações.
O trabalho encontra-se dividido da seguinte forma:
• Seção 2 - Noções de orientação a objetos.
• Seção 3 - Modelo Pós-Relacional Caché.
• Seção 4 - Ambiente de Desenvolvimento.
• Seção 5 - Tecnologia Caché Server Pages (CSP)[4].
• Seção 6 - Estudo de caso.
• Seção 7 - Conclusões e os Trabalhos Futuros.
13
2 Orientação a Objetos
Para compreender o desenvolvimento de aplicações utilizando o Caché é

essencial ter conhecimento dos principais conceitos da orientação a objetos.
Superficialmente, pode-se dizer que orientação a objetos corresponde à organização
de sistemas como uma coleção de objetos que integram estruturas de dados e
comportamento[1]. Seus principais conceitos são apresentados a seguir.
2.1 Abstração
É a consideração apenas das propriedades comuns de um conjunto de objetos,

omitindo os detalhes, utilizada com freqüência na definição de valores similares e na
formação de um tipo a partir de outro, em diferentes níveis de abstração. O uso de
abstrações permite a geração de tipos baseada em hierarquias de tipos e de
relacionamentos[6].
Os principais conceitos de abstração utilizados em banco de dados são
generalização e agregação. A generalização corresponde à associação "é um" onde,
a partir de propriedades comuns de diferentes entidades, é criada uma outra
entidade. O processo inverso é a especialização[2]. A agregação corresponde a
associação "parte de".
2.2 Objeto
Os objetos são abstrações de dados do mundo real, com uma interface de

nomes de operações e um estado local que permanece oculto[6]. As abstrações da
representação e das operações são ambas suportadas no modelo de dados
orientado a objetos, ou seja, são incorporadas as noções de estruturas de dados e
de comportamento. Um objeto tem um estado interno descrito por atributos que
podem apenas ser acessados ou modificados através de operações definidas pelo
criador do objeto. Um objeto individual é chamado de instância ou ocorrência de
objeto. A parte estrutural de um objeto (em banco de dados) é similar à noção de
entidade no modelo Entidade-Relacionamento.
14
2.3 Identidade de Objeto
Num modelo com identidade de objetos, estes têm existência independente de

seus valores correntes e dos endereços de armazenamento físico. A identidade do
objeto é geralmente gerada pelo sistema. A impossibilidade de garantir a
identificação de objetos exclusivamente através de suas propriedades estruturais e
comportamentais motivou a definição de identificadores únicos de objetos, que
persistem no tempo de forma independente ao estado interno do objeto.
A identidade de objetos elimina as anomalias de atualização e de integridade
referencial, uma vez que a atualização de um objeto será automaticamente refletida
nos objetos que o referenciam e que o identificador de um objeto não tem seu valor
alterado[1].
2.4 Objetos Complexos
Os objetos complexos são formados por construtores (conjuntos, listas, tuplas,

registros, coleções, arrays) aplicados a objetos simples (inteiros, booleanos, strings).
Nos modelos orientados a objetos, os construtores são em geral ortogonais, isto é,
qualquer construtor pode ser aplicado a qualquer objeto. No modelo relacional este
não é o caso, visto que só é possível aplicar o construtor de conjuntos às tuplas e o
construtor de registro a valores atômicos[1].
A manutenção de objetos complexos, independente de sua composição, requer
a definição de operadores apropriados para sua manipulação como um todo, e
transitivos para seus componentes. Um exemplo desta operação é a atualização ou
remoção de um objeto[6].
2.5 Classes
Um conjunto de objetos que possui o mesmo tipo (atributos, relacionamentos,

operações) pode ser agrupado para formar uma classe. A noção de classe é
associada ao tempo de execução, podendo ser vista como uma representação por
extensão, enquanto que o tipo é uma representação intencional. Cada classe tem
um tipo associado, o qual especifica a estrutura e o comportamento de seus objetos.
15
Assim, a extensão da classe denota o conjunto dos objetos atualmente existentes na
classe e o tipo provê a estrutura destes objetos[2].
2.6 Herança
Herança é um mecanismo que permite ao usuário definir tipos de forma

incremental, por refinamento de outros já existentes, permitindo composição de tipos
em que as propriedades de um ou mais tipos são reutilizadas na definição de um
novo tipo. De fato, ela corresponde a transferência de propriedades estruturais e de
comportamento de uma classe para suas subclasses.
As principais vantagens de herança são prover uma maior expressividade na
modelagem dos dados, facilitar a reusabilidade de objetos e definir classes por
refinamento, podendo fatorar especificações e implementações como na adaptação
de métodos gerais para casos particulares, redefinindo-os para estes, e
simplificando a evolução e a reusabilidade de esquemas de banco de dados[1].
Existem dois tipos de herança descritos a seguir:
• Herança Simples: Na herança simples um certo tipo pode ter apenas um

supertipo, da mesma forma uma subclasse só herda diretamente de uma
única classe.
• Herança Múltipla: Nesta herança um tipo pode ter supertipos e os mesmos
refinamentos de herança simples. Há basicamente dois tipos de conflitos
referentes à herança múltipla: entre o tipo e o supertipo e entre múltiplos
supertipos. O primeiro pode ser resolvido dando-se prioridade à definição
presente no tipo, e não a no supertipo[4]. Com os conflitos entre múltiplos
supertipos, como uma resolução por default pode causar heranças não
desejadas, a abordagem mais segura é baseada na requisição explícita da
intervenção do usuário.
2.7 Métodos e Mensagens
Um método, em relação a um objeto, corresponde ao comportamento dos

objetos, implementando uma operação associada a uma ou mais classes, de forma
16
similar aos códigos dos procedimentos usados em linguagens de programação
tradicionais, que manipula o objeto ou parte deste. Cada objeto tem um certo
número de operações para ele definida. Para cada operação pode-se ter um ou mais
métodos de implementação associados[1].
As mensagens são a forma mais usada para se ativar os métodos. Os objetos
se comunicam e são ativados através de mensagens enviadas entre eles.
2.8 Polimorfismo
Em sistemas polimórficos uma mesma operação pode se comportar de

diferentes formas em classes distintas. Como exemplo temos a operação print que
será implementada de forma diferente se o objeto correspondente for um texto ou
uma imagem: dependendo do objeto teremos um tipo de impressão. Tem-se
também polimorfismo quando ocorre a passagem de diferentes tipos de objetos
como parâmetros enviados a outros objetos. Um mesmo nome pode ser usado por
mais de uma operação definida sobre diferentes objetos, o que caracteriza uma
sobrecarga[1].
2.9 Encapsulamento
O encapsulamento possibilita a distinção entre a especificação e a

implementação das operações de um objeto, além de prover a modularidade que
permite uma melhor estruturação das aplicações ditas complexas, bem como a
segurança dentro do sistema. Em banco de dados se diz que um objeto está
encapsulado quando o estado é oculto ao usuário e o objeto pode ser consultado e
modificado exclusivamente por meio das operações a ele associadas[1].
17
3 Modelo Pós-Relacional Caché
O Caché é um SGBD Pós-Relacional que une os modelos relacional e

orientados a objetos[4]. Essa união permite que aplicações sejam construídas de
forma rápida, eficiente e aumentando a performance das mesmas. Possui suporte
as principais tecnologias, permitindo a integração entre novas soluções e aplicações
existentes.
3.1 Arquitetura
A arquitetura é o grande diferencial deste banco, pois permite a coexistência

de tabelas e objetos. Quando é definida uma classe e compilada, automaticamente é
gerada uma tabela relacional. Isso reduz o tempo de desenvolvimento e custos de
processamento, possibilitando que aplicações sejam construídas e executadas
rapidamente. A figura 3.1 mostra essa arquitetura.
Aplicações
Engine Engine
SQL Objetos
Máquina Virtual
Multi Dimensional
Figura 3.1: Arquitetura Caché.
Com essa arquitetura é possível armazenar dados de acordo com a

necessidade. As aplicações podem acessar dados através da linguagem SQL ou
diretamente, com métodos disponíveis para cada tecnologia. Por possuir uma
máquina virtual que compila as classes gerando o pcode[4], as aplicações
desenvolvidas podem ser executadas em outras plataformas.
Todos os dados são armazenados em vetores multidimensionais, que
permitem o armazenamento de dados complexos do mundo real, reduzem o tempo
de acesso e tornam os dados compactos, economizando espaço em disco. O
18
servidor de dados multidimensional é responsável pela performance e escalabilidade
do banco de dados.
O termo multidimensional significa que os dados podem ser indexados por
tantos parâmetros quanto forem necessários e não são limitados a linhas e colunas.
Isto permite modelos de dados mais ricos do que os obtidos no modelo relacional[4].
Dados complexos podem ser armazenados e utilizados de forma natural e intuitiva.
Armazenar objetos complexos não é simples, por que a informação precisa
ser fragmentada em tabelas, ocorrendo um empilhamento destas e causando um
maior processamento para reconstruir os objetos decompostos.
Dados multidimensionais não precisam ser reconstruídos. O servidor de
dados multidimensional elimina a sobrecarga de processamento, o que permite um
melhor desempenho.
3.2 Características
O Caché apresenta uma série de características que torna o desenvolvimento

de aplicações simples, rápido, seguro e com um baixo custo[7]. A seguir, são
apresentadas as principais características.
• Desempenho: com o acesso multidimensional de dados é possível
representar objetos complexos de forma simples, melhorando o
armazenamento e o acesso aos mesmos.
• Tecnologia avançada de objetos: suporta um modelo completo de
objetos, incluindo encapsulamento, polimorfismo, heranças múltiplas,
coleções e relacionamentos.
• Conectividade: dispõe de mecanismo para acessar outros bancos de
dados e permitir a integração de sistemas.
• Baixo Custo: demanda poucos recursos de hardware, permitindo alta
escalabilidade sem altos investimentos.
• Desenvolvimento rápido de aplicações Web: dispõe de tecnologia
Web própria, Caché Server Pages(CSP). Páginas CSP rodam dentro
do banco, o que melhora a performance das aplicações, pois não
precisam conectar ao banco para obter dados.
19
• Escalabilidade: utilizando o Enterprise Caché Protocol (ECP) é
simples distribuir cargas e construir esquemas de cluster[4].
• Portabilidade: por possuir uma máquina virtual, as classes Caché são
compiladas e podem ser executadas na maioria das plataformas, com
exceção da AS400 e de MainFrames.
3.3 Objetos
O Caché dispõe de várias formas de acesso a objetos. Isso permite a

integração com diversas tecnologias[7]. Para cada tecnologia são fornecidos objetos
que interagem com o banco. A figura 3.2 apresenta as formas de acesso.
O J
D D
XML SOAP COM EJB Java .Net C++ Web COS
B B
C C CSP
Basic
Caché
SQL Objetos Caché
Multi-Dimensional
Figura 3.2: Formas de Acesso.
3.4 Tipos de Classes
Devido aos diferentes tipos de classes é possível representar todas as

situações encontradas na construção de aplicações. A figura 3.3 mostra estes tipos
e uma hierarquia entre as mesmas[7].
20
Classes
Dados Objetos
Não Registradas Registradas
Embutidas Persistentes
Figura 3.3: Tipos de Classes
3.4.1 Dados
São classes que suportam apenas valores literais. Não possuem identidades
e não podem ser instanciadas. Estas classes existem somente como propriedades
de objetos.
3.4.2 Objetos
Estas classes definem uma estrutura e um comportamento. Podem ser

instanciados e cada objeto tem um único nome.
3.4.3 Não-Registradas
Classes deste tipo não são gerenciadas automaticamente pelo Caché. O

desenvolvedor é responsável pela administração da classe. Por não serem
controladas pelo banco de dados, elas não suportam polimorfismo.
3.4.4 Registradas
As classes registradas são administradas pelo gerenciador de banco de

dados e herdam da classe %RegisteredObject.
21
3.4.5 Embutidas
As classes embutidas são utilizadas para compor outras classes. Elas não
são armazenadas diretamente no banco de dados. Eles são carregadas na memória
principal e na momento do armazenamento são vinculadas a classes persistentes.
3.4.6 Persistentes
As classes persistentes podem ser armazenadas em disco e herdam de

%Persistent. São as classes mais utilizadas no Caché.
3.5 Linguagens
O Caché possui duas linguagens de programação: o Caché ObjectScript

(COS) e Caché Basic. Ambas foram projetadas para base de dados e lógica de
negócios de alta performance e suportam objetos, SQL e acesso multidimensional
de dados[4].
3.5.1 Programação
O Caché possui duas linguagens de programação: o Caché ObjectScript

(COS) e Caché Basic.
3.5.1.1 Caché ObjectScript
Caché ObjectScript é uma linguagem orientada a objetos, simples e

poderosa. Permite a interação de métodos de acesso aos dados, possibilitando uma
visão dos dados como objetos, tabelas relacionais ou arrays multidimensionais[7].
Além disso, não requer que todo o código faça parte do método de uma classe de
objetos.
22
3.5.1.2 Caché Basic
É uma linguagem similar ao VBScript e que possui as mesmas características

da linguagem descrita anteriormente[4]. A grande vantagem é que desenvolvedores
que trabalham Visual Basic não terão dificuldades em utilizar esta linguagem.
3.5.2 Consulta
SQL (com features do ANSI 92 e 2003 e extensões OO) é a linguagem de

consulta, pois a maioria das aplicações foram desenvolvidas utilizando essa
linguagem. Isso permite a total compatibilidade com os sistemas existentes[4].
3.6 Elementos de Classes
Uma classe descreve uma estrutura e um comportamento. Os elementos de

classes caracterizam e auxiliam na construção de classes eficientes [7].
Esses elementos são descritos a seguir:
• Nome único.
• Palavras Chaves (Keywords) – modifica a definição de classe.
• Propriedades – são dados, referência a objetos persistentes e objetos
embutidos.
• Métodos – código que adiciona funcionalidades.
• Parâmetros – valores que modificam o comportamento das classes
durante a compilação.
• Query – permite observar a instância de uma classe.
• Index – estrutura de armazenamento que otimiza o acesso a objetos.
Os tipos, métodos e componentes de classes são geralmente inicializados

pelo caractere “%” .
23
3.6.1 Métodos
Os métodos fornecem o acesso a classes e objetos[6]. Existem dois tipos

básicos de métodos:
• Métodos de Classes: são executados a partir de classes, isto é, são
métodos aplicados a classes e não a objetos. Exemplos: %OpenId,
%New, %DeleteId, etc.
• Métodos de Instância: métodos aplicados a objetos (instância de
classes). Exemplos: %Save, %Close.
3.7 Referências e Identidades
Objetos possuem duas formas de identificação :

• OREF – referência a um objeto em memória volátil.
• ID – identidade do objeto em disco. É possível ter mais de um objeto
com o mesmo ID em classes diferentes, mas nunca na mesma
classe[6].
3.8 Relacionamento entre Classes
O Caché possui diversas formas para relacionar objetos: Referência Simples,

Relacionamento, Composição/Agregação e Foreign Key relacional [6]. A seguir, é
descrito cada uma delas.
3.8.1 Referência Simples
Em uma referência simples, um objeto simplesmente aponta para um outro

objeto através de seu ID[7]. Caso o outro objeto seja excluído, o primeiro não será
notificado e qualquer acesso ocasionará erro de referencia inválida. Portanto, não
existe integridade referencial. Contudo, este tipo de referência apresenta vantagens:
• Performance: Se existe uma objeto que nunca será excluído, não
existe a necessidade de verificar sua existência.
24
• Encapsulamento/Acoplamento: Não é necessário checar a integridade
referencial, consequentemente não existe a propriedade inversa na
classe referenciada. Isto é útil quando existe uma objeto referenciado
por muitos outros. Qualquer classe pode acessar o objeto sem que o
mesmo faça nenhuma checagem.
3.8.2 Relacionamentos
Quando é preciso garantir a integridade referencial, impedindo que um objeto

seja excluído e ainda tenha referência para algum objeto, o ideal é utilizar
Relacionamentos.
Existem dois tipos de relacionamentos:
• Um para Muitos: Uma lista de objetos (L1, L2,...,Ln) podem
referenciar um objeto T. Cada objeto da lista possui uma
propriedade do tipo T e em T existe uma lista do tipo L. Não é
possível excluir T enquanto houver referências para o mesmo,
garantindo assim, a integridade referencial.
• Pai-Filho: Um objeto T referencia um ou mais objetos (L1, L2,...,Ln).
No objeto T existe uma lista do tipo L (filhos de T) e em L existe
uma propriedade do tipo T. Caso o objeto T seja excluído, todos os
objetos da lista L (L1, L2,...,Ln) serão excluídos também.
Os relacionamentos do tipo “Um para Um” e “Muitos para Muitos” não estão
presentes no Caché. Esse relacionamentos são implementados utilizando os
relacionamentos descritos anteriormente.
O relacionamento “Um para Um” pode ser implementado utilizando o “Um
para Muitos” e garantindo que exista apenas um objeto na lista mantida pela Caché.
Já o “Muitos para Muitos” pode ser implementado utilizando dois relacionamentos
“Um para Muitos” e uma classe de relacionamento[6].
25
3.8.3 Composição
Uma referência simples para um objeto de uma classe do tipo serial. Quando
o objeto que mantém referência é salvo, o objeto serial referenciado é salvo
juntamente com o mesmo [7].
3.8.4 Foreing Key Relacional
Um relacionamento entre objetos mantido através de uma ou mais colunas

que juntas representam um objeto (linha de outra tabela)[15].
3.9 Objetos e Tabelas
A arquitetura unificada proporciona uma correspondência entre objetos e

tabelas, mostrada na tabela 3.1. Isso permite a total compatibilidade entre aplicações
que utilizam objetos e tabelas.
Tabela 3.1: Objetos e Tabelas
Objetos Tabelas
pacote SQL schema
classe table
OID chave primária
referência para objeto chave estrangeira

persistente
objetos embutidos coluna individual
relacionamentos chave estrangeira
método de classe store procedure
26
4 Ambiente de Desenvolvimento
O Caché possui um ambiente completo de desenvolvimento e administração.

A tabela 4.1 exibe os componentes disponíveis e suas descrições.
Tabela 4.1: Componentes do Ambiente
Componente Descrição
Studio IDE de desenvolvimento usado para criar classes, páginas

Caché Server Pages (CSP) e rotinas.
Terminal Emula um terminal de comandos.
Explorer Gerenciar/administrar o banco de dados com suas classes

associadas, globais e rotinas.
Gerenciador SQL Gerenciar todos os aspectos de acesso relacional.
Painel de Controle Usado para administrar o sistema (operação e seus

processos).
Gerenciador de Utilizado para definir as configurações de sistema e rede.

Configuração
Acesso a sistemas Usado para acessar outros servidores.

Remotos
.
4.1 Namespaces
Namespace é uma área de trabalho associado a um diretório. Um namespace

contém projetos, que por sua vez, pode conter classes, rotinas, xml, javascript, html,
etc. Para cada namespace existe um arquivo cache.dat[6].
Quando o Caché é instalado, são criados alguns namespaces como o USER
(destinado a testes), SAMPLES, SYS.
27
C:\CacheSys\Mgr\User\cache.dat
USER
C:\CacheSys\Mgr\cachelib\cache.dat
SAMPLES C:\CacheSys\Mgr\Samples\cache.dat
Figura 4.1: Namespaces
4.2 Caché Studio
É um ambiente de desenvolvimento. Pode-se construir classes, páginas CSP,

HTML, Java, etc. Possui checagem de sintaxe e debug[4]. A figura 4.2 mostra este
ambiente.
Figura 4.2: Caché Studio
4.3 Integração com Tecnologias
O Caché integra-se com as principais tecnologias. Isto o torna uma solução

completa para desenvolvimento de aplicações[6]. É usado para cria classes e
escreve métodos e rotinas utilizando a linguagem mais adequada, como Java e
Basic, tudo em um único ambiente. A tabela 4.2 mostra algumas das ferramentas
que são integradas na instalação do produto, sem a necessidade de configurações
adicionais.
28
Tabela 4.2: Ferramentas integráveis.
Ferramenta Descrição
Visual Basic Acrescenta um Wizard para a criação automática de formulários

VB baseados em classes do banco.
Rational Rose Adiciona um Wizard para importar/ exportar classes de/para o

banco.
DreamWeaver Acrescenta um Wizard para a criação automática de páginas

CSP baseadas em classes do banco.
Configura um novo site no IIS apontando para as páginas CSP
ISS
O Apache é configurado para redirecionar chamadas para
Apache (Linux) páginas CSP para o Caché.
4.3.1 Rose Link
RoseLink é um plugin que estabelece a conexão entre o Caché a ferramenta

Rational Rose[12]. Suas características são as seguintes:
• Exportar diagramas da Unified Modeling Language(UML)[2] para classes
Caché.
• Importar classes do banco gerando diagramas da UML.
A tabela 4.3 mostra correspondência entre os principais tipos do Rose e do
Caché.
Tabela 4.3: Correspondências de tipos com Rational Rose.
Tipos do Rose Tipos do Caché
Byte %Integer
Date %Date
Double %Float
Integer %Integer
String %String
29
4.3.2 SQL Gateway
Permite o acesso à bancos relacionais, possibilitando a integração de

aplicações e dados[4]. Este acesso podem ser estabelecido através de tecnologias
com ODBC, JDBC[3], etc. A figura 4.3 exibe o SQL Gateway.
ODBC JDBC Gateway Oracle
SQL Server
Caché SQL
Informix
Multi Dimensional Sybase
Figura 4.3: SQL Gateway.
4.3.3 ActiveX
Qualquer aplicação capaz de instanciar componentes ActiveX pode instanciar

objetos diretamente no Caché sem qualquer configuração ou mapeamento. Visual
Basic, Delphi, etc, interagem com o banco de dados de forma transparente e
orientada a objetos[7].
4.3.3.1 Visual Caché
Link para o Visual Basic que possibilita a geração automática de formulários a

partir de classes do banco. São gerados métodos básicos de acesso ao bancos, tais
como inserir, excluir e pesquisar[4].
4.3.4 Java
Java é uma linguagem de programação orientação a objetos1. Objetos Java e

Caché interagem de forma eficiente. Esta interação pode ser através de JDBC, J2EE
e Web Services[4].
1
http://www.sun.com/java
30
Os métodos de acesso a objetos Java (abrir, listar, salvar, excluir, etc.) são
gerados com projeções. Um projeção transporta o código da classe para a
linguagem Java[4]. A figura 4.4 mostra o modelo de interação entre essas
tecnologias.
Projeção Classe Java
Maquina
Virtual Java
Definição de Classe Caché

Classe Caché
Servidor
Caché
Figura 4.4: Projeção de Classes.
4.3.5 XML
XML é a linguagem mais utilizada para troca de dados entre aplicações. O

Caché fornece uma interface bidirecional com o XML, que elimina a necessidade de
mapeamentos para o processamento de dados XML e o banco de dados[4].
4.3.5.1 Exportação do XML
Quando uma classe Caché é exportada para XML são fornecidos métodos
que auxiliam a:
• Criar DTD (Document Type Definition) ou uma Esquema XML para a
classe. DTDs e Esquemas XML são documentos que definem a
estrutura dos dados XML.
• Formatar dados automaticamente (instâncias da classe) como XML, de
acordo com DTD ou esquema definido.
31
4.3.5.2 Importação do XML
O Caché possui classes que fornecem métodos que permitem:

• Importar esquemas XML e criar automaticamente classes do banco
correspondentes.
• Importar dados de documentos XML como instâncias de classes
Caché, por meio de uma simples API.
• Analisar e validar documentos XML usando uma interface para Xerxes
SAX parser2 .
4.3.6 Web Services
Web Services são uma forma de compartilhamento de funcionalidades de

aplicações na Internet. Os Web Services possuem uma interface pública descrita em
WSDL (Web Services Defination Language) e retornam um documento XML
formatado de acordo com o protocolo SOAP (Simple Object Access Protocol)[4]. O
Caché gera automaticamente o descritor WSDL do serviço e, quando chamado,
envia uma resposta devidamente formatada como SOAP/XML. Dessa forma,
qualquer método Caché pode ser publicado como um Web Service.
2
http://www.apache.org/xerxes
32
5 CSP (Caché Server Pages)
Com o crescimento da Internet, as aplicações Web vem tornando-se cada vez

mais comuns. O Caché dispõe de uma forma fácil e rápida para o desenvolvimento
de páginas dinâmicas, através do Caché Server Pages (CSP)[7].
5.1 Arquitetura CSP
Caché Server Pages tem melhor performance que as demais tecnologias

disponíveis pois não precisam conectar-se ao banco para obter seus dados[7].
Páginas CSP podem ser desenvolvidas no Dreamweaver[4] ou no próprio
Caché Studio. A grande vantagem é que o Caché é totalmente escrito em ANSI C e
executa estas classes de forma muito rápida e eficiente em qualquer plataforma.
As classes estão compiladas dentro do Caché e o acesso aos dados resume-
se à simples instanciação de objetos e execução de consultas sem a necessidade
de conectar-se ao banco. Portanto, o fato de o CSP ser a tecnologia mais rápida e
eficiente é uma simples questão física, pois não existe tráfego pela rede e nem
necessidade de manter um pool de conexões, como mostra a figura 5.1.
Servidor Web
Gateway CSP
Servidor CSP
SGBD Caché
Figura 5.1: Arquitetura CSP
O servidor Web é configurado para redirecionar chamadas com extensão .csp

para o Caché, que passa a trabalhar também como um servidor de aplicações. Na
primeira vez que uma página CSP é endereçada, o conteúdo é interpretado e é
33
criado uma classe responsável por atender às chamadas subseqüentes[4]. Se a
página CSP for modificada, a classe será reconstruída na próxima chamada.
Cada requisição Web é encapsulada em dois objetos, request e response,
facilitando o recebimento de parâmetros e a formatação do resultado. É possível
utilizar o objeto session para armazenar o contexto de uma transação que pode se
estender por várias requisições. Tudo é executado dentro do banco, garantindo a
propriedade de seu código[7]. O browser cliente recebe apenas o conteúdo HTML.
CSP usa delimitadores semelhantes ao XML e scripts na linguagem COS
(Caché Object Script) para incluir a lógica da aplicação que pode ser mantida nos
objetos armazenados, que são endereçados pelos scripts. As conexões ao servidor
Web são feitas através de APIs (Application Program Interface) padronizadas.
5.2 Caché Application Tags
Caché Application Tags (CATs) executam funções no servidor de dados ou no

browser[4]. Os CATs são extensíveis, reutilizáveis e podem ser usados para uma
série de funções, tais como:
• buscar dados para preenchimento de formulários;
• validar informações;
• transformar itens codificados ou calculados;
• gravar informações na base de dados;
• controlar o HTML fornecido ao navegador através de laços para
gerar linhas dinamicamente em uma tabela ou condições de inclusão
em partes de uma página.
5.3 Caché Web Form
Ferramenta que gera automaticamente formas HTML funcionais a partir de

classes do banco. São gerados métodos básicos de acesso aos bancos, tais como
inserir, excluir e pesquisar[3].
34
6 Estudo de Caso
O objetivo do estudo de caso é demonstrar o desenvolvimento de aplicações

utilizando o Caché, destacando os conceitos abordados neste trabalho. Para isso, foi
escolhido um sistema de vendas.
Uma visão geral do funcionamento do sistema pode ser vista na figura 6.1
que representa o diagrama de caso de uso (Use-Case), criado com o auxílio da
ferramenta Rational Rose[12].
Figura 6.1: Diagrama de Caso de Uso.
6.1 Aspectos de Implementação
O sistema foi implementado utilizando tecnologias presentes no próprio banco

de dados, pois isso melhora a performance do sistema, além de acelerar o
desenvolvimento. Contudo, qualquer uma das tecnologias abordadas neste trabalho
poderiam ser utilizadas, já que o Caché dispõe de formas de interagir com a maioria
das tecnologias de objetos.
As tecnologias utilizadas nesta aplicação foram as seguintes:
• Unified Modeling Language(UML)[2].
• Caché Server Pages (CSP)[4].
35
A construção da aplicação é composta de três etapas, de acordo com a figura
6.2.
Diagrama de Classes Páginas

Classe (UML) Caché CSP
figura 6.2.
Figura 6.2: Etapas da construção.
A figura 6.3 mostra o diagrama de classes. É interessante observar que é

necessário utilizar os tipos definidos para o banco. Estes tipos tornam-se disponíveis
automaticamente após a instalação do SGBD.
Vale ressaltar ainda que não é preciso escrever métodos set e get para
acessar os atributos, como “setNome()”, pois na verdade quando os atributos são
acessados, o banco internamente utiliza métodos de acesso. Por isso, é
aconselhável que os atributos sejam acessados diretamente.
Figura 6.3: Diagrama de Classe.
6.2 Exportação do Diagrama de Classes
Com base no diagrama de classes são criadas as classes no banco. Através

do Rose Link é realizado este processo (figura 6.4). Para uma melhor organização é
aconselhável criar um pacote para armazenar as classes. Neste caso, foi criado um
pacote “empresa”.
36
Figura 6.4: Exportação do Diagrama de Classes
6.3 Análise do Código Gerado
Todas as classes geradas são persistentes, exceto a classe Endereco que é

serial e é armazenada juntamente com a classe Pessoa. Isto pode ser observado no
parâmetro ClassType destas classes (listagens 6.1 e 6.2).
Class empresa.Pessoa Extends %Persistent

[ ClassType = persistent, ProcedureBlock ]
{
Property Nome As %String [ Required ];
Property Endereco As locadora.Endereco [ Required ];
}
Listagem 6.1: Classe Pessoa
Class empresa.Endereco Extends %SerialObject

[ ClassType = serial, ProcedureBlock ]
{
Property Rua As %String [ Required ];
Property Num As %Integer;
}
Listagem 6.2: Classe Endereco
O termo “Required”, na propriedade Nome, indica que ela é obrigatória, assim

com a propriedade Endereco. Neste caso, é caracterizado uma composição, pois a
classe Endereco compõe a Classe Pessoa.
Um herança é observada na classe Cliente (listagem 6.3), que herda da
classe Pessoa, através do termo “Extends”. Contudo, todas as classes apresentam
37
herança, pois são concebidas a partir de classes bases como %Persistent,
%SerialObject, etc.
Entre as classes Cliente e Pedido há um relacionamento do tipo “um para
muitos”, discutido na seção 3.8.
O parâmetro Cardinality está configurado como many, já que um Cliente pode
ter vários Pedidos, de acordo com listagem 6.3.
Class empresa.Cliente Extends empresa.Pessoa

{
Property CPF As %Integer [ Required ];
Relationship Pedidos As empresa.Pedido [ Cardinality = many, Inverse = Cliente ];
}
Listagem 6.3: Classe Cliente
Como o Pedido aponta para um único Cliente, o parâmetro Cardinality está

configurado como one (figura 6.4) . O parâmetro Inverse define qual propriedade é a
inversa na relação.
Class empresa.Pedido Extends %Persistent

{
...
Relationship Cliente As empresa.Cliente [ Cardinality = one, Inverse = Pedidos
];
Listagem 6.4: Classe Pedido
6.4 Geração de Páginas CSP
O objetivo da utilização de páginas CSP é promover o desenvolvimento

rápido e eficiente do lado servidor[7]. Com as classes construídas, basta selecionar
as propriedades a serem exibidas no formulário, com o Caché Web Form, como
mostra a figura 6.5.
38
Figura 6.5: Seleção de Propriedades
Com a seleção das propriedades é gerada uma página CSP correspondente e

neste caso, a página Pessoa(figura 6.6). É disponibilizado uma série de métodos de
acesso, como salvar, pesquisar, excluir, entre outros. A listagem 6.5 mostra as
opções salvar (form_save) e pesquisar (form_search).
Figura 6.6: Página Pessoa
…
<INPUT TYPE="BUTTON" NAME="btnSave" VALUE="Salvar"
ONCLICK='form_save();'>
<INPUT TYPE="BUTTON" NAME="btnSearch" VALUE="Pesquisar"
ONCLICK='form_search();'>
….
Listagem 6.5: Pessoa.csp
Quando a opção pesquisar é selecionada, um formulário é disponibilizado

como na figura 6.6. Pode-se adicionar mais de um parâmetro de pesquisa.
Uma pesquisa na classe pessoa exibe tanto clientes como fornecedores, já
que estes herdam de Pessoa.
39
Figura 6.7: Página Pessoa.csp
A figura 6.8 exibe a classe Pedido.Como existe um relacionamento com a

classe Pessoa, é disponibilizado uma opção para pesquisar a pessoa a que quem o
pedido pertence. Não é possível excluir uma pessoa enquanto houver pedidos
referentes a mesma.
Figura 6.6: Página Pessoa.csp
O Caché permite que aplicações sejam construídas de forma rápida e

eficiente, como demonstrado no estudo de caso deste trabalho. Isto é fundamental
para empresas, já que as mesmas necessitam de sistemas com alta performance e
a um baixo custo.
40
7 Considerações Finais
Este trabalho apresentou um estudo sobre o desenvolvimento de aplicações

utilizando o Caché, banco de dados pós-relacional, que, através de sua arquitetura
unificada de dados, permite que os dados sejam representados tanto como objetos
como tabelas.
7.1 Conclusões
O Caché apresentou características que auxiliam na construção e integração

de aplicações. Estas características permitem um desenvolvimento simples, rápido,
eficiente e com baixos custos de aplicações.
7.2 Sugestões de Trabalhos Futuros
Podem-se sugerir as seguintes atividades futuras:

• Fazer um estudo semelhante sobre outros bancos de dados pós-
relacionais.
• Estudar a integração de base de dados citada neste trabalho, analisando a
plataforma Ensemble3.
• Realizar um estudo comparativo entre CSP e outras linguagem para Web.
• Criar uma ferramenta de geração de formulários em Java, com base em
classes do banco de dados.
3
Ensemble é uma plataforma de integração baseada no Caché.
41
8 Referências bibliográficas
[1] Banco de Dados Orientado a Objetos. Disponível em:

http://www.sqlmagazine.com.br/downloads. Acessado em 07 de maio de 2004.
[2] BOOCH, Grady; RUMBAUGH, James; JACOBSON, Ivar. UML: Guia do

usuário. 1ª ed. Campus, 2000.
[3] Caché. Banco de Dados Pós-Relacional. Disponível em:

http://www.intersystems.com. Acessado em 15 de março de 2004.
[4] Documentação sobre o Caché. Disponível em:

http://platinum.intersystems.com. Acessado em 02 de novembro de 2004.
[5] Encapsulating Database Acess. Disponível em:

http://www.agiledata.org. Acessado em 06 de agosto de 2004.
[6] Introdução a Orientação a Objetos no Caché. Disponível em:

http://www.intersystems.com.br. Acessado em 21 de junho de 2004.
[7] KIRSTEN, W.; IHRINGER, M; RÖHRING, B; KÜHN, M. Object-Oriented

Application Development. Using the Caché Postrelational Database. 2ª ed.
Springer, 2002.
[8] MURTA, L. C. O.; Veronese, G. O.; Wener, C. M. L. Mor: Uma ferramenta

para mapeamento Objeto-Relacional em Java. Disponível em:
http://www.cos.ufrj.br/~odyssey. Acessado em 19 de maio de 2004.
[9] OR Mapping Articles. Disponível em:

http://www.object-relational.com/articles. Acessado em 17 maio de 2004.
[10] Oracle9i SQL Reference. Disponível em:

http://download-east.oracle.com/otndoc. Acessado em 29 de março de 2004
42
[11] OMG – Object Management Group. Disponível em:
http://www.omg.org. Acesso em 04 julho de 2004.
[12] Rational Rose Corporation . Disponível em:

http://www.rational.com. Acessado em 07 de maio de 2004.
[13] ROGERS, Gregory F. Framework – Based Software Development in C++.

New Jersey, Prentice - Hall, 1997.
[14] RUMBAUGH, J. Modelagem e Projetos Baseados em Objetos. 1ª ed. São

Paulo, Ed. Campus, 1994.
[15] SILBERSCHATZ, Abraham. Sistema de Banco de Dados. 3ª ed. São Paulo,

Makron Books, 1999.
[16] SOARES, Valéria G. Banco de Dados Não-Convencionais. Disponível em :

http://www.ufrn.br/~valeria. Acessado em 05 de dezembro de 2004.
43
Anexo – Código do estudo de caso
• Classe Pessoa;
• Classe Endereco;
• Classe Cliente;
• Classe Fornecedor;
• Classe Pedido;
• Pessoa.csp;
• Cliente.csp;
• Fornecedor.csp;
• Produto.csp;
Classe Pessoa
Class empresa.Pessoa Extends %Persistent [ ClassType = persistent, ProcedureBlock ]
{
Property Nome As %String [ Required ];
Index NomeIndex On Nome;
Property Endereco As Endereco [ Required ];
Query QueryPessoa(Nome As %String, Endereco As Endereco) As %SQLQuery(CONTAINID = 1)

{
SELECT %ID,Nome,Endereco_Rua,Endereco_Numero FROM Pessoa
ORDER BY Nome
}
Classe Endereco
Class empresa.Endereco Extends %SerialObject [ ClassType = serial, ProcedureBlock ]
{
Property Numero As %Integer;
Property Rua As %String [ Required ];
Classe Cliente
Class empresa.Cliente Extends empresa.Pessoa [ ClassType = persistent, ProcedureBlock ]

{
Property CPF As %Integer [ Required ];
Relationship Pedidos As empresa.Pedido [ Cardinality = many, Inverse = Cliente ];
Index CPFIndex On CPF;
Query QueryCliente(Nome As %String, CPF As %Integer, Endereco As Endereco) As %SQLQuery(CONTAINID = 1)

{
SELECT %ID,CPF,Nome,Endereco_Rua,Endereco_Numero FROM Cliente
ORDER BY CPF, Nome
}
44
Classe Fornecedor
Class empresa.Fornecedor Extends empresa.Pessoa [ ClassType = persistent, ProcedureBlock ]
{
Property CNPJ As %Integer [ Required ];
Index CNPJIndex On CNPJ;
Query QueryFornecedor(CNPJ As %Integer, Endereco As Endereco) As %SQLQuery(CONTAINID = 1)

{
SELECT %ID,Nome,CNPJ,Endereco_Rua,Endereco_Numero FROM Fornecedor
ORDER BY CNPJ, Nome
}
Classe Pedido
Class empresa.Pedido Extends %Persistent [ ClassType = persistent, ProcedureBlock ]

{
Relationship Cliente As empresa.Cliente [ Cardinality = one, Inverse = Pedidos ];
Property Descricao As %String [ Required ];
Property Valor As %Float [ Required ];
Index DescricaoIndex On Descricao;
Index ClienteIndex On Cliente;
Query QueryPedido(Descricao As %String, Valor As %Float, Cliente As Cliente) As %SQLQuery

{
SELECT Cliente->Nome,Cliente->CPF,Descricao,Valor FROM Pedido
ORDER BY Cliente, Descricao
}
Pessoa.csp
<H1 ALIGN="CENTER">Classe Pessoa</H1>

<SCRIPT Language=JavaScript>

</SCRIPT>

<CSP:OBJECT NAME="objForm" CLASSNAME="empresa.Pessoa" OBJID=#(%request.Get("OBJID"))#>

<CSP:SEARCH NAME="form_search" CLASSNAME="empresa.Pessoa" WHERE="Nome" OPTIONS="popup,nopredicates"
ONSELECT="update">
<FORM NAME="form" CSPBIND="objForm" CSPJS="All" ONSUBMIT='return form_validate();'>

<CENTER>
<TABLE CELLPADDING="3">
45
<TR>
<TD><FONT COLOR="#666666"><B><DIV ALIGN="RIGHT">ID:</DIV></B></FONT></TD>
<TD><INPUT TYPE="TEXT" NAME="sys_Id" CSPBIND="%Id()" SIZE="10" READONLY></TD>
</TR>
<TR>
<TD><B><DIV ALIGN="RIGHT">*Nome:</DIV></B></TD>
<TD><INPUT TYPE="TEXT" NAME="Nome" CSPBIND="Nome" SIZE="50" CSPREQUIRED></TD>
</TR>
<TR>
<TD><B><DIV ALIGN="RIGHT">* Rua:</DIV></B></TD>
<TD><INPUT TYPE="TEXT" NAME="EnderecoRua" CSPBIND="Endereco.Rua" SIZE="50" CSPREQUIRED></TD>
</TR>
<TR>
<TD><B><DIV ALIGN="RIGHT"> Numero:</DIV></B></TD>
<TD><INPUT TYPE="TEXT" NAME="EnderecoNumero" CSPBIND="Endereco.Numero" SIZE="10"></TD>
</TR>
<TR>
<TD> </TD>
<TD> <INPUT TYPE="BUTTON" NAME="btnSave" VALUE="Salvar" ONCLICK='form_save();'>
<INPUT TYPE="BUTTON" NAME="btnSearch" VALUE="Pesquisar" ONCLICK='form_search();'>
<INPUT TYPE="BUTTON" NAME="btnExcluir" VALUE="Excluir"
ONCLICK="#server(empresa.Pessoa.%DeleteId(form.OBJID.value))#;form_new();">
<INPUT TYPE="BUTTON" NAME="btnClear" VALUE="Limpar" ONCLICK='form_new();'>
</TD>
</TR>
<TR>
<TD> </TD>
<TD><FONT COLOR="#000088" SIZE="2">(* Indica campos obrigatórios)</FONT></TD>
</TR>
</TABLE>
</CENTER>
</FORM>
<HTML>
<HEAD>
<TITLE> Cache Server Page </TITLE>
</HEAD>
<BODY>
<center>
<a href="http://127.0.0.1:1972/csp/user/index.html">Página Inicial</a>
</center>
</BODY>
</HTML>
Cliente.csp
<H1 ALIGN="CENTER">Classe Cliente</H1>

</SCRIPT>
<CSP:OBJECT NAME="objForm" CLASSNAME="empresa.Cliente" OBJID=#(%request.Get("OBJID"))#>
<CSP:SEARCH NAME="form_search" CLASSNAME="empresa.Cliente" WHERE="Nome,CPF"
OPTIONS="popup,nopredicates" ONSELECT="update">

<CENTER>
<TR>
46
</TR>
<TR>
</TR>
<TR>
<TD><B><DIV ALIGN="RIGHT">*CPF:</DIV></B></TD>
<TD><INPUT TYPE="TEXT" NAME="CPF" CSPBIND="CPF" SIZE="10" CSPREQUIRED></TD>
</TR>
<TR>
<TD><B><DIV ALIGN="RIGHT">*Rua:</DIV></B></TD>
</TR>
<TR>
<TD><B><DIV ALIGN="RIGHT">Numero:</DIV></B></TD>
</TR>
<TR>
<TD> </TD>
</TD>
</TR>
<TR>
<TD> </TD>
</TR>
</TABLE>
</CENTER>
</FORM>
<HTML>
<HEAD>


</HEAD>
<BODY>
<center>
</center>

</BODY>
</HTML>
Fornecedor.csp
<H1 ALIGN="CENTER"> Classe Fornecedor</H1>


</SCRIPT>
<CSP:OBJECT NAME="objForm" CLASSNAME="empresa.Fornecedor" OBJID=#(%request.Get("OBJID"))#>
<CSP:SEARCH NAME="form_search" CLASSNAME="empresa.Fornecedor" WHERE="Nome,CNPJ"
47
<CENTER>
<TR>
</TR>
<TR>
</TR>
<TR>
<TD><B><DIV ALIGN="RIGHT">*CNPJ:</DIV></B></TD>
<TD><INPUT TYPE="TEXT" NAME="CNPJ" CSPBIND="CNPJ" SIZE="10" CSPREQUIRED></TD>
</TR>
<TR>
<TD><B><DIV ALIGN="RIGHT">*Rua:</DIV></B></TD>
</TR>
<TR>
<TD><B><DIV ALIGN="RIGHT">Numero:</DIV></B></TD>
</TR>
<TR>
<TD> </TD>
ONCLICK="#server(empresa.Fornecedor.%DeleteId(form.OBJID.value))#;form_new();">
</TD>
</TR>
<TR>
<TD> </TD>
</TR>
</TABLE>
</CENTER>
</FORM>
<HTML>
<HEAD>


</HEAD>
<BODY>

<center>
</center>
</BODY>
</HTML>
Pedido.csp
<H1 ALIGN="CENTER">Classe Pedido</H1>

</SCRIPT>
<CSP:OBJECT NAME="objForm" CLASSNAME="empresa.Pedido" OBJID=#(%request.Get("OBJID"))#>
<CSP:SEARCH NAME="form_search" CLASSNAME="empresa.Pedido" WHERE="Descricao"

<CSP:SEARCH NAME="findCliente" CLASSNAME="empresa.Cliente" WHERE="Nome" OPTIONS="popup,nopredicates"

CAPTION="Cliente " STARTVALUES="ClienteNome" ONSELECT="updateCliente">

<CENTER>
<TR>
<TD><INPUT TYPE="HIDDEN" SIZE="10" NAME="ClienteID" CSPBIND="Cliente">
<A HREF="JavaScript:findCliente();"><B><DIV ALIGN="RIGHT">Cliente :</DIV></B></A></TD>
<TD><INPUT TYPE="TEXT" NAME="Cliente" CSPBIND="Cliente.Nome" SIZE="50" READONLY></TD>
</TR>
<TR>
<TD><FONT COLOR="#666666"><B><DIV ALIGN="RIGHT">*CPF:</DIV></B></FONT></TD>
<TD><INPUT TYPE="TEXT" NAME="ClienteCPF" CSPBIND="Cliente.CPF" SIZE="10" CSPREQUIRED READONLY></TD>
</TR>
<TR>
<TD><FONT COLOR="#666666"><B><DIV ALIGN="RIGHT">*Nome:</DIV></B></FONT></TD>
<TD><INPUT TYPE="TEXT" NAME="ClienteNome" CSPBIND="Cliente.Nome" SIZE="50" CSPREQUIRED
READONLY></TD>
</TR>
<TR>
<TD><B><DIV ALIGN="RIGHT">*Descricao:</DIV></B></TD>
<TD><INPUT TYPE="TEXT" NAME="Descricao" CSPBIND="Descricao" SIZE="50" CSPREQUIRED></TD>
</TR>
<TR>
<TD><B><DIV ALIGN="RIGHT">*Valor:</DIV></B></TD>
<TD><INPUT TYPE="TEXT" NAME="Valor" CSPBIND="Valor" SIZE="10" CSPREQUIRED></TD>
</TR>
<TR>
<TD> </TD>
<TD><INPUT TYPE="BUTTON" NAME="btnSave" VALUE="Salvar" ONCLICK='form_save();'>
</TD>
</TR>
<TR>
<TD> </TD>
</TR>
</TABLE>
</CENTER>
</FORM>
<HTML>
<HEAD>
</HEAD>
<BODY>
<center>
</center>
</BODY>
</HTML>
49

Cache

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Cache

Enviado por

Direitos autorais:

Formatos disponíveis

CACHÉ

Banco de Dados Pós-Relacional

Flávio Rubens de Carvalho Sousa

Copyright (c) – 2005 – Flávio Sousa

Palavras-chaves : Orientação a Objetos, Banco de Dados, Caché.

Figura 3.1: Arquitetura Caché ..................................................................................... 20

Listagem 6.1: Classe Pessoa............................................................................... .......39

Tabela 3.1: Objetos e Tabelas ....................... ............................................................. 28

Para compreender o desenvolvimento de aplicações utilizando o Caché é

É a consideração apenas das propriedades comuns de um conjunto de objetos,

Os objetos são abstrações de dados do mundo real, com uma interface de

Num modelo com identidade de objetos, estes têm existência independente de

2.4 Objetos Complexos

Os objetos complexos são formados por construtores (conjuntos, listas, tuplas,

Um conjunto de objetos que possui o mesmo tipo (atributos, relacionamentos,

Herança é um mecanismo que permite ao usuário definir tipos de forma

• Herança Simples: Na herança simples um certo tipo pode ter apenas um

2.7 Métodos e Mensagens

Um método, em relação a um objeto, corresponde ao comportamento dos

Em sistemas polimórficos uma mesma operação pode se comportar de

O encapsulamento possibilita a distinção entre a especificação e a

O Caché é um SGBD Pós-Relacional que une os modelos relacional e

A arquitetura é o grande diferencial deste banco, pois permite a coexistência

Figura 3.1: Arquitetura Caché.

Com essa arquitetura é possível armazenar dados de acordo com a

O Caché apresenta uma série de características que torna o desenvolvimento

O Caché dispõe de várias formas de acesso a objetos. Isso permite a

Figura 3.2: Formas de Acesso.

3.4 Tipos de Classes

Devido aos diferentes tipos de classes é possível representar todas as

Não Registradas Registradas

Figura 3.3: Tipos de Classes

Estas classes definem uma estrutura e um comportamento. Podem ser

Classes deste tipo não são gerenciadas automaticamente pelo Caché. O

As classes registradas são administradas pelo gerenciador de banco de

As classes persistentes podem ser armazenadas em disco e herdam de

O Caché possui duas linguagens de programação: o Caché ObjectScript

O Caché possui duas linguagens de programação: o Caché ObjectScript

3.5.1.1 Caché ObjectScript

Caché ObjectScript é uma linguagem orientada a objetos, simples e

É uma linguagem similar ao VBScript e que possui as mesmas características

SQL (com features do ANSI 92 e 2003 e extensões OO) é a linguagem de

3.6 Elementos de Classes

Uma classe descreve uma estrutura e um comportamento. Os elementos de

Os tipos, métodos e componentes de classes são geralmente inicializados

Os métodos fornecem o acesso a classes e objetos[6]. Existem dois tipos

3.7 Referências e Identidades

Objetos possuem duas formas de identificação :

3.8 Relacionamento entre Classes

O Caché possui diversas formas para relacionar objetos: Referência Simples,

3.8.1 Referência Simples

Em uma referência simples, um objeto simplesmente aponta para um outro

Quando é preciso garantir a integridade referencial, impedindo que um objeto

3.8.4 Foreing Key Relacional

Um relacionamento entre objetos mantido através de uma ou mais colunas

3.9 Objetos e Tabelas

A arquitetura unificada proporciona uma correspondência entre objetos e

Tabela 3.1: Objetos e Tabelas

pacote SQL schema

OID chave primária

referência para objeto chave estrangeira

objetos embutidos coluna individual

relacionamentos chave estrangeira

método de classe store procedure