You are on page 1of 49

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

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. Este trabalho apresenta um estudo sobre o SGBD Caché. a melhor solução seria unir as características dos modelos relacionais e orientados a objetos de forma eficiente. os sistemas gerenciadores de bancos de dados orientados a objetos (SGBDOO) e o objeto-relacional (SGBDOR). Palavras-chaves : Orientação a Objetos. Entretanto. o que faz com que ele termine sendo utilizado como o SGBD relacional. cada vez mais complexas das aplicações. herança e polimorfismo. destacando a arquitetura unificada de dados. Os Frameworks realizam o mapeamento de objeto para SBBDs relacionais. Para suprir as limitações do modelo relacional surgiram várias soluções. 5 . No entanto.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. A grande vantagem do uso de um SGBDOO consiste em que os objetos podem ser armazenados de forma transparente. Os SGBDs objeto-relacionais dão suporte ao modelo relacional estendido com certos conceitos de orientação a objetos. O modelo relacional é baseado na relação entre tabelas. Contudo. como Frameworks. Caché. seu uso é especifico e acrescenta mais camadas ao sistema. pois possui suporte a objetos e tabelas. a integração com tecnologias e o desenvolvimento de aplicações. esse modelo não atende à demanda. Porém. a maior parte dos sistemas gerenciadores de banco de dados (SGBDs) utilizados nos últimos anos são baseados no modelo relacional. Banco de Dados. esse modelo não apresenta as características da orientação a objetos de forma simples. os SGBDOOs ainda apresentam pouca maturidade e robustez. Neste contexto. Contudo. que utilizam imagens e multimídia. O modelo orientado a objetos é baseado no conceito de classes e utilizam encapsulamento.

................9 Objetos e Tabelas ......................................................1 Referencias Simples.................................6 Herança.................. 25 3... 25 3.......................3................................1 Caché ObjectScript........... ...........................................................3.................................................................................... 22 3.....2 Características.............................4 Java......................... 28 3.................... 30 4...............................2 Objetos................ .......................................... . 17 2................. ............................5.............................3 Integração com Tecnologias ........4 Obetos Compexos............ 31 4......................................................................................2 Relacionamentos...................................................................8................8..5................2 Caché Studio...1 Visual Caché............ ......7 Referências e Identidades.................................................................................................................................. .. ................ 27 3.....Sumário 1 Introdução...................................................... 19 2... 23 3.................... 23 3. 32 4..........3................................................5 Classes............ ............5.................................... 18 2...........................................................16 2...............................................18 2......................2 Caché Basic............................................ .......... ................ 26 3................. 32 6 ........ 24 3....... 24 3...........................1 Dados......4................4 Registradas.....6 Persistentes...........................................................................3 Identidade de Objeto........ 26 3.... 29 4............2 Objeto................1 Programação..............................5....................................................................... 23 3........3.................................................................................... 17 2............................................4................................... 28 4 Ambiente de Desenvolvimento. ................ ...........5 Linguagens. ............ .............................8 Relacionamento entre Classes............................................ 32 4.1 Namespaces................................................ 20 3.........................................8 Polimorfirmo...............3 Objetos..........................................................................3 Não-Registradas...6 Elementos de Classes......................................... 25 3.......................................................................6.......1..........9 Encapsulamento............................. 24 3...................... .................. 21 3................................................................. 19 3 Modelo Pós-Relacional Caché...........................................4 Foreing Key Relacional...4.........................................................4 Tipos de Classes..............................3 ActiveX. 29 4............7 Métodos e Mensagens.... 26 3..............5 Embutidas....................... 23 3.. 20 3.1 Métodos.8........................................................................................................................................................................................................................................4.............................................................2 SQL Gateway..................3.......................................................4.. 17 2... 28 3....... .............................................................. 26 3.................. 32 4....................................................................16 2....................................................................................................................... ................................24 3............................................8.........................................................1 Rose Link........................................... 24 3..................... ........... ........................16 2.................................................................. 13 2 Noções de Orientação a Objetos..................3 Composição...........................1...........4....................2 Consulta.......................................................... ................................... 22 3..................................................3........1 Arquitetura..30 4..................................................1 Abstração...............

......37 6..3 Caché Web Form.......36 6 Estudo de Caso...5 XML.............................44 Anexo: Código do estudo de caso....................................5....6 Web Services...........................................................37 6.................................................................... 38 6..............3 Análise do Código Gerado..............2 Caché Application Tags..... 43 7.................................4 Geração de Páginas CSP.............3..........................................................................................................................................................................................2 Exportação do Diagrama de Classes...........................................................................................1 Importação do XML...3.................2 Sugestões de Trabalhos Futuros..........................................1 Conclusões...................1 Arquitetura CSP............33 4............. ..........34 5...............4.. 43 7................................ 39 6.................34 4.............5....................................................................................................................... 36 5...............................1 Aspectos da Implementação........................................................................................................................46 ........... ...2 Exportação do XML....3..3..........................................34 5 CSP (Caché Server Pages).................................................................. 43 8 Referências bibliográficas.......................... 34 5.................................................... 40 7 Consideraçoes Finais.................... 33 4................... .....................................

.......................2: Etapas da Construção ..............................................................1: Namespaces................ 23 Figura 4................................................................................................................................................................................ 30 Figura 4............... 42 Figura 6..............................................3: Tipos de Classes...................................................................3: SQL Gateway................................ ..............6: Página Pedido.........1: Arquitetura CSP. ...6: Página Pessoa................................................... ........... ................. ................................................................... ............. 41 Figura 6. ............... 20 Figura 3............................................. 38 Figura 6................... .........................3: Diagrama de Classe....................................................................................... 32 Figura 4................ 22 Figura 3........1: Diagrama de Caso de Uso ............................ 37 Figura 6.. 33 Figura 5...................6: Página de Pesquisa......................... 42 8 ..... ..................................................... 41 Figura 6......... 35 Figura 6......5: Seleção de Propriedades.............................................................................. 30 Figura 4...........2: Caché Studio.......4: Exportação do Diagrama de Classe..............................................................4: Projeção de Classes....2: Formas de Acesso...............................................................................................1: Arquitetura Caché ....... 39 Figura 6...................................Índice de figuras Figura 3.............................. 38 Figura 6....................................

. ..1: Classe Pessoa..................................3: Classe Cliente................................................................ 41 9 ......................39 Listagem 6..........................Índice de listagens de código Listagem 6.......2: Classe Endereco....5: Pessoa....................................................... .............. 40 Listagem 6................................................. ...... 40 Listagem 6.............................................. 39 Listagem 6...................................................csp...........................................4: Classe Pedido ...............

................................. 31 Tabela 4..... ............................ 31 10 ..3: Correspondência de tipos com Rational Rose ...................Índice de tabelas Tabela 3...........1: Componentes do Ambiente...... 28 Tabela 4...... ................................................................ 29 Tabela 4...............2: Ferramentas Integráveis .....................................................1: Objetos e Tabelas .................................

A necessidade de armazenar e processar dados complexos em bancos de dados relacionais vem aumentando à medida que surgem sistemas de informação mais sofisticados.. encapsulamento. Contudo. 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. Os frameworks são capazes de realizar o mapeamento objeto-relacional[9]. identidade. tipo. Contudo. Suporta uma pequena quantidade de tipos de dados que se mostram adequados para aplicações convencionais. isto é. agregação. string. o qual permite ao desenvolvedor concentre-se apenas no modelo de objetos[13]. atrasam significativamente o desenvolvimento das mesmas e acrescentam mais camadas ao sistema. herança. os conceitos de classe. Além disso. diminuem o desempenho das aplicações. possuem mecanismos especiais para controlar transações entre objetos 11 . neste caso.)[15].. as quais contêm um tipo de dado simples especificado (integer. Para suprir as limitações do modelo relacional surgiram várias soluções. Isto provoca problemas no desenvolvimento de aplicações que utilizam tecnologia de objetos. Uma relação é uma tabela com linhas (tuplas) e colunas (atributos). o modelo de dados mais utilizado por SGBDs (Sistemas Gerenciadores de Banco de Dados) é o relacional[15]. Os objetos podem ter estruturas complexas e.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]. O modelo relacional está baseado em uma única estrutura de dados: a relação. objeto. character. Os SGBDOOs implementam de forma natural o modelo orientado a objeto.. Um framework é uma aplicação reusável destinada ao mapeamento de objetos para bancos de dados relacionais. como Frameworks. método e polimorfismo[14] . tais como aplicações multimídia para Web. os sistemas gerenciadores de banco de dados orientados a objetos (SGBDOO) e o objeto-relacional (SGBDOR). 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].

essa linguagem não têm aceitação generalizada[1]. a única maneira de acessar os dados é através de linguagens de consulta. A linguagem de consulta é SQL com extensões para cada banco. herdando transação robusta e características de gerenciamento de performance da tecnologia relacional e adiciona a flexibilidade da tecnologia orientada a objetos[16]. Esse é um termo freqüentemente utilizado para designar bancos de dados multidimensionais que apresentam orientação a objetos.e técnicas de armazenamento que facilitam a recuperação rápida de objetos complexos (clustering)[11]. 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. Os SGBDORs são evolucionários. que combina as tecnologias de orientação a objetos e relacional [4]. tornando a modelagem destes uma tarefa difícil. No entanto. Alguns fabricantes deste modelo fornecem o acesso a dados através da linguagem Objetc Query Language (OQL). Mas isso não é o suficiente. pois possui suporte a tabelas e objetos. aplicações relacionais podem coexistir com novos componentes de negócios construídos com a tecnologia de objetos. com estrutura de dados multidimensional. O SGBD Caché realiza esta união. permitindo uma integração entre as mesmas. Pode-se trabalhar com estruturas tabulares familiares. já que não existe um padrão. este modelo não foi concebido para armazenar objetos. No entanto. O acesso aos objetos é mais versátil quando se utiliza um SGBDOO. as aplicações desenvolvidas poderiam acessar dados de várias formas. a melhor solução seria unir as características dos modelos relacionais e orientados a objetos. O Caché é um banco de dados pós-relacional. 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. Usando SGBDRs. Assim. Assim. Cada uma das diversas tecnologias contidas no Caché é aplicada a determinadas tarefas. enquanto adiciona novas possibilidades de gerenciamento de objetos[10]. Todos os SGBDs desenvolvidos após o modelo relacional podem ser chamados de pós-relacional. 12 . Eles refletem uma imagem do mundo real e atendem as necessidades das aplicações atuais que apresentam dados complexos[7]. já que é possível fazê-lo de forma navegacional ou por meio de linguagens do tipo SQL[5]. Neste contexto.

Noções de orientação a objetos.Conclusões e os Trabalhos Futuros. • Seção 7 . 13 .Estudo de caso. • Seção 5 . Este trabalho apresenta um estudo sobre o SGBD Caché.Ambiente de Desenvolvimento. a integração com tecnologias e o desenvolvimento de aplicações. • Seção 3 . destacando a arquitetura unificada de dados. • Seção 6 .Tecnologia Caché Server Pages (CSP)[4]. O trabalho encontra-se dividido da seguinte forma: • Seção 2 . • Seção 4 .Modelo Pós-Relacional Caché.

utilizada com freqüência na definição de valores similares e na formação de um tipo a partir de outro. 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]. A generalização corresponde à associação "é um" onde. Um objeto individual é chamado de instância ou ocorrência de objeto. As abstrações da representação e das operações são ambas suportadas no modelo de dados orientado a objetos. Superficialmente. 14 . 2. ou seja. 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. 2.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.2 Objeto Os objetos são abstrações de dados do mundo real. são incorporadas as noções de estruturas de dados e de comportamento. Seus principais conceitos são apresentados a seguir. em diferentes níveis de abstração. Os principais conceitos de abstração utilizados em banco de dados são generalização e agregação. é criada uma outra entidade. A agregação corresponde a associação "parte de". omitindo os detalhes.1 Abstração É a consideração apenas das propriedades comuns de um conjunto de objetos. A parte estrutural de um objeto (em banco de dados) é similar à noção de entidade no modelo Entidade-Relacionamento. a partir de propriedades comuns de diferentes entidades. O processo inverso é a especialização[2]. com uma interface de nomes de operações e um estado local que permanece oculto[6]. O uso de abstrações permite a geração de tipos baseada em hierarquias de tipos e de relacionamentos[6].

e transitivos para seus componentes. que persistem no tempo de forma independente ao estado interno do objeto. Cada classe tem um tipo associado. tuplas. 15 .2. os construtores são em geral ortogonais. 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. podendo ser vista como uma representação por extensão. operações) pode ser agrupado para formar uma classe. coleções. relacionamentos.5 Classes Um conjunto de objetos que possui o mesmo tipo (atributos.4 Objetos Complexos Os objetos complexos são formados por construtores (conjuntos. 2. 2. arrays) aplicados a objetos simples (inteiros.3 Identidade de Objeto Num modelo com identidade de objetos. registros. independente de sua composição. Um exemplo desta operação é a atualização ou remoção de um objeto[6]. estes têm existência independente de seus valores correntes e dos endereços de armazenamento físico. listas. isto é. A manutenção de objetos complexos. 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]. booleanos. No modelo relacional este não é o caso. o qual especifica a estrutura e o comportamento de seus objetos. A identidade de objetos elimina as anomalias de atualização e de integridade referencial. Nos modelos orientados a objetos. A identidade do objeto é geralmente gerada pelo sistema. visto que só é possível aplicar o construtor de conjuntos às tuplas e o construtor de registro a valores atômicos[1]. qualquer construtor pode ser aplicado a qualquer objeto. strings). A noção de classe é associada ao tempo de execução. enquanto que o tipo é uma representação intencional. requer a definição de operadores apropriados para sua manipulação como um todo.

redefinindo-os para estes. 2. por refinamento de outros já existentes. 2. implementando uma operação associada a uma ou mais classes. em relação a um objeto. • Herança Múltipla: Nesta herança um tipo pode ter supertipos e os mesmos refinamentos de herança simples. ela corresponde a transferência de propriedades estruturais e de comportamento de uma classe para suas subclasses.6 Herança Herança é um mecanismo que permite ao usuário definir tipos de forma incremental. Há basicamente dois tipos de conflitos referentes à herança múltipla: entre o tipo e o supertipo e entre múltiplos supertipos. Existem dois tipos de herança descritos a seguir: • Herança Simples: Na herança simples um certo tipo pode ter apenas um supertipo. e simplificando a evolução e a reusabilidade de esquemas de banco de dados[1]. As principais vantagens de herança são prover uma maior expressividade na modelagem dos dados.7 Métodos e Mensagens Um método. como uma resolução por default pode causar heranças não desejadas. a extensão da classe denota o conjunto dos objetos atualmente existentes na classe e o tipo provê a estrutura destes objetos[2]. e não a no supertipo[4]. podendo fatorar especificações e implementações como na adaptação de métodos gerais para casos particulares. permitindo composição de tipos em que as propriedades de um ou mais tipos são reutilizadas na definição de um novo tipo. Com os conflitos entre múltiplos supertipos.Assim. a abordagem mais segura é baseada na requisição explícita da intervenção do usuário. De fato. facilitar a reusabilidade de objetos e definir classes por refinamento. da mesma forma uma subclasse só herda diretamente de uma única classe. corresponde ao comportamento dos objetos. O primeiro pode ser resolvido dando-se prioridade à definição presente no tipo. de forma 16 .

além de prover a modularidade que permite uma melhor estruturação das aplicações ditas complexas. o que caracteriza uma sobrecarga[1]. Para cada operação pode-se ter um ou mais métodos de implementação associados[1]. Um mesmo nome pode ser usado por mais de uma operação definida sobre diferentes objetos. que manipula o objeto ou parte deste. Os objetos se comunicam e são ativados através de mensagens enviadas entre eles.9 Encapsulamento O encapsulamento possibilita a distinção entre a especificação e a implementação das operações de um objeto. 2. 17 . bem como a segurança dentro do sistema. 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. Cada objeto tem um certo número de operações para ele definida. 2.8 Polimorfismo Em sistemas polimórficos uma mesma operação pode se comportar de diferentes formas em classes distintas.similar aos códigos dos procedimentos usados em linguagens de programação tradicionais. 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]. Tem-se também polimorfismo quando ocorre a passagem de diferentes tipos de objetos como parâmetros enviados a outros objetos. As mensagens são a forma mais usada para se ativar os métodos.

reduzem o tempo de acesso e tornam os dados compactos. que permitem o armazenamento de dados complexos do mundo real. A figura 3. possibilitando que aplicações sejam construídas e executadas rapidamente.1: Arquitetura Caché.1 mostra essa arquitetura. Quando é definida uma classe e compilada. Isso reduz o tempo de desenvolvimento e custos de processamento. Aplicações Engine Engine SQL Objetos Máquina Virtual Multi Dimensional Figura 3.3 Modelo Pós-Relacional Caché O Caché é um SGBD Pós-Relacional que une os modelos relacional e orientados a objetos[4]. as aplicações desenvolvidas podem ser executadas em outras plataformas. As aplicações podem acessar dados através da linguagem SQL ou diretamente.1 Arquitetura A arquitetura é o grande diferencial deste banco. economizando espaço em disco. com métodos disponíveis para cada tecnologia. automaticamente é gerada uma tabela relacional. pois permite a coexistência de tabelas e objetos. Todos os dados são armazenados em vetores multidimensionais. eficiente e aumentando a performance das mesmas. Essa união permite que aplicações sejam construídas de forma rápida. permitindo a integração entre novas soluções e aplicações existentes. Por possuir uma máquina virtual que compila as classes gerando o pcode[4]. 3. O 18 . Possui suporte as principais tecnologias. Com essa arquitetura é possível armazenar dados de acordo com a necessidade.

são apresentadas as principais características. polimorfismo. • Desenvolvimento rápido de aplicações Web: dispõe de tecnologia Web própria.2 Características O Caché apresenta uma série de características que torna o desenvolvimento de aplicações simples. Caché Server Pages(CSP). • Baixo Custo: demanda poucos recursos de hardware. ocorrendo um empilhamento destas e causando um maior processamento para reconstruir os objetos decompostos. Dados multidimensionais não precisam ser reconstruídos. coleções e relacionamentos. O servidor de dados multidimensional elimina a sobrecarga de processamento. • Tecnologia avançada de objetos: suporta um modelo completo de objetos. A seguir. Isto permite modelos de dados mais ricos do que os obtidos no modelo relacional[4]. Páginas CSP rodam dentro do banco.servidor de dados multidimensional é responsável pela performance e escalabilidade do banco de dados. melhorando o armazenamento e o acesso aos mesmos. por que a informação precisa ser fragmentada em tabelas. • Conectividade: dispõe de mecanismo para acessar outros bancos de dados e permitir a integração de sistemas. permitindo alta escalabilidade sem altos investimentos. seguro e com um baixo custo[7]. Armazenar objetos complexos não é simples. incluindo encapsulamento. Dados complexos podem ser armazenados e utilizados de forma natural e intuitiva. 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. o que permite um melhor desempenho. pois não precisam conectar ao banco para obter dados. • Desempenho: com o acesso multidimensional de dados é possível representar objetos complexos de forma simples. 19 . 3. heranças múltiplas. rápido. o que melhora a performance das aplicações.

3. O J D D XML SOAP COM EJB Java .3 Objetos O Caché dispõe de várias formas de acesso a objetos. • Escalabilidade: utilizando o Enterprise Caché Protocol (ECP) é simples distribuir cargas e construir esquemas de cluster[4]. Para cada tecnologia são fornecidos objetos que interagem com o banco. Isso permite a integração com diversas tecnologias[7]. 3.2: Formas de Acesso.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. 20 . A figura 3.2 apresenta as formas de acesso. com exceção da AS400 e de MainFrames. as classes Caché são compiladas e podem ser executadas na maioria das plataformas.3 mostra estes tipos e uma hierarquia entre as mesmas[7].Net C++ Web COS B B C C CSP Basic Caché SQL Objetos Caché Multi-Dimensional Figura 3. • Portabilidade: por possuir uma máquina virtual.

4. Por não serem controladas pelo banco de dados. Estas classes existem somente como propriedades de objetos.4.1 Dados São classes que suportam apenas valores literais. O desenvolvedor é responsável pela administração da classe.3: Tipos de Classes 3.2 Objetos Estas classes definem uma estrutura e um comportamento. 3. elas não suportam polimorfismo.4.4. 3. 21 .4 Registradas As classes registradas são administradas pelo gerenciador de banco de dados e herdam da classe %RegisteredObject. Podem ser instanciados e cada objeto tem um único nome. Classes Dados Objetos Não Registradas Registradas Embutidas Persistentes Figura 3. 3.3 Não-Registradas Classes deste tipo não são gerenciadas automaticamente pelo Caché. Não possuem identidades e não podem ser instanciadas.

possibilitando uma visão dos dados como objetos.5.1 Programação O Caché possui duas linguagens de programação: o Caché ObjectScript (COS) e Caché Basic. São as classes mais utilizadas no Caché. 3.5 Embutidas As classes embutidas são utilizadas para compor outras classes. 3. Permite a interação de métodos de acesso aos dados. simples e poderosa.5.1. SQL e acesso multidimensional de dados[4]. não requer que todo o código faça parte do método de uma classe de objetos.5 Linguagens O Caché possui duas linguagens de programação: o Caché ObjectScript (COS) e Caché Basic. tabelas relacionais ou arrays multidimensionais[7].6 Persistentes As classes persistentes podem ser armazenadas em disco e herdam de %Persistent. 3.4. 3. Além disso.4. Elas não são armazenadas diretamente no banco de dados.3. Eles são carregadas na memória principal e na momento do armazenamento são vinculadas a classes persistentes. 22 . Ambas foram projetadas para base de dados e lógica de negócios de alta performance e suportam objetos.1 Caché ObjectScript Caché ObjectScript é uma linguagem orientada a objetos.

• Query – permite observar a instância de uma classe. Os elementos de classes caracterizam e auxiliam na construção de classes eficientes [7]. métodos e componentes de classes são geralmente inicializados pelo caractere “%” . • Index – estrutura de armazenamento que otimiza o acesso a objetos. • Propriedades – são dados. 23 .6 Elementos de Classes Uma classe descreve uma estrutura e um comportamento. Esses elementos são descritos a seguir: • Nome único.2 Consulta SQL (com features do ANSI 92 e 2003 e extensões OO) é a linguagem de consulta. • Parâmetros – valores que modificam o comportamento das classes durante a compilação.2 Caché Basic É uma linguagem similar ao VBScript e que possui as mesmas características da linguagem descrita anteriormente[4]. Os tipos.1. • Palavras Chaves (Keywords) – modifica a definição de classe. 3.3.5. pois a maioria das aplicações foram desenvolvidas utilizando essa linguagem. Isso permite a total compatibilidade com os sistemas existentes[4]. A grande vantagem é que desenvolvedores que trabalham Visual Basic não terão dificuldades em utilizar esta linguagem. • Métodos – código que adiciona funcionalidades. referência a objetos persistentes e objetos embutidos.5. 3.

1 Referência Simples Em uma referência simples. 24 . o primeiro não será notificado e qualquer acesso ocasionará erro de referencia inválida. Existem dois tipos básicos de métodos: • Métodos de Classes: são executados a partir de classes. Contudo.8 Relacionamento entre Classes O Caché possui diversas formas para relacionar objetos: Referência Simples. é descrito cada uma delas. É possível ter mais de um objeto com o mesmo ID em classes diferentes. %DeleteId. não existe integridade referencial. são métodos aplicados a classes e não a objetos. %Close. A seguir. 3. 3.7 Referências e Identidades Objetos possuem duas formas de identificação : • OREF – referência a um objeto em memória volátil. %New. um objeto simplesmente aponta para um outro objeto através de seu ID[7]. Caso o outro objeto seja excluído. Relacionamento.1 Métodos Os métodos fornecem o acesso a classes e objetos[6]. não existe a necessidade de verificar sua existência. etc.8. isto é. Composição/Agregação e Foreign Key relacional [6]. Portanto. • ID – identidade do objeto em disco. mas nunca na mesma classe[6]. Exemplos: %OpenId.3. Exemplos: %Save.6. este tipo de referência apresenta vantagens: • Performance: Se existe uma objeto que nunca será excluído. • Métodos de Instância: métodos aplicados a objetos (instância de classes). 3.

Isto é útil quando existe uma objeto referenciado por muitos outros.. Qualquer classe pode acessar o objeto sem que o mesmo faça nenhuma checagem. 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é. Existem dois tipos de relacionamentos: • Um para Muitos: Uma lista de objetos (L1.2 Relacionamentos Quando é preciso garantir a integridade referencial. a integridade referencial.Ln) podem referenciar um objeto T. 25 .Ln) serão excluídos também. L2.. garantindo assim. impedindo que um objeto seja excluído e ainda tenha referência para algum objeto.8.. • Pai-Filho: Um objeto T referencia um ou mais objetos (L1. Cada objeto da lista possui uma propriedade do tipo T e em T existe uma lista do tipo L.. Esse relacionamentos são implementados utilizando os relacionamentos descritos anteriormente. • Encapsulamento/Acoplamento: Não é necessário checar a integridade referencial.. Os relacionamentos do tipo “Um para Um” e “Muitos para Muitos” não estão presentes no Caché. o ideal é utilizar Relacionamentos. No objeto T existe uma lista do tipo L (filhos de T) e em L existe uma propriedade do tipo T. 3... Já o “Muitos para Muitos” pode ser implementado utilizando dois relacionamentos “Um para Muitos” e uma classe de relacionamento[6].Ln). Não é possível excluir T enquanto houver referências para o mesmo. todos os objetos da lista L (L1... consequentemente não existe a propriedade inversa na classe referenciada.. L2. L2.. Caso o objeto T seja excluído..

3.9 Objetos e Tabelas A arquitetura unificada proporciona uma correspondência entre objetos e tabelas.1.3.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]. mostrada na tabela 3. Quando o objeto que mantém referência é salvo. 3. Isso permite a total compatibilidade entre aplicações que utilizam objetos e tabelas.8.3 Composição Uma referência simples para um objeto de uma classe do tipo serial.8. o objeto serial referenciado é salvo juntamente com o mesmo [7]. 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 .

globais e rotinas. javascript.1 Namespaces Namespace é uma área de trabalho associado a um diretório. Configuração Acesso a sistemas Usado para acessar outros servidores. Remotos . rotinas.1 exibe os componentes disponíveis e suas descrições. Explorer Gerenciar/administrar o banco de dados com suas classes associadas.dat[6]. que por sua vez. são criados alguns namespaces como o USER (destinado a testes). A tabela 4. 27 . Quando o Caché é instalado. Um namespace contém projetos. Gerenciador SQL Gerenciar todos os aspectos de acesso relacional. etc. Para cada namespace existe um arquivo cache. páginas Caché Server Pages (CSP) e rotinas. Terminal Emula um terminal de comandos. 4.1: Componentes do Ambiente Componente Descrição Studio IDE de desenvolvimento usado para criar classes. Tabela 4. Gerenciador de Utilizado para definir as configurações de sistema e rede. Painel de Controle Usado para administrar o sistema (operação e seus processos). pode conter classes. SAMPLES. xml.4 Ambiente de Desenvolvimento O Caché possui um ambiente completo de desenvolvimento e administração. html. SYS.

dat Figura 4. Java. etc. É usado para cria classes e escreve métodos e rotinas utilizando a linguagem mais adequada. Possui checagem de sintaxe e debug[4]. como Java e Basic. Figura 4. C:\CacheSys\Mgr\User\cache.2: Caché Studio 4.2 Caché Studio É um ambiente de desenvolvimento.1: Namespaces 4. 28 . HTML.dat USER C:\CacheSys\Mgr\cachelib\cache. páginas CSP. sem a necessidade de configurações adicionais. A tabela 4.dat SAMPLES C:\CacheSys\Mgr\Samples\cache.3 Integração com Tecnologias O Caché integra-se com as principais tecnologias. Pode-se construir classes. Isto o torna uma solução completa para desenvolvimento de aplicações[6].2 mostra algumas das ferramentas que são integradas na instalação do produto. tudo em um único ambiente. A figura 4.2 mostra este ambiente.

Tabela 4. 4. Rational Rose Adiciona um Wizard para importar/ exportar classes de/para o banco. • Importar classes do banco gerando diagramas da UML. Tipos do Rose Tipos do Caché Byte %Integer Date %Date Double %Float Integer %Integer String %String 29 .3.3: Correspondências de tipos com Rational Rose. A tabela 4.2: Ferramentas integráveis. 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é.3 mostra correspondência entre os principais tipos do Rose e do Caché. Tabela 4.1 Rose Link RoseLink é um plugin que estabelece a conexão entre o Caché a ferramenta Rational Rose[12]. Ferramenta Descrição Visual Basic Acrescenta um Wizard para a criação automática de formulários VB baseados em classes do banco. Suas características são as seguintes: • Exportar diagramas da Unified Modeling Language(UML)[2] para classes Caché.

JDBC[3]. 4.3. possibilitando a integração de aplicações e dados[4].com/java 30 .3. São gerados métodos básicos de acesso ao bancos. excluir e pesquisar[4].3. J2EE e Web Services[4].sun. tais como inserir. Visual Basic.2 SQL Gateway Permite o acesso à bancos relacionais. A figura 4.3: SQL Gateway. Delphi.3 ActiveX Qualquer aplicação capaz de instanciar componentes ActiveX pode instanciar objetos diretamente no Caché sem qualquer configuração ou mapeamento. 1 http://www. Objetos Java e Caché interagem de forma eficiente. etc.4. etc. Esta interação pode ser através de JDBC. Este acesso podem ser estabelecido através de tecnologias com ODBC. interagem com o banco de dados de forma transparente e orientada a objetos[7]. 4.3. ODBC JDBC Gateway Oracle SQL Server Caché SQL Informix Multi Dimensional Sybase Figura 4.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.3 exibe o SQL Gateway. 4.4 Java Java é uma linguagem de programação orientação a objetos1.

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.4 mostra o modelo de interação entre essas tecnologias. 4. listar. O Caché fornece uma interface bidirecional com o XML.5.) são gerados com projeções. de acordo com DTD ou esquema definido. Um projeção transporta o código da classe para a linguagem Java[4]. que elimina a necessidade de mapeamentos para o processamento de dados XML e o banco de dados[4]. A figura 4.4: Projeção de Classes.3. Projeção Classe Java Maquina Virtual Java Definição de Classe Caché Classe Caché Servidor Caché Figura 4. 4. Os métodos de acesso a objetos Java (abrir. DTDs e Esquemas XML são documentos que definem a estrutura dos dados XML.5 XML XML é a linguagem mais utilizada para troca de dados entre aplicações. salvar. excluir. • Formatar dados automaticamente (instâncias da classe) como XML.3. 31 . etc.

apache. • Importar dados de documentos XML como instâncias de classes Caché. • Analisar e validar documentos XML usando uma interface para Xerxes SAX parser2 .3. 4.3. O Caché gera automaticamente o descritor WSDL do serviço e. 2 http://www.4. quando chamado. qualquer método Caché pode ser publicado como um Web Service. Dessa forma.6 Web Services Web Services são uma forma de compartilhamento de funcionalidades de aplicações na Internet. envia uma resposta devidamente formatada como SOAP/XML. 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].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.org/xerxes 32 . por meio de uma simples API.

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. pois não existe tráfego pela rede e nem necessidade de manter um pool de conexões. Páginas CSP podem ser desenvolvidas no Dreamweaver[4] ou no próprio Caché Studio. 5.1: Arquitetura CSP O servidor Web é configurado para redirecionar chamadas com extensão .csp para o Caché. Na primeira vez que uma página CSP é endereçada.5 CSP (Caché Server Pages) Com o crescimento da Internet. como mostra a figura 5. que passa a trabalhar também como um servidor de aplicações. as aplicações Web vem tornando-se cada vez mais comuns. o fato de o CSP ser a tecnologia mais rápida e eficiente é uma simples questão física.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]. Servidor Web Gateway CSP Servidor CSP SGBD Caché Figura 5. Portanto. o conteúdo é interpretado e é 33 . através do Caché Server Pages (CSP)[7]. O Caché dispõe de uma forma fácil e rápida para o desenvolvimento de páginas dinâmicas. 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.1.

É possível utilizar o objeto session para armazenar o contexto de uma transação que pode se estender por várias requisições.criado uma classe responsável por atender às chamadas subseqüentes[4]. • validar informações. request e response. • 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. a classe será reconstruída na próxima chamada. que são endereçados pelos scripts. 34 . tais como inserir. Se a página CSP for modificada. Tudo é executado dentro do banco. facilitando o recebimento de parâmetros e a formatação do resultado.2 Caché Application Tags Caché Application Tags (CATs) executam funções no servidor de dados ou no browser[4]. São gerados métodos básicos de acesso aos bancos. O browser cliente recebe apenas o conteúdo HTML. Os CATs são extensíveis.3 Caché Web Form Ferramenta que gera automaticamente formas HTML funcionais a partir de classes do banco. excluir e pesquisar[3]. Cada requisição Web é encapsulada em dois objetos. tais como: • buscar dados para preenchimento de formulários. • transformar itens codificados ou calculados. As conexões ao servidor Web são feitas através de APIs (Application Program Interface) padronizadas. garantindo a propriedade de seu código[7]. • gravar informações na base de dados. reutilizáveis e podem ser usados para uma série de funções. 5. 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.

Figura 6. destacando os conceitos abordados neste trabalho. já que o Caché dispõe de formas de interagir com a maioria das tecnologias de objetos. foi escolhido um sistema de vendas. qualquer uma das tecnologias abordadas neste trabalho poderiam ser utilizadas. além de acelerar o desenvolvimento. Contudo. criado com o auxílio da ferramenta Rational Rose[12]. 6.1 Aspectos de Implementação O sistema foi implementado utilizando tecnologias presentes no próprio banco de dados.1 que representa o diagrama de caso de uso (Use-Case). • Caché Server Pages (CSP)[4]. pois isso melhora a performance do sistema.6 Estudo de Caso O objetivo do estudo de caso é demonstrar o desenvolvimento de aplicações utilizando o Caché. As tecnologias utilizadas nesta aplicação foram as seguintes: • Unified Modeling Language(UML)[2]. Uma visão geral do funcionamento do sistema pode ser vista na figura 6.1: Diagrama de Caso de Uso. 35 . Para isso.

pois na verdade quando os atributos são acessados.3: Diagrama de Classe.3 mostra o diagrama de classes. foi criado um pacote “empresa”. como “setNome()”.2: Etapas da construção. Para uma melhor organização é aconselhável criar um pacote para armazenar as classes. é aconselhável que os atributos sejam acessados diretamente. Neste caso. Figura 6. Estes tipos tornam-se disponíveis automaticamente após a instalação do SGBD. de acordo com a figura 6. A figura 6. Através do Rose Link é realizado este processo (figura 6. 6.4). o banco internamente utiliza métodos de acesso. 36 . Por isso. A construção da aplicação é composta de três etapas. É interessante observar que é necessário utilizar os tipos definidos para o banco.2. Figura 6. Diagrama de Classes Páginas Classe (UML) Caché CSP figura 6.2.2 Exportação do Diagrama de Classes Com base no diagrama de classes são criadas as classes no banco. Vale ressaltar ainda que não é preciso escrever métodos set e get para acessar os atributos.

Um herança é observada na classe Cliente (listagem 6. Property Endereco As locadora. ProcedureBlock ] { Property Nome As %String [ Required ]. que herda da classe Pessoa.3). exceto a classe Endereco que é serial e é armazenada juntamente com a classe Pessoa. Figura 6. na propriedade Nome. todas as classes apresentam 37 . Neste caso.Endereco Extends %SerialObject [ ClassType = serial.2). pois a classe Endereco compõe a Classe Pessoa. } Listagem 6. ProcedureBlock ] { Property Rua As %String [ Required ].2: Classe Endereco O termo “Required”. } Listagem 6.Endereco [ Required ].Pessoa Extends %Persistent [ ClassType = persistent. é caracterizado uma composição.1: Classe Pessoa Class empresa. Property Num As %Integer. através do termo “Extends”. Contudo.3 Análise do Código Gerado Todas as classes geradas são persistentes. Class empresa.4: Exportação do Diagrama de Classes 6. assim com a propriedade Endereco. Isto pode ser observado no parâmetro ClassType destas classes (listagens 6. indica que ela é obrigatória.1 e 6.

com o Caché Web Form. Relationship Pedidos As empresa. Listagem 6. de acordo com listagem 6.8. Relationship Cliente As empresa.Pedido Extends %Persistent [ ClassType = persistent.Cliente Extends empresa.herança.5. ProcedureBlock ] { Property CPF As %Integer [ Required ]. ProcedureBlock ] { . Inverse = Cliente ].3: Classe Cliente Como o Pedido aponta para um único Cliente.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].. basta selecionar as propriedades a serem exibidas no formulário. já que um Cliente pode ter vários Pedidos. discutido na seção 3.4) . %SerialObject. Com as classes construídas.Cliente [ Cardinality = one. Inverse = Pedidos ]. Class empresa.Pedido [ Cardinality = many. } Listagem 6. O parâmetro Inverse define qual propriedade é a inversa na relação. o parâmetro Cardinality está configurado como one (figura 6..4: Classe Pedido 6.3. como mostra a figura 6. 38 . etc. Class empresa. pois são concebidas a partir de classes bases como %Persistent. Entre as classes Cliente e Pedido há um relacionamento do tipo “um para muitos”.Pessoa [ ClassType = persistent. O parâmetro Cardinality está configurado como many.

6: Página Pessoa … <INPUT TYPE="BUTTON" NAME="btnSave" VALUE="Salvar" ONCLICK='form_save(). É disponibilizado uma série de métodos de acesso. Figura 6.6).5 mostra as opções salvar (form_save) e pesquisar (form_search). excluir. como salvar. Pode-se adicionar mais de um parâmetro de pesquisa. a página Pessoa(figura 6. A listagem 6.'> <INPUT TYPE="BUTTON" NAME="btnSearch" VALUE="Pesquisar" ONCLICK='form_search(). Uma pesquisa na classe pessoa exibe tanto clientes como fornecedores. Figura 6.'> …. Listagem 6. já que estes herdam de Pessoa.6. pesquisar.5: Seleção de Propriedades Com a seleção das propriedades é gerada uma página CSP correspondente e neste caso. entre outros.csp Quando a opção pesquisar é selecionada. um formulário é disponibilizado como na figura 6.5: Pessoa. 39 .

Não é possível excluir uma pessoa enquanto houver pedidos referentes a mesma. como demonstrado no estudo de caso deste trabalho. Figura 6.7: Página Pessoa. já que as mesmas necessitam de sistemas com alta performance e a um baixo custo. 40 .csp O Caché permite que aplicações sejam construídas de forma rápida e eficiente. Figura 6. é disponibilizado uma opção para pesquisar a pessoa a que quem o pedido pertence.csp A figura 6.Como existe um relacionamento com a classe Pessoa.6: Página Pessoa. Isto é fundamental para empresas.8 exibe a classe Pedido.

que. 3 Ensemble é uma plataforma de integração baseada no Caché. 7. • Realizar um estudo comparativo entre CSP e outras linguagem para Web. 41 .1 Conclusões O Caché apresentou características que auxiliam na construção e integração de aplicações. analisando a plataforma Ensemble3. • Criar uma ferramenta de geração de formulários em Java. 7. através de sua arquitetura unificada de dados. • Estudar a integração de base de dados citada neste trabalho. permite que os dados sejam representados tanto como objetos como tabelas.7 Considerações Finais Este trabalho apresentou um estudo sobre o desenvolvimento de aplicações utilizando o Caché. banco de dados pós-relacional. com base em classes do banco de dados. rápido.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. eficiente e com baixos custos de aplicações. Estas características permitem um desenvolvimento simples.

com. Mor: Uma ferramenta para mapeamento Objeto-Relacional em Java. Acessado em 06 de agosto de 2004. Disponível em: http://www.br/~odyssey. B. Acessado em 17 maio de 2004.com/articles. Acessado em 02 de novembro de 2004. [4] Documentação sobre o Caché. RUMBAUGH. Acessado em 21 de junho de 2004. IHRINGER.8 Referências bibliográficas [1] Banco de Dados Orientado a Objetos. 2000. Springer.com.cos. O. Disponível em: http://download-east. [9] OR Mapping Articles. Disponível em: http://www. M. UML: Guia do usuário. [6] Introdução a Orientação a Objetos no Caché. G. O. Object-Oriented Application Development.org. 2ª ed. Disponível em: http://www. Wener.com. Using the Caché Postrelational Database.ufrj.object-relational. Disponível em: http://www. [10] Oracle9i SQL Reference. Disponível em: http://www. L. 2002. Banco de Dados Pós-Relacional. James. Acessado em 15 de março de 2004. Acessado em 29 de março de 2004 42 .br/downloads.br. C. Acessado em 19 de maio de 2004. 1ª ed.intersystems. Campus. [7] KIRSTEN. L. [3] Caché. JACOBSON. Acessado em 07 de maio de 2004.. C.. [5] Encapsulating Database Acess. W.com/otndoc. RÖHRING. Disponível em: http://www.intersystems.sqlmagazine. Veronese. Ivar. [8] MURTA. M.. [2] BOOCH. M. KÜHN.intersystems. Disponível em: http://platinum.com.agiledata. Grady.oracle.

Ed. 1994.org. Modelagem e Projetos Baseados em Objetos. Makron Books. New Jersey.omg. [14] RUMBAUGH. Prentice .com. Disponível em: http://www. [12] Rational Rose Corporation . São Paulo. Campus. Gregory F. [13] ROGERS.[11] OMG – Object Management Group. Acessado em 07 de maio de 2004.ufrn. 1ª ed. Sistema de Banco de Dados.br/~valeria. 43 . Acesso em 04 julho de 2004. 3ª ed. Acessado em 05 de dezembro de 2004. J. [16] SOARES. Banco de Dados Não-Convencionais. São Paulo. Disponível em: http://www.Hall. Framework – Based Software Development in C++. 1997. Disponível em : http://www.rational. Valéria G. [15] SILBERSCHATZ. 1999. Abraham.

• Fornecedor. Classe Pessoa Class empresa.Cliente Extends empresa. • Produto. • Classe Pedido.Endereco_Numero FROM Pessoa ORDER BY Nome } } Classe Endereco Class empresa. Endereco As Endereco) As %SQLQuery(CONTAINID = 1) { SELECT %ID. Inverse = Cliente ]. Index CPFIndex On CPF. Property Endereco As Endereco [ Required ]. Property Rua As %String [ Required ]. Nome } } 44 . Query QueryPessoa(Nome As %String.Anexo – Código do estudo de caso • Classe Pessoa.Nome. • Cliente. } Classe Cliente Class empresa.Endereco_Rua.Endereco_Rua. • Classe Endereco. ProcedureBlock ] { Property Numero As %Integer. ProcedureBlock ] { Property Nome As %String [ Required ]. • Classe Cliente. ProcedureBlock ] { Property CPF As %Integer [ Required ]. Endereco As Endereco) As %SQLQuery(CONTAINID = 1) { SELECT %ID. • Pessoa.Pessoa Extends %Persistent [ ClassType = persistent.Pedido [ Cardinality = many.Endereco Extends %SerialObject [ ClassType = serial. Relationship Pedidos As empresa. Query QueryCliente(Nome As %String. Index NomeIndex On Nome. CPF As %Integer.csp. • Classe Fornecedor.csp.Pessoa [ ClassType = persistent.csp.Endereco_Numero FROM Cliente ORDER BY CPF.csp.Nome.CPF.

Pedido Extends %Persistent [ ClassType = persistent.Endereco_Rua. Index DescricaoIndex On Descricao.'> <CENTER> <TABLE CELLPADDING="3"> 45 . return true. Query QueryPedido(Descricao As %String.nopredicates" ONSELECT="update"> <FORM NAME="form" CSPBIND="objForm" CSPJS="All" ONSUBMIT='return form_validate(). } // --> </SCRIPT> <!-. ProcedureBlock ] { Relationship Cliente As empresa.Descricao.Pessoa [ ClassType = persistent.use CSP:SEARCH tag to create a javascript function to invoke a search page --> <CSP:SEARCH NAME="form_search" CLASSNAME="empresa.Cliente [ Cardinality = one.Nome. Nome } } Classe Pedido Class empresa. Index CNPJIndex On CNPJ..Fornecedor Extends empresa.Get("OBJID"))#> <!-. Descricao } } Pessoa.Pessoa" WHERE="Nome" OPTIONS="popup.Pessoa" OBJID=#(%request. Inverse = Pedidos ].Cliente->CPF.CNPJ.Classe Fornecedor Class empresa.csp <H1 ALIGN="CENTER">Classe Pessoa</H1> <SCRIPT Language=JavaScript> <!-- function update(id) { #server(. Query QueryFornecedor(CNPJ As %Integer.Endereco_Numero FROM Fornecedor ORDER BY CNPJ.Valor FROM Pedido ORDER BY Cliente. Valor As %Float. Property Valor As %Float [ Required ]. Property Descricao As %String [ Required ].formLoad(id))#.use CSP:OBJECT tag to create a reference to an instance of the class --> <CSP:OBJECT NAME="objForm" CLASSNAME="empresa. Index ClienteIndex On Cliente. Endereco As Endereco) As %SQLQuery(CONTAINID = 1) { SELECT %ID. Cliente As Cliente) As %SQLQuery { SELECT Cliente->Nome. ProcedureBlock ] { Property CNPJ As %Integer [ Required ].

<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.form_new().'> <INPUT TYPE="BUTTON" NAME="btnExcluir" VALUE="Excluir" ONCLICK="#server(empresa.Cliente" OBJID=#(%request.csp <H1 ALIGN="CENTER">Classe Cliente</H1> <SCRIPT Language=JavaScript> <!-- function update(id) { #server(.</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.formLoad(id))#.Numero" SIZE="10"></TD> </TR> <TR> <TD>&nbsp.1:1972/csp/user/index.Get("OBJID"))#> <!-.0.</TD> <TD> <INPUT TYPE="BUTTON" NAME="btnSave" VALUE="Salvar" ONCLICK='form_save().'> <CENTER> <TABLE CELLPADDING="3"> <TR> <TD><FONT COLOR="#666666"><B><DIV ALIGN="RIGHT">ID:</DIV></B></FONT></TD> 46 .html">Página Inicial</a> </center> </BODY> </HTML> Cliente.CPF" OPTIONS="popup.use CSP:SEARCH tag to create a javascript function to invoke a search page --> <CSP:SEARCH NAME="form_search" CLASSNAME="empresa.Pessoa.use CSP:OBJECT tag to create a reference to an instance of the class --> <CSP:OBJECT NAME="objForm" CLASSNAME="empresa.value))#.OBJID.'> </TD> </TR> <TR> <TD>&nbsp."> <INPUT TYPE="BUTTON" NAME="btnClear" VALUE="Limpar" ONCLICK='form_new().nopredicates" ONSELECT="update"> <FORM NAME="form" CSPBIND="objForm" CSPJS="All" ONSUBMIT='return form_validate().'> <INPUT TYPE="BUTTON" NAME="btnSearch" VALUE="Pesquisar" ONCLICK='form_search().. return true.0.%DeleteId(form. } // --> </SCRIPT> <!-.Rua" SIZE="50" CSPREQUIRED></TD> </TR> <TR> <TD><B><DIV ALIGN="RIGHT"> Numero:</DIV></B></TD> <TD><INPUT TYPE="TEXT" NAME="EnderecoNumero" CSPBIND="Endereco.Cliente" WHERE="Nome.

value))#.'> <INPUT TYPE="BUTTON" NAME="btnExcluir" VALUE="Excluir" ONCLICK="#server(empresa.use CSP:SEARCH tag to create a javascript function to invoke a search page --> <CSP:SEARCH NAME="form_search" CLASSNAME="empresa.</TD> <TD><FONT COLOR="#000088" SIZE="2">(* Indica campos obrigatórios)</FONT></TD> </TR> </TABLE> </CENTER> </FORM> <HTML> <HEAD> <!-.Rua" SIZE="50" CSPREQUIRED></TD> </TR> <TR> <TD><B><DIV ALIGN="RIGHT">Numero:</DIV></B></TD> <TD><INPUT TYPE="TEXT" NAME="EnderecoNumero" CSPBIND="Endereco.Put your page Title here --> <TITLE> Cache Server Page </TITLE> </HEAD> <BODY> <center> <a href="http://127.use CSP:OBJECT tag to create a reference to an instance of the class --> <CSP:OBJECT NAME="objForm" CLASSNAME="empresa. } // --> </SCRIPT> <!-.Fornecedor" OBJID=#(%request.Pessoa.0.'> </TD> </TR> <TR> <TD>&nbsp.Numero" SIZE="10"></TD> </TR> <TR> <TD>&nbsp.</TD> <TD> <INPUT TYPE="BUTTON" NAME="btnSave" VALUE="Salvar" ONCLICK='form_save().csp <H1 ALIGN="CENTER"> Classe Fornecedor</H1> <SCRIPT Language=JavaScript> <!-- function update(id) { #server(.Put your page code here --> </BODY> </HTML> Fornecedor."> <INPUT TYPE="BUTTON" NAME="btnClear" VALUE="Limpar" ONCLICK='form_new(). <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">*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> <TD><INPUT TYPE="TEXT" NAME="EnderecoRua" CSPBIND="Endereco.html">Página Inicial</a> </center> <!-.Get("OBJID"))#> <!-.OBJID..0.formLoad(id))#.1:1972/csp/user/index.'> <INPUT TYPE="BUTTON" NAME="btnSearch" VALUE="Pesquisar" ONCLICK='form_search().%DeleteId(form.form_new(). return true.CNPJ" OPTIONS="popup.nopredicates" ONSELECT="update"> 47 .Fornecedor" WHERE="Nome.

Rua" SIZE="50" CSPREQUIRED></TD> </TR> <TR> <TD><B><DIV ALIGN="RIGHT">Numero:</DIV></B></TD> <TD><INPUT TYPE="TEXT" NAME="EnderecoNumero" CSPBIND="Endereco.0.Fornecedor. 48 .<FORM NAME="form" CSPBIND="objForm" CSPJS="All" ONSUBMIT='return form_validate().1:1972/csp/user/index..csp <H1 ALIGN="CENTER">Classe Pedido</H1> <SCRIPT Language=JavaScript> <!-- function update(id) { #server(.'> <INPUT TYPE="BUTTON" NAME="btnSearch" VALUE="Pesquisar" ONCLICK='form_search().</TD> <TD><FONT COLOR="#000088" SIZE="2">(* Indica campos obrigatórios)</FONT></TD> </TR> </TABLE> </CENTER> </FORM> <HTML> <HEAD> <!-.form_new().'> </TD> </TR> <TR> <TD>&nbsp.0.'> <INPUT TYPE="BUTTON" NAME="btnExcluir" VALUE="Excluir" ONCLICK="#server(empresa..Numero" SIZE="10"></TD> </TR> <TR> <TD>&nbsp."> <INPUT TYPE="BUTTON" NAME="btnClear" VALUE="Limpar" ONCLICK='form_new(). return true.html">Página Inicial</a> </center> </BODY> </HTML> Pedido.formClienteLoad(id))#.Put your page code here --> <center> <a href="http://127.value))#. } function updateCliente(id) { #server(.Put your page Title here --> <TITLE> Cache Server Page </TITLE> </HEAD> <BODY> <!-.'> <CENTER> <TABLE CELLPADDING="3"> <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">*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> <TD><INPUT TYPE="TEXT" NAME="EnderecoRua" CSPBIND="Endereco.%DeleteId(form.formLoad(id))#.</TD> <TD> <INPUT TYPE="BUTTON" NAME="btnSave" VALUE="Salvar" ONCLICK='form_save().OBJID. return true.

} // --> </SCRIPT> <CSP:OBJECT NAME="objForm" CLASSNAME="empresa.0.Pessoa.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.Get("OBJID"))#> <CSP:SEARCH NAME="form_search" CLASSNAME="empresa.'> </TD> </TR> <TR> <TD>&nbsp.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>&nbsp.0.</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.</TD> <TD><INPUT TYPE="BUTTON" NAME="btnSave" VALUE="Salvar" ONCLICK='form_save()."><B><DIV ALIGN="RIGHT">Cliente :</DIV></B></A></TD> <TD><INPUT TYPE="TEXT" NAME="Cliente" CSPBIND="Cliente."> <INPUT TYPE="BUTTON" NAME="btnClear" VALUE="Limpar" ONCLICK='form_new().html">Página Inicial</a> </center> </BODY> </HTML> 49 .Pedido" OBJID=#(%request.OBJID.'> <CENTER> <TABLE CELLPADDING="3"> <TR> <TD><INPUT TYPE="HIDDEN" SIZE="10" NAME="ClienteID" CSPBIND="Cliente"> <A HREF="JavaScript:findCliente().Pedido" WHERE="Descricao" OPTIONS="popup.form_new().nopredicates" ONSELECT="update"> <CSP:SEARCH NAME="findCliente" CLASSNAME="empresa.1:1972/csp/user/index.'> <INPUT TYPE="BUTTON" NAME="btnExcluir" VALUE="Excluir" ONCLICK="#server(empresa.'> <INPUT TYPE="BUTTON" NAME="btnSearch" VALUE="Pesquisar" ONCLICK='form_search().value))#.%DeleteId(form.Cliente" WHERE="Nome" OPTIONS="popup.nopredicates" CAPTION="Cliente " STARTVALUES="ClienteNome" ONSELECT="updateCliente"> <FORM NAME="form" CSPBIND="objForm" CSPJS="All" ONSUBMIT='return form_validate().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.