Criando
Aplicações com o
Caché
Versão Demo
Amir Samary
Sobre o Autor
Amir Samary foi aluno do curso de Bacharelado em Matemática com ênfase em Informática da
Universidade do Estado do Rio de Janeiro (UERJ) de 1996 a 2001. Também foi aluno do curso de Ciências da
Computação das Faculdades Associadas de São Paulo (FASP) de 2005 a 2006.
Amir entrou em contato com tecnologia InterSystems por primeira vez em 1997 quando começou a
trabalhar para uma empresa no Rio de Janeiro. Em 2003, Amir foi contratado pela InterSystems Brasil como
Sales Engineer e trabalhou apoiando clientes, universidades e ao processo interno de vendas da InterSystems.
Hoje Amir trabalha para a InterSystems Chile como Arquiteto de Integração e Interoperabilidade e é
responsável pela arquitetura e qualidade de todos os projetos de integração entre sistemas informáticos
implementados com tecnologia InterSystems no Chile.
Quem deve ler este livro?  3
Sumário  4
Quem é a InterSystems
A InterSystems é uma empresa americana localizada em Cambridge, MA. Foi fundada em 1978 e,
atualmente possui cinco produtos:
•
O Caché, Banco de Dados Orientado a Objetos de alta performance com total suporte a SQL.
•
O DeepSee, framework de BI (Business Intelligence) do Caché. A InterSystems apresenta o
DeepSee como um outro produto mas na verdade o DeepSee representa o Engine de BI do Caché
que pode ser utilizado em qualquer instalação do Caché que tenha uma licença de Caché com
DeepSee incluído.
•
O Ensemble, Plataforma de Integração SOA que se baseia e estende o Caché com funcionalidades
específicas para a construção de integrações complexas entre sistemas distintos, usando
tecnologias como BPEL (Business Process Execution Language), filas de mensageria, e etc. A
pesar de estender o Caché, o Ensemble é considerado um outro produto. Tudo o que você estudar
neste livro se aplica também ao Ensemble, mas o Ensemble possui mais funcionalidades
específicas para integrações.
•
O TrakCare, um HIS (Health Information Systems ou Sistema de Gestão Clínica) World Class,
totalmente web e baseado no Ensemble. O TrakCare é capaz de gerenciar de forma integrada
todas as atividades de uma Rede de Saúde composta de vários estabelecimentos como Hospitais,
Clínicas, Ambulatórios, Laboratórios, Farmácias e etc.
•
O HealthShare, Plataforma de Colaboração entre Instituições e Comunidades de Saúde, também
baseada no Ensemble, para implementação de um Registro Eletrônico de Saúde Regional ou
Nacional, de forma que toda informação de interesse possa estar disponível para o médico no ponto
de atendimento, onde quer que este seja.
4  Criando Aplicações com o Caché
Dedicatórias
Minha Esposa, Maira Marques Samary, companheira fiel
e sincera, que sempre me motivou, incentivou e ajudou a completar
todos os meus desafios. Uma mulher maravilhosa que me enche de
alegria e vontade de viver.
Meus Pais, Cláudio e Sandra Faria que tiveram
a
paciência que os bons pais possuem para educar seus filhos.
Introdução  5
Sumário  6
Quem deve ler este livro?
Este livro tem como assunto o Caché, Sistema Gerenciador de Banco de Dados Objeto-Relacional
(SGBDOR) da InterSystems Corporation.
O livro pode ser lido por estudantes, programadores e administradores de bancos de dados com
experiência em programação ou não, que desejam conhecer o Caché em toda a sua extensão. É recomendável
que o leitor já tenha algum conhecimento de conceitos básicos relacionados a programação orientada a objetos
(POO) como Classes, Herança e Polimorfismo, por exemplo. Também se recomenda que o leitor já tenha
conhecimentos básicos de algum outro bancos de dados e da linguagem SQL de consulta a bases de dados.
O livro tentará cobrir lacunas de conhecimento com explicações detalhadas e fará referencias à
documentação do Caché que é bastante rica e completa. Mas pode ser que o leitor tenha que buscar
conhecimento mais específico em outros livros para temas mais complexos ou abstratos. Existem excelentes
livros sobre UML, Orientação a Objetos e etc. Seria extremamente redundante cobrir estes temas neste livro, que
terminaria bastante grande e cansativo.
Se você está folheando este livro em uma livraria e está curioso a respeito do Caché, aconselho a ler
pelo menos o início do primeiro capítulo, que fala um pouco de sua arquitetura diferenciada, que justifica o nome
de Objeto-Relacional. O Caché é um produto único.
Professores de cadeiras como Bancos de Dados, Estruturas de Dados e Tópicos Especiais também
vão encontrar neste livro bastante material interessante para suas aulas. Não nos limitamos, neste livro, a
estudar apenas o Engine SQL e o Engine de Objetos do Caché, mas também o Caché Database Toolkit, a
plataforma sobre a qual estes Engines foram construídos. Esta plataforma prove serviços básicos de
persistência, concorrência, comunicação, dentre outros, além de linguagens de programação dinâmicas como o
Caché Object Script que permitem o acesso direto a estes serviços de forma que o programador possa optar por
construir seu próprio Engine de Banco de Dados se desejarem.
Mostramos ao leitor como o Caché armazena internamente os dados de seus objetos ou registros de
suas tabelas em estruturas multidimensionais (árvores) que podem ser vistas e manipuladas diretamente pelos
alunos como nenhum outro banco de dados permitiria. É possível entender, por exemplo, como os dados, índices
e streams são armazenados de forma distinta em árvores distintas e como isto afeta o desempenho. Os alunos
poderão ver estas estruturas e inclusive manipula-las diretamente.
6  Criando Aplicações com o Caché
Exploraremos também as melhores práticas no desenvolvimento de aplicações Web com o Caché
usando CSP (Caché Server Pages) e Zen. Mas não deixaremos de cobrir o desenvolvimento de aplicações com
outras tecnologias utilizando as suas APIs para Java, .NET e C++, mostrando todos os seus poderosos recursos
para a construção de poderosas aplicações Orientadas a Objetos.
O livro também cobre Administração do Caché e sua Configuração em Arquiteturas Distribuídas,
Business Intelligence, Web Services e XML, entre outros tópicos especiais importantes.
Introdução  7
Índice
1 INTRODUÇÃO
11 1.1 A Arquitetura do Caché _____________________________________________________________ 12 1.2 Obtendo o Caché__________________________________________________________________ 22 2
PREPARANDO O CACHÉ PARA NOSSOS ESTUDOS
25
2.1 O que vamos instalar? ______________________________________________________________
2.2 Sistemas Operacionais Suportados ___________________________________________________
2.3 Instalando o Caché no Windows ______________________________________________________
2.4 Estrutura, Databases e Namespaces __________________________________________________
2.4.1 Namespaces ____________________________________________________________________
2.5 Iniciando e Parando o Caché ________________________________________________________
2.6 Abrindo o Portal Administrativo do Caché _______________________________________________
3
26 30 31 37 39 41 43 CONHECENDO O TERRENO: CRIANDO SUA PRIMEIRA APLICAÇÃO E SE FAMILIARIZANDO COM AS
44
FERRAMENTAS
3.1 Conceitos e Definições necessárias para nossa Primeira Aplicação __________________________
3.2 Caché Studio _____________________________________________________________________
3.2.1 Abrindo o Caché Studio pela Primeira vez _____________________________________________
3.2.2 Verificando o Namespace (Conectando em Outro Namespace com o Caché Studio) ____________
3.2.3 Trabalhando com Projetos (Uma questão de metodologia) _________________________________
3.2.4 Criando Nossa Primeira Classe ______________________________________________________
3.2.5 Usando a Janela de Inspeção _______________________________________________________
3.3 Criando nossos Primeiros Objetos ____________________________________________________
3.3.1 Abrindo o Caché Terminal __________________________________________________________
3.4 Conhecendo o Portal de Administração ________________________________________________
3.4.1 Abrindo o Portal de Administração do Caché ___________________________________________
3.4.2 A Documentação de Nossa Classe ___________________________________________________
3.4.3 Listando os Objetos usando SQL ____________________________________________________
3.5 Criando Nossa Primeira Página Web __________________________________________________
3.5.1 Criando Nossa Primeira Página CSP _________________________________________________
3.5.2 Salvando e Compilando nossa Primeira Página CSP _____________________________________
3.5.3 Alterando a Página para Exibir Nossos Contatos ________________________________________
45 47 47 49 50 55 59 60 60 69 69 70 74 80 80 81 82 Sumário  9
3.5.4 Usando Tags Caché Server Pages Especiais ____________________________________________ 85 3.6 Criando Nossa Primeira Rotina Caché Object Script _______________________________________ 88 3.6.1 Criando nossa primeira Rotina Caché Object Script _______________________________________ 88 3.6.2 Salvando e Compilando nossa Primeira Rotina __________________________________________ 89 3.6.3 Expandindo as Funcionalidades ______________________________________________________ 90 3.7 Criando a sua Primeira página Zen _____________________________________________________ 93 3.7.1 Criando a Classe de Aplicação Zen____________________________________________________ 94 3.7.2 Criando a nossa primeira página Zen __________________________________________________ 97 3.7.3 Incluir, Excluir e Alterar ____________________________________________________________ 102 3.7.4 Conclusão ______________________________________________________________________ 104 3.8 Consultando a Documentação do Caché _______________________________________________ 105 10  Criando Aplicações com o Caché
1 Introdução
Escrever um livro sobre o Caché é uma tarefa complexa, pois envolve tantos assuntos e tecnologias
que fica difícil saber por onde começar. Dizer isto pode levar o leitor a pensar que o Caché é complicado, mas
não é assim. Imagino que seja difícil compreender esta minha dificuldade sem compreender um pouco a
arquitetura básica do Caché e é por isto que a introdução de este livro começa exatamente explicando esta
arquitetura única que, pessoalmente, nunca vi em nenhum outro Sistema Gerenciador de Banco de Dados
(SGBD) ou servidor de aplicações e é esta arquitetura única que torna o Caché, um Sistema Gerenciador Banco
de Dados Orientados Objeto-Relacional, poderoso e versátil.
Neste capítulo vamos:
•
Conhecer a Arquitetura do Caché e onde ele normalmente é usado,
•
Saber como obter uma versão atual do Caché,
Introdução  11
1.1 A Arquitetura do Caché
Conhecer a arquitetura do Caché é essencial para nosso estudo e é por esta razão que este tópico
aparece como primeiro assunto deste livro. Como você pode ver na Figura 1-1, no centro da arquitetura do
Caché, temos o Caché Database Engine que oferece um conjunto completo de serviços como:
•
Isolamento do hardware e sistema operacional subjacente – O Caché Database Engine é uma
máquina virtual disponível em muitas plataformas (combinações de hardwares e sistemas
operacionais).
•
Linguagens – O Caché suporta varias
linguagens de programação como o
Caché Object Script, VBScript, MVBasic,
SQL, TSQL, ISQL, Mumps e etc. Para
suportar este conjunto de linguagens, o
Caché trabalha de forma transparente
com um conjunto de compiladores que
transformam estas linguagens em um
único código objeto que pode ser
executado pelo Caché Database Engine.
•
IO – O Caché permite o Acesso a
Arquivos em Disco, fita, Rede (TCP/IP),
Pipes, etc.
Figura 1-1 – Caché Database Engine
•
Gerenciamento de objetos – O Caché
Database Engine gerência a alocação de memória e instanciação de objetos e traz um garbage
collector que cuida de liberar a memória de objetos que não são mais usados.
•
Persistência – Armazenamento seguro de dados de objetos em disco. Os dados armazenados em
bases de dados Caché sempre permanecerão íntegros enquanto o arquivo de dados está integro. A
única coisa que poderia corromper um arquivo de dados do Caché seria problemas no hardware e a
única maneira de evitar isto (para qualquer banco de dados) é comprando hardware de qualidade,
com redundância (RAID) e etc.
•
Controle de concorrência – Para controlar o acesso concorrente a dados em memória ou em disco
e garantir que processos diferentes não sobrescreverão os dados uns dos outros inadvertidamente
em uma ou mais máquinas.
•
Controle de transações – Para garantir que um conjunto de operações em disco possam ser
executadas dentro dos conceitos que definem uma transação que basicamente significa que: ou
todas as mudanças provocadas por operações são persistidas com sucesso na base de dados ou
nenhuma delas.
•
Controle de processos – Alocação de processos no sistema operacional para os processos
correspondentes no Caché, alocação dinâmica de memória, coleta de lixo, etc.
12  Introdução
A lista de serviços não tem o objetivo de ser completa. Muitos destes serviços são essenciais para a
construção de qualquer sistema gerenciador de banco de dados e formam o que poderíamos chamar de Núcleo
ou Fundação do Caché.
Alguns destes serviços também podem ser encontrados em algumas implementações de Máquinas
Virtuais conhecidas, como Java e .NET. De fato, o Caché Database Engine (ou engine de banco de dados do
Caché) é uma Máquina Virtual como as mencionadas, que se diferencia por implementar serviços específicos
para bancos de dados diretamente em seu runtime,
como os serviços de persistência e controle de
transações locais e distribuídas, que não existem nos
runtimes de outras Máquinas Virtuais mais
conhecidas que, diferente do Caché, normalmente só
implementam uma API a través da qual podem
comunicar-se com um sistema de bancos de dados
externo, delegando esta funcionalidade. Poderíamos
dizer que o Caché é uma máquina Virtual Completa.
Podemos pensar no Caché Database Engine
como um poderoso Database ToolKit ou SDK.
Usando este ToolKit, a InterSystems implementou um
Sistema Gerenciador de Banco de Dados Orientado a
Objetos (SGBDOO), um Sistema Gerenciador de
Figura 1-2 – Arquitetura de Engines do Caché
Banco de Dados SQL1 (SGBDSQL) e toda sua
infraestrutura de Business Intelligence como pode ser observado na Figura 1-2.
Todos estes componentes, na verdade, foram construídos juntos, não só em cima da mesma fundação
(o Caché Database Engine), mas também cooperando uns com os outros.
O Caché Database Engine é a fundação que armazena os dados em uma estrutura neutra hierárquica e
provê todos os serviços já mencionados para todos os Engines de Dados.
O Engine de Objetos foi construído apoiando-se no Caché Database Engine e serve de base para todos
os outros Engines de Dados. Por outro lado, como veremos, o Caché depende de seu Engine SQL para
encontrar seus objetos. Isto é: A linguagem de consulta aos objetos do Caché é a conhecida e consagrada SQL.
Mencionaremos mais sobre isso nos próximos capítulos.
O Engine de SQL foi construído apoiando-se no Caché Database Engine e no Engine de Objetos. Como
veremos nos próximos capítulos, a definição de uma tabela SQL é mantida como uma Classe. Toda vez que
usamos comandos DDL (Data Definition Language), através do Engine de SQL, para manipular a definição desta
tabela, o Engine de SQL altera a definição da classe que a representa.
SQL (Structured Query Language) – Linguagem Estruturada de Consulta criada em 1970 e vem evoluindo sempre, sendo
padronizada tanto pela ISO quanto pela ANSI e hoje é a principal linguagem usada para fazer consultas e manipular os
dados armazenados em sistemas gerenciadores de bancos de dados de diferentes fornecedores.
1
Introdução  13
Figura 1-3 - Armazenamento
O Engine de BI foi construído para dar aos desenvolvedores de aplicações baseadas no Caché recursos
poderosos de BI diretamente associados ao modelo de dados de suas aplicações. Isto significa que se um
desenvolvedor desejar adicionar à sua aplicação recursos de BI poderosos, não precisará comprar outro software
e duplicar seus dados em outro repositório de BI. Ele poderá usar os próprios recursos de BI do Caché, que já
conhecerão seu modelo de dados e, mais importante, terão acesso direto, em tempo real, aos dados
transacionais o que permite ao desenvolvedor oferecer recursos de BI embebidos em sua aplicação e em tempo
real.
O Acesso Direto permite que a aplicação possa acessar os dados armazenados no Caché diretamente,
saltando todos os outros Engines como se pode observar na Figura 1-3. Se o desenvolvedor desejar o máximo
de desempenho e flexibilidade que qualquer sistema gerenciador de banco de dados poderia jamais oferecer, ele
pode optar por acessar seus dados diretamente desta maneira.
Quando estamos usando os outros Engines para inserir um registro via SQL ou criar e salvar um objeto,
o Caché armazena os dados em um mesmo local dentro do Caché Database Engine em estruturas hierárquicas
as quais chamamos de Globais como pode ser visto na figura Figura 1-3. O Acesso Direto permite realizar
operações simples e diretas nestas estruturas de dados internas saltando o peso que o Engine de SQL ou o
Engine de Objetos poderiam naturalmente impor. É um recurso poderoso que, quando bem utilizado, pode ser a
solução para o tratamento de grandes volumes de dados ou para lidar com um processamento de dados muito
14  Introdução
intenso. Sendo estruturas de dados hierárquicas, as globais representam também um modelo alternativo de
dados, flexível, fácil e rápido, para o tratamento de problemas mais complexos.
Desta forma, o desenvolvedor pode escolher quando deseja usar o Modelo Orientado a Objetos de
acesso aos dados ou de construção de sua aplicação ou quando necessita do Modelo SQL de acesso aos dados.
Também pode escolher dar a sua aplicação recursos poderosos de Business Intelligence em Tempo Real ou
acessar os dados diretamente para atender às suas necessidades de desempenho e volume. De fato o
desenvolvedor pode escolher criar uma aplicação com todos estes mecanismos juntos para resolver diferentes
requisitos de arquitetura, interoperabilidade, desempenho e funcionalidade de sua aplicação.
Cada meio de acesso aos dados expõe um conjunto de APIs que permitem que aplicações escritas nas
mais variadas linguagens possam acessar os dados. Se tomamos a linguagem Java como exemplo, podemos
em uma mesma aplicação Java acessar os dados via SQL (JDBC), via Objetos, acesso direto ou de todas as
formas ao mesmo tempo de acordo com as necessidades das diversas partes da aplicação.
Figura 1-4 – Métodos de Acesso aos Dados no Caché
Se o leitor está pensando mais a frente, prevendo que estas múltiplas vias de conexão de uma mesma
aplicação poderiam significar que uma mesma instancia da aplicação estaria abrindo duas ou mais conexões
concorrentes ao Caché está enganado. O driver JDBC da InterSystems e a API de Objetos Java, por exemplo,
compartilham um único protocolo interno de comunicação de maneira que uma aplicação Java pode instanciar
um objeto e fazer uma consulta SQL a través da mesma (única) conexão ao banco de dados de forma
concorrente e segura, garantindo um controle de transações unificado, simples e efetivo. O mesmo é válido para
outros meios de conexão como ADO.NET, Perl, Object C, ou C++ por exemplo.
Introdução  15
Poder escolher e combinar recursos tão poderosos é o que torna o Caché uma plataforma
extremamente atrativa para o desenvolvimento de aplicações modernas e complexas. A Figura 1-5 mostra como
os Engines do Caché traduzem as chamadas às suas APIs a um mesmo conjunto de instruções para gerenciar
os dados diretamente nas globais dentro do Caché Engine e como o acesso direto permite a um programa enviar
as instruções diretamente. Você pode imaginar quão rápido pode ser esta maneira de trabalhar:
Figura 1-5 - Não Importa o Meio de Acesso: Tudo termina em uma Global
A Figura 1-5 também mostra como os Engines de SQL do Caché consegue traduzir um comando SQL
como o INSERT para instruções Caché Object Script internas e como o Engine de Objetos faz o mesmo com os
objetos manipulados a través de qualquer linguagem de programação como o Java, C++, linguagens .NET., etc.
Veremos nos próximos capítulos como o Engine de BI faz o mesmo para a linguagem MDX.
Além disso, como já mencionamos, não existem duas definições para um mesmo objeto de banco de
dados. Uma tabela, por exemplo, quando criada no Caché através do conhecido comando DDL (Data Definition
Language) CREATE TABLE, cria uma classe com toda a definição da tabela. Quando decidimos adicionar uma
nova coluna à tabela também via DDL, o Engine de SQL adiciona uma nova propriedade à classe existente.
O contrário também é verdade: Quando criamos uma classe, esta pode ser enxergada como uma tabela
no Engine SQL. Quando adicionamos ou alteramos uma propriedade de uma classe, a sua imagem SQL
correspondente refletirá estas mudanças em suas colunas. Além disto, não importa se criamos os dados via
16  Introdução
objetos ou via SQL, estes são armazenados na mesma Global (consulte a Figura 1-5 de novo) dentro do Caché
Database Engine. Não existe duplicação de dados ou de definições de maneira alguma.
As vantagens desta arquitetura, de acordo com a documentação do Caché são:
•
Os Engines SQL e Orientado a Objetos falam diretamente com o Caché Database Engine para
trabalhar com os dados de forma extremamente eficiente. Não há qualquer tipo de mapeamento ou
ponte objeto-relacional.
•
A separação lógica da base de dados (Classes/Tabelas) de sua configuração física (globais no
Caché Database Engine) torna possível uma radical reconfiguração da forma como a aplicação foi
instalada, sem qualquer mudança na lógica da aplicação. Esta noção é completamente nova para
muitos expertos em sistemas gerenciadores de bases de dados já que é comum considerar que as
tabelas representam o modelo físico. Podemos continuar com esta mesma noção no Caché mas é
preciso lembrar que o Caché expõe para nós sua estrutura interna de armazenamento enquanto
que outros SGBD a escondem. A maioria dos SGBD permitem definir em que base de dados os
dados de uma tabela poderão estar armazenados. O Caché, por exemplo, vai mais além e permite
reconfigurar completamente como os dados de uma tabela são distribuídos não só em uma, mas
em várias bases de dados diferentes (em discos diferentes se você quiser) para obter o máximo de
desempenho. Podemos, por exemplo, colocar os dados de índices em uma base de dados, os
dados de campos BLOB/CLOB/Streams em outra e os dados em si em uma terceira base de dados,
de forma transparente para o usuário da tabela.
•
O fato de o Caché Database Engine ser aberto, permite que se faça uso direto de seus recursos
quando necessário. Desde construir seu próprio sistema de banco de dados customizado a
implementar otimizações específicas para ter o máximo de performance possível disponível para
aplicações críticas.
•
Uma plataforma planejada para o futuro: A arquitetura do Caché permite que futuras melhorias no
Caché Database Engine sejam feitas sem afetar aplicações existentes. Mudanças de versões são
relativamente simples, mesmo quando mudanças agressivas tenham sido feitas na forma como as
informações são armazenadas. Na medida em que novas tecnologias surgem, o Caché pode
adicionar suporte a elas como componentes nativos, de alta performance com quase nenhum
impacto em aplicações existentes.
O Caché também traz embutido um Servidor de Aplicações Web (Caché Server Pages, ou CSP para
abreviar) que permite a construção de aplicações Web orientadas a objetos, trabalhando em conjunto com todos
os recursos das camadas subjacentes da arquitetura de forma totalmente integrada para o máximo de
simplicidade e desempenho.
Introdução  17
Figura 1-6 – Servidor de Aplicações Web
Com o CSP podemos escrever aplicações Web da mesma forma como escrevemos em JSP (Java
Server Pages) ou ASP.NET (Active Server Pages .NET). Os métodos de acesso externo que o Caché oferece
(ODBC, JDBC, ADO.NET, Java, etc.) não são utilizados quando construímos uma aplicação CSP pois nossas
páginas são compiladas em classes dentro do próprio Caché!
Figura 1-7 - Caché Server Pages x Java Server Pages
18  Introdução
Observe que enquanto a aplicação JSP necessita abrir uma conexão JDBC para conectar-se ao Caché,
a aplicação Caché Server Pages não só não precisa preocupar-se com conexões como também pode optar por
usar o acesso direto e trabalhar diretamente com as globais! Isto não significa que um desenvolvedor Caché usa
acesso direto as globais sempre. Usar objetos e SQL é muito rápido e é essencial por vários motivos e, em
verdade, um desenvolvedor típico de Caché usa objetos e SQL a maior parte do tempo. Mas ter a disposição o
acesso direto é uma grande vantagem em muitas situações.
Desta forma, nossa aplicação CSP não necessita de esforço algum para chegar a seus dados, bastando
com executar uma consulta ou abrir os objetos no banco. Uma aplicação Web CSP não necessita abrir conexões
de Rede ao Caché ou gerenciar pool de conexões. Não existem conexões, e isto faz com que uma aplicação
CSP seja naturalmente mais rápida que uma aplicação Web desenvolvida em outra tecnologia.
A boa notícia é que a InterSystems fez algo parecido para o Java também! Com o Caché eXtreme para
Java, o Caché expõe as suas principais APIs (JDBC, Objetos e Acesso Direto) via JNI, o que permite
comunicação direta com um processo Caché! Parece complicado mas na verdade é bastante simples de usar. Se
você só usa JDBC padrão, ainda assim a sua aplicação poderá beneficiar-se de um grande aumento de
velocidade pois a “conexão JDBC” usando Caché eXtreme é uma conversação direta da sua aplicação Java com
um processo Caché. É claro que com eXtreme, o trabalho via objetos também é muito mais rápido que a través
de uma conexão JDBC/TCP e o acesso direto às globais se torna possível!
A figura abaixo mostra o paralelo entre uma aplicação Java que se conecta ao Caché via uma conexão
JDBC/TCP e outra aplicação Java que se conecta via JDBC/eXtreme:
Figura 1-8 - Caché eXtreme for Java
Introdução  19
Observe que a aplicação Java que usa o Caché via eXtreme tem acesso direto ao Caché via objetos,
SQL e acesso direto às globais! Com esta configuração, o Caché consegue substituir bancos de dados “in
memory” entregando mais velocidade que estes bancos de dados especializados, mas com maior segurança e
recursos.
Além do CSP, desde a versão 2007 do Caché, é possível utilizar o Zen, o framework AJAX
(Asynchronous Javascript And XML) da InterSystems que permite o desenvolvimento de aplicações Web
altamente interativas. O Zen é construído sobre o CSP e o estende com um poderoso framework de objetos
visuais como janelas, painéis, formulários, caixas de seleção, botões, grids e etc. com os recursos de arrastar e
soltar e gerenciamento de eventos no cliente e no servidor.
O Zen permite a construção de aplicações Web profissionais totalmente integradas ao modelo de
objetos do Caché com alta segurança, de forma simples e organizada, em um único ambiente de
desenvolvimento. A diferença entre o Zen e o CSP é que cada página Zen, depois de carregada no navegador do
usuário, interage com o servidor a través de pequenas conexões HTTP para enviar e receber dados, de maneira
transparente para o usuário. Quando o usuário atualiza uma tabela de elementos, por exemplo, a página não é
completamente submetida para o servidor como ocorre normalmente quando usamos CSP, JSP, PHP, etc. Em
lugar disto, o Zen abre uma conexão HTTP invisível para o usuário e solicita os dados atualizados que são
retornados e atualizados na tabela de elementos.
Os componentes de uma página Zen são renderizados como HTML, CSS e JavaScript padrão, de
maneira que não é necessário nenhum plugin para que suas páginas Zen possam ser abertas nos
navegadores dos usuários. Uma página Zen pode ser visualizada da mesma forma no Internet Explorer
ou no Safari em um iPhone, por exemplo.
O Zen é um framework aberto e extensível e sua maior vantagem é que a grande maioria de seus
componentes como formulários, grids, caixas de texto e etc. podem trabalhar conectados aos objetos
persistentes na base de dados poupando o desenvolvedor do trabalho de costurar tecnologias diferentes para
construir aplicações realmente interativas e orientada aos dados armazenados no banco de dados.
Não poderíamos terminar de falar da arquitetura do Caché sem mencionar a sua escalabilidade. Um
banco de dados pode escalar tanto vertical quanto horizontalmente. Escalabilidade vertical é obtida ao adicionar
mais memória e mais CPUs a um único servidor e a escalabilidade horizontal é obtida ao adiciona mais máquinas
para atender em paralelo às requisições dos usuários.
20  Introdução
Figura 1-9 - Escalabilidade Horizontal Massiva com o ECP
O Caché escala muito bem tanto verticalmente quanto horizontalmente. Para escalar horizontalmente, o
Caché permite construir uma configuração de servidores interconectados a través do protocolo ECP (Enterprise
Cache Protocol). A Figura 1-9 mostra varias caixinhas conectadas. As caixinhas “Server” são todas instalações
normais de Caché que estão se comportando como um ator específico (Database Server x Application Server).
Observe que o Caché configurar um cluster de servidores de aplicações conectados via ECP a um cluster de
base de dados espelhado.
Todos os componentes de uma aplicação que se podem executar ou armazenar no servidor como
classes, stored procedures, páginas CSP/Zen compiladas, dados e rotinas estão no servidor de banco dados.
Quando conectamos um servidor de aplicações (inicialmente vazio), via ECP, a um servidor de banco de dados
este servidor de aplicações automaticamente expõe todos estes componentes. Não é preciso fazer nada mais!
Os usuários podem simplesmente conectar-se a qualquer um dos servidores de aplicação e trabalhar
normalmente. Você pode variar o número de servidores de aplicação de acordo com a variação do número de
usuários.
ooo
Introdução  21
1.2 Obtendo o Caché
A melhor maneira de se obter a versão mais atual do Caché é baixando-a do site da própria
InterSystems:
http://www.intersystems.com/cache/downloads/index.html
Você terá que se registrar caso já não tenha um login e senha. A versão que se baixa através deste link
não é igual à versão que se recebe quando se compra o produto: Trata-se de uma versão que não necessita de
licença para funcionar, chamada de “Free Single-user Caché” ou “Caché PC”. No entanto, possui algumas
limitações:
•
Apesar de permitir o uso de qualquer tecnologia de desenvolvimento (CSP, ODBC, JDBC,
ADO.NET, Java Extreme, etc.), esta versão não aceita conexões que venham de outras máquinas.
Isto significa que sua aplicação, independente de sua tecnologia, caso esteja usando esta versão
limitada do Caché, tem que rodar na mesma máquina onde está rodando o Caché.
•
Além disto, esta versão limitada do Caché só permite que um usuário seja usado por vez. Isto é: Se
você estiver construindo uma aplicação Java, esta aplicação poderá rodar na mesma máquina do
Caché e abrir uma conexão (JDBC, por exemplo) ao banco, usando um usuário e senha
específicos. Mas esta mesma aplicação não poderá abrir outra conexão ao Caché usando outro
usuário enquanto o primeiro ainda estiver conectado.
•
Existe, no entanto, um alívio para a restrição acima: O Caché permite que um mesmo usuário abra
até 252 conexões concorrentes (ao mesmo tempo). Ou seja: Esta mesma aplicação Java, acima,
poderia de fato abrir até 25 conexões ao Caché, desde que usasse o mesmo usuário e senha.
•
Apesar de o Caché estar disponível para diversas plataformas, esta versão de avaliação (Caché
PC) só está disponível para Windows 2000, Windows XP, Windows Server 2003, Windows Vista,
Mac OS X, Red Hat Linux, e SuSE Linux. Recomendo baixar a versão para Windows para
acompanhar este livro.
•
A instalação do Caché PC é muito mais simples, com menos perguntas e é feita com uma
configuração de segurança Mínima. Isto significa que todos os serviços estão ativos e rodando e
que você pode conectar-se (ao Caché Terminal, Studio, ou através de qualquer uma das APIs de
conexão) sem informar usuário ou senha (para facilitar a vida para os iniciantes).
As restrições são menos incômodas do que parecem e você pode usar esta versão para criar uma
aplicação de avaliação usando qualquer tecnologia desde que todos os componentes de sua aplicação rodem na
mesma máquina do Caché.
2
Este numero pode mudar para mais ou para menos de acordo com a versão do Caché.
22  Introdução
O fato de ter se registrado para avaliar o Caché lhe dá direito a suporte limitado, via 0800 ou e-mail. Tire
o restante de suas dúvidas sobre a versão de avaliação do Caché (Caché PC) no seguinte site:
http://www.intersystems.com/cache/downloads/cachepcfaq.html
Se as limitações impostas pela versão de avaliação do Caché (Caché PC) dificultam a sua avaliação do
produto, você pode entrar em contato com um escritório local da InterSystems e pedir que lhe enviem um CD
com a versão oficial do produto e uma licença demo que durará alguns meses. Esta licença demo é uma licença
normal, igual a uma licença comercial, de Caché; mas com data de expiração mais curta. Desta forma, nenhuma
das limitações acima se aplicam, pois você estará usando a versão de produção do produto (enviada por CD) e
uma licença válida. Uma lista com todos os escritórios da InterSystems no mundo, com informações de contato,
pode ser encontrada no seguinte endereço:
http://www.intersystems.com/offices/index.html
É importante lembrar que não se deve tentar usar a licença demo enviada pela InterSystems em uma
instalação de Caché PC. O Caché PC não aceita licenças. É preciso instalar a versão de produção,
enviada em CD pela InterSystem para usar a licença demo.
Introdução  23
2 Preparando o Caché para Nossos Estudos
Não é possível começar a aprender nenhum software novo sem instala-lo em nossas máquinas e saber
o mínimo suficiente para por os pés no chão e nos sentir à vontade para usa-lo, certo? Mesmo que você já tenha
instalado o Caché ou já conheça um pouco do processo de instalação, recomendo a leitura deste capítulo, pois
aqui vamos:
•
Aprender um pouco sobre como os componentes server e client do Caché se relacionam.
•
Aprender a instalar o Caché no Windows e saber como responder às poucas perguntas que
são feitas durante o processo de instalação.
•
Conhecer um pouco da organização lógica do Caché e como ele armazena suas informações
em namespaces e databases. Isto será muito útil para todos os capítulos que se seguem.
Preparando o Caché para Nossos Estudos  25
2.1 O que vamos instalar?
A instalação do Caché é um processo relativamente simples em todos os sistemas operacionais
suportados. Antes de seguirmos com o processo de instalação, é importante primeiro entender o que vem no CD
de instalação e o que precisamos instalar de fato. Se você ainda não tem uma cópia de instalação do Caché, a
Introdução deste livro explica como conseguir uma versão de avaliação (Caché PC) ou uma versão completa.
O Caché pode ser dividido em duas grandes partes: A parte server e a parte client:
Máquina Client
Qualquer
Sistema
Operacional
Suportado
Máquina Server
Rede TCP
Qualquer
Sistema
Operacional
Suportado
Figura 2-1 - Componentes de Instalação do Caché
A instalação de Caché para Windows traz as duas partes em um único setup. Desta forma, quando você
for instalar o Caché em sua máquina Windows, o programa de instalação perguntará o que você deseja instalar:
•
Um ambiente de desenvolvimento (server + client),
•
Apenas os componentes server,
•
Apenas os componentes client (como drivers de ODBC, ADO.NET, JDBC, Java Binding, Perl,
Python, o ambiente de desenvolvimento Windows – Caché Studio, além de outros componentes)
•
Apenas os componentes para habilitar um servidor Web para funcionar com o Caché
•
Ou uma instalação customizada onde você pode escolher instalar apenas componentes específicos
do Caché, da parte server ou client.
A instalação do Caché para ambientes Unix/Linux também segue a mesma linha, permitindo que se
escolha quais componentes da parte server e da parte client se deseja instalar. Mas é importante ressaltar que os
componentes da parte client disponíveis para instalação podem variar de acordo com a plataforma onde se
instala. A instalação para Unix/Linux, por exemplo, traz muitos componentes em comum com a instalação para
Windows, mas não traz o plugin ISAPI para o Internet Information Server da Microsoft pois este produto só
funciona em Windows.
Além disto, existe uma instalação de Caché específica para cada combinação de microprocessador e
sistema operacional. Desta forma, se você for pedir para a InterSystems uma versão demo de Caché para uma
máquina qualquer, especifique corretamente o processador (Intel, SPARC, PPC, 32bits/64bits e etc.) e o Sistema
Operacional (Window, RedHat Linux, AIX, HPUX, Mac OS X, Solaris, e etc.). Isto se deve ao fato de que a parte
server do Caché, escrita em ANSI C, Assembly e C++, é recompilada em cada uma das plataformas suportadas,
usando os compiladores específicos destas plataformas, para tirar o máximo do conjunto de instruções do
microprocessador e das otimizações específicas do compilador da plataforma e do sistema operacional
subjacente.
26  Preparando o Caché para Nossos Estudos
Além disto, o ambiente de desenvolvimento do Caché, o Caché Studio, só funciona em ambiente
Windows e, por isto mesmo, somente a instalação do Caché para Windows o traz. É por esta razão que a
InterSystems costuma enviar junto com o CD de instalação do Caché para Unix/Linux, o CD de Instalação do
Caché para Windows. Assim, você pode instalar o Caché em um servidor RedHat Linux e instalar a parte client,
junto com o Caché Studio, nas máquinas Windows dos desenvolvedores.
Figura 2-2 – Caché Studio (Editando uma classe de exemplo)
A parte server não depende da parte client para funcionar. Mas a parte client só é útil se houver um
Caché Server instalado em algum lugar na rede (ou na própria máquina local) onde ela possa se conectar.
É perigoso misturar versões de componentes. Por exemplo, não é recomendável usar o Caché Studio
do Caché 2007 conectado a um servidor rodando Caché 2010 ou vice-versa. Além disto, drivers de
ODBC, JDBC, ADO.NET, Java Binding e etc. também tem restrições de versões de Caché server que
devem ser respeitadas. Mas, normalmente, componentes client de versões superiores (como o driver de
ODBC do Caché 2010) funcionam também com servers de versões inferiores (como com o Caché 2007
ou 2008). A documentação do Caché traz um mapa de compatibilidade de componentes entre as
diversas versões do produto bastante simples de entender.
Preparando o Caché para Nossos Estudos  27
A primeira versão de produção do Caché foi a 2.1.6. Depois seguiram versões numeradas de forma
semelhante como a 3.x, 4.x e 5.x. Mas em 2006 a InterSystems mudou a numeração de suas versões. A
última versão com numeração antiga foi a 5.2.3. Depois desta vieram a 2007.1, 2007.2, 2008.1, e assim
por diante.
Toda a Administração do Caché pode ser feita através de um portal Web (veja Figura 2-3) de forma
que qualquer máquina que possua um navegador (como o Internet Explorer ou o Firefox) é capaz de se conectar
ao Caché Server e administrá-lo independente de ter instalado a parte client nesta máquina ou não.
Figura 2-3 – Portal de Administração do Caché aberto no Internet Explorer
Este portal administrativo oferece ferramentas muito úteis para:
•
Desenvolvedores de aplicações e DBAs - Execução de comandos SQL, Plano de Execução
de comandos SQL, lista de processos em execução e etc.
•
Administradores – Configuração de perfis de usuários, usuários, segurança, criação de
bases de dados, namespaces, instalação de chaves criptográficas (SSL/TLS), configurações
de informações de domínios de segurança, LDAP, e etc.
•
Operadores – Backup, Agendamento de Tarefas, Monitoração, consultas as tabelas de
processos, locks, ao uso da licença e etc.
Caso este portal Web não possa ser acessado por algum motivo qualquer (em uma crise), o Caché
também oferece ferramentas de administração via linha de comando na console do servidor ou via telnet de
forma que em uma emergência, um administrador sempre poderá trabalhar para restaurar o ambiente,
independente do estado do portal.
28  Preparando o Caché para Nossos Estudos
É comum em um ambiente de produção3 que os administradores e operadores responsáveis pelo Caché
não tenham que instalar nada em suas máquinas para administrar o banco, fazer backups, promover
novos componentes para produção e etc. Eles utilizam o portal web de administração e não precisam do
Caché Studio.
Além do Caché Studio e do Portal Administrativo, também são instalados no client outras ferramentas
como o Caché Terminal e a Documentação completa do produto. Vamos explicar o uso de cada um destes
componentes nos capítulos que se seguem, mas é importante saber que todos podem ser facilmente
encontrados no menu Iniciar do Windows ou no Cubo do Caché. O Cubo do Caché, que exploraremos mais
adiante, fica ao lado do relógio, na bandeja de sua barra de tarefas, e tem a aparência de um cubo mesmo: .
Ao clicar no Cubo do Caché, um menu se abre com todas as ferramentas do Caché.
Ambiente de produção – Quando disponibilizamos um sistema de informação para usuários, normalmente reservamos para
ele uma máquina, ou conjunto de máquinas, separadas das máquinas que são normalmente utilizadas para se desenvolver
o sistema (ambiente de desenvolvimento). Estas máquinas costumam ficar em “data centers” ou salas de acesso restrito, e
qualquer alteração no software instalado nestas máquinas passa por um rigoroso processo de auditoria, validação e
autorização de forma a manter a integridade do ambiente.
3
Preparando o Caché para Nossos Estudos  29
2.2 Sistemas Operacionais Suportados
O Caché é suportado em uma série de sistemas operacionais e plataformas de hardware diferentes:
•
Apple Mac OS X 10.6 for x86-64
•
HP HP-UX 11i v2, v3 for Itanium
•
HP HP-UX 11i v2, v3 for PA-RISC-64
•
HP OpenVMS 8.2, 8.3, 8.4 for Alpha
•
HP OpenVMS 8.3, 8.3-1H1, 8.4 for Itanium
•
HP Tru64 UNIX 5.1B for Alpha
•
IBM AIX 5L V5.3, 6.1 for System P-32
•
IBM AIX 5L V5.3, 6.1, 7.1 for System P-64
•
Microsoft Windows XP Pro, Server 2003, Vista, Server 2008, 7 for x86-32
•
Microsoft Windows Server 2003, Vista, Server 2008, 7 for x86-64
•
Microsoft Windows Server 2003, Server 2008 for Itanium
•
Microsoft Windows Server 2008 for Amazon EC2 for x86-64
•
Oracle Enterprise Linux 5 for x86–64
•
Oracle Solaris 10 for SPARC-64
•
Oracle Solaris 10 for x86-64
•
Red Hat Enterprise Linux v.4, 5, 6 Advanced Platform for x86-32
•
Red Hat Enterprise Linux v.4, 5, 6 Advanced Platform for x86-64
•
Red Hat Enterprise Linux v.4, 5 Advanced Platform for Itanium
•
Red Hat Enterprise Linux 5 x86-64 for Amazon EC2
•
SUSE Linux Enterprise Server 10, 11 for x86-32
•
SUSE Linux Enterprise Server 10, 11 for x86-64
•
SUSE Linux Enterprise Server 10, 11 for Itanium
Uma lista atual de todas as plataformas suportadas para todas as versões de Caché pode ser
encontrada em:
http://www.intersystems.com/cache/technology/product-tables/current-prodlist.html
30  Preparando o Caché para Nossos Estudos
2.3 Instalando o Caché no Windows
Neste livro, instalaremos uma versão comercial do Caché 20010.2. Se você estiver instalando uma
versão de demonstração (que pode ser baixada do site da InterSystems gratuitamente), ou estiver instalando
uma versão anterior à versão 2010.24, as telas de instalação serão um pouco diferentes. No entanto, como
estamos explorando as opções mais comuns de instalação, acreditamos que você será capaz de lidar com as
diferenças de telas e responder de acordo.
A instalação do Caché PC (versão limitada do Caché baixada do site da InterSystems) é bem mais
simples que a instalação da versão comercial do Caché. Ela basicamente pede apenas para que você
confirme o local de instalação do software em seu disco. Portanto, não se assuste se a sua instalação
for mais simples do que o que explicamos aqui. Mas não deixe de ler este tópico, pois existem dicas
muito boas para qualquer versão de Caché como, por exemplo, qual é o login e a senha do usuário
administrador criado automaticamente durante a instalação.
Vamos instalar, para nossos estudos, um ambiente de desenvolvimento com ambas as partes client e
server do Caché em nossa máquina Windows.
Para tanto, basta executar o programa de
instalação que pode ser acionado automaticamente,
ao se inserir o CD de instalação do Caché em seu
drive de disco ou através de um duplo clique no
programa de instalação do Caché.
Se você já tiver uma versão anterior do
Caché instalada na sua máquina, a primeira coisa
que o programa de instalação fará é perguntar se
você deseja atualizar a versão que está instalada em
sua máquina ou instalar uma nova instância do
produto como pode ser observado na Figura 2-4
Recomendamos que você escolha a opção de
instalar uma nova instância.
Figura 2-4 – Tela perguntando se desejamos atualizar
Se você está instalando o Caché na sua máquina pela primeira vez, esta tela não aparecerá. Se
aparecer, recomendamos que você instale uma nova instância do Caché, em outra pasta em seu disco.
Se você estiver instalando uma versão anterior à versão 2007.2, considere contactar a InterSystems para obter uma versão
mais recente.
4
Preparando o Caché para Nossos Estudos  31
É possível ter várias instâncias de Caché instaladas na mesma máquina funcionando ao mesmo tempo.
Isto é muito útil quando estamos desenvolvendo algo que terá que funcionar bem em mais de uma versão do
Caché, por exemplo.
Aceitando os Termos do Acordo de Licenciamento
Se você está instalando o Caché pela primeira vez (ou, em caso contrário, seguiu a recomendação de
instalar uma nova instância) a tela seguinte apresenta o acordo de licenciamento comum que todo programa
comercial apresenta durante a instalação. Basta marcar que a opção indicando que você aceita os termos do
acordo e prosseguir para a próxima tela.
Definindo o nome da Instância
A próxima tela do programa de instalação perguntará qual será o nome desta instância. Se você está
instalando o Caché pela primeira vez em sua máquina, a instalação sugerirá o nome “CACHE”.
Quando temos mais de uma instância de Caché instalada, cada instância tem um nome único que a
identifica. Este nome aparecerá em vários lugares (como no Portal Administrativo) para indicar com qual instância
estamos trabalhando. Este nome também poderá ser utilizado para realizar tarefas como parar ou iniciar uma
instância pela linha de comando. Você pode manter o nome sugerido, ou alterá-lo sem problemas.
Definindo a pasta onde o Caché será instalado
A tela seguinte pede para que se confirme a pasta ou diretório onde o Caché deve ser instalado. Se
você está instalando o Caché pela primeira vez, o programa de instalação sugerirá a pasta
“C:\InterSystems\Cache”.
Caso esteja instalando uma nova instância do produto, o programa poderá sugerir a próxima pasta
disponível como “C:\InterSystems\Cache1” ou “C:\InterSystems\Cache2”. Você pode mudar o caminho de
instalação sem problemas. Mais tarde discutiremos os arquivos e pastas que são criados dentro desta pasta.
Definindo os componentes a ser instalados
A próxima tela do programa de instalação (Figura 2-5) é uma das mais importantes, pois é nela que
definimos quais componentes do Caché instalaremos e, por conseguinte que ambiente teremos.
32  Preparando o Caché para Nossos Estudos
Poderemos escolher entre as seguintes opções:
•
Development – Instala tanto a parte server (Caché Engine) quanto a parte client com uma
configuração mínima de segurança.
•
Server – Instala apenas a parte server do Caché e permite que se especifique opções avançadas
de segurança, inicialização e codificação da base de dados.
•
Client– Instala apenas a parte client do Caché de forma que esta máquina possa ser usada para se
trabalhar com um Caché Server em outra máquina. Aqui seriam instalados apenas o cubo do
Caché, o Caché Studio, o Caché Terminal e os drivers de acesso ao banco.
•
Web Server – Instala apenas os componentes necessários para que um web Server como o
Apache ou o IIS possam ser utilizados com um servidor Caché em outra máquina.
•
Custom – Permite que o usuário escolha uma combinação qualquer de componentes do Caché
que ele deseja instalar.
Figura 2-5 – Escolhendo os Componentes a serem instalados
Prosseguiremos instalando com a opção Development que instalará tanto a parte server (Caché
Engine) quanto a parte client do Caché na nossa máquina, criando assim um perfeito ambiente de
desenvolvimento para nossos estudos.
Preparando o Caché para Nossos Estudos  33
Entrando com os dados da licença
Agora estamos quase no final da configuração do programa de instalação e por isto ele nos apresenta
uma tela com o resumo de nossas escolhas como pode ser visto na Figura 2-6.
Figura 2-6 - Resumo da Instalação
Observe que, na parte de baixo desta tela, você pode escolher se deseja entrar com os dados da
licença agora ou depois. Se você já recebeu a licença da InterSystems, deixe a opção marcada. Caso contrário,
desmarque a opção e você poderá seguir instruções para instalar a licença mais tarde.
Se você deixou a opção marcada, um assistente será iniciado para colher os dados da licença. Clique
para prosseguir na primeira tela do assistente de forma que a tela da figura Figura 2-7 apareça.
34  Preparando o Caché para Nossos Estudos
Figura 2-7 – Entrando com uma licença
Esta tela permite que você entre com as informações de sua licença. Estas informações estão presentes
em um documento impresso (ou em um e-mail) enviado pela InterSystems com os dados da licença, que devem
ser digitados corretamente, respeitando-se letras maiúsculas e minúsculas.
Quando a InterSystems envia a licença, ela não só envia o documento com seus detalhes (usado para
preencher o diálogo da Figura 2-7), mas também um arquivo (via e-mail), normalmente chamado
licensekey.txt. Depois do processo de instalação, você pode renomear este arquivo para cache.key e
copiá-lo para a pasta <InstallDir>\Mgr. Para localizar esta pasta, leia o tópico 2.4 - Estrutura, Databases
e Namespaces.
Finalizando
Depois de entrar com a licença, o instalador prosseguirá com a cópia dos arquivos. Quando terminar de
copiar os arquivos, uma tela final será apresentada (Figura 2-8) e você terá a opção de ver uma página de boas
vindas com links para tutoriais, release notes, e etc.
Preparando o Caché para Nossos Estudos  35
Figura 2-8 - Instalação Terminada
Ao clicar no botão de finalização nesta tela final, observe que um cubo
aparecerá na bandeja de seu
Windows, perto da data e da hora no canto inferior direito de sua tela. É através deste cubo que você terá
acesso às diversas ferramentas do Caché. Veremos mais sobre estas ferramentas nos capítulos seguintes.
36  Preparando o Caché para Nossos Estudos
2.4 Estrutura, Databases e Namespaces
Agora que temos o Caché efetivamente instalado em nossa máquina, vamos começar a compreender
um pouco de sua organização lógica e física. Esta compreensão é essencial para todo o resto do livro, mas não
vamos explicar tudo de uma vez aqui. Explicaremos apenas o suficiente para que você compreenda a ideia geral.
Conforme já explicamos, o Caché é, ao mesmo tempo, um Banco de Dados e um Servidor de
Aplicações. Se o desenvolvedor construir uma aplicação em Java (JSP, J2EE, Swing, SWT, etc.), Visual Basic,
PHP, Delphi, .NET e etc. que necessite de uma base de dados para armazenar suas informações, o Caché
estará sendo usado a principio como base de dados para a aplicação.
Figura 2-9 - O Caché como Banco de Dados e Servidor de Aplicações
Mas se o desenvolvedor estiver construindo a sua aplicação usando apenas recursos do Caché como o
CSP (Caché Server Pages) ou o Zen, então ele estará usando o Caché não só como base de dados, mas
também como Servidor de Aplicações. Desta forma, ele não precisará de mais nada, além do próprio Caché,
para construir e executar a sua aplicação e armazenar os seus dados. Um ambiente completamente
independente e unificado.
Esta é uma separação inexata, pois mesmo trabalhando com Visual Basic .NET, por exemplo, o
desenvolvedor pode optar por colocar código no banco de dados na forma de Stored Procedures,
Métodos de Classes (se estiver desenvolvendo de forma orientada a objetos) ou Web Services (o que
caracterizaria mais o Caché como servidor de aplicação). Mas o objetivo aqui é explicar que o Caché
pode ser um ambiente independente para alguns tipos de aplicações (como aplicações Web), atuando
portanto como um servidor de aplicações Web e Banco de Dados ao mesmo tempo!
De uma forma ou de outra, se você está construindo uma aplicação usando o Caché, você estará
usando-o como banco de dados e todo banco de dados guarda informações, em última instância, em arquivos no
disco de seu computador. Portanto, é importante começar a analisar o que foi de fato criado em seu disco em
termos de pastas e arquivos para começar a entender onde ficam nossas aplicações e nossos dados.
Preparando o Caché para Nossos Estudos  37
A Figura 2-10 mostra algumas das principais pastas criadas em seu computador depois do processo de
instalação:
<InstallDir> Bin CSP httpd Mgr Figura 2-10 – Algumas das Principais Pastas criadas pelo Processo de Instalação do Caché
De acordo com as opções de instalação escolhidas, o Caché poderá estar instalado em uma pasta raiz
diferente. Portanto <InstallDir> pode ser algo como “C:\InterSystems\Cache”.
As subpastas dentro de <InstallDir>, por outro lado, terão o mesmo nome que as apresentadas na
Figura 2-10. Nem todas as pastas criadas são mostradas, apenas as mais importantes. A próxima tabela
descreve cada uma delas:
Tabela 2-1 – Pastas criadas pelo Caché no Processo de Instalação
Bin
Nesta pasta estão todos os binários (executáveis) do Caché.
CSP
Nesta pasta, existem subpastas. Cada subpasta representa uma aplicação CSP e contém
os arquivos (páginas) csp que compõem esta aplicação.
Httpd
Nesta pasta estão os binários do Servidor Web Apache que vem embutido no Caché. Este
servidor é de uso exclusivo do Caché e serve para que possamos acessar o seu portal
administrativo e outras aplicações Web do Caché.
Mgr
Nesta pasta, existem subpastas. Cada subpasta representa uma base de dados
(database) do Caché. Em cada subpasta, você encontrará apenas um arquivo chamado
CACHE.DAT que contém todos os dados do database específico.
Por exemplo, o arquivo <InstallDir>\Mgr\SAMPLES\CACHE.DAT
guarda todas as
informações do database chamado SAMPLES.
A pasta Mgr é uma das mais importantes. É abaixo dela que ficam as pastas que representam nossos
databases. Por exemplo, o arquivo <InstallDir>\Mgr\SAMPLES\CACHE.DAT mencionado acima, contém todas as
tabelas (ou classes), registros, índices e etc. do database SAMPLES. Este database vem com o Caché e traz
aplicações de exemplo criadas pela InterSystems para ajudar no aprendizado do Caché.
38  Preparando o Caché para Nossos Estudos
Como outro exemplo, o arquivo <InstallDir>\Mgr\USER\CACHE.DAT guarda todos os dados do
database USER, que também vem com o Caché, mas não traz nenhuma tabela, classe ou aplicação préconstruída como o SAMPLES. Trata-se de um database vazio, usado para testes e estudo (usaremos este
database em breve para criar nossa primeira aplicação no Capítulo 3).
2.4.1 Namespaces
O conceito de database é muito importante, mas o Caché não permite que utilizemos um database
diretamente. Existe uma estrutura lógica muito útil chamada namespace que agrupa um ou mais databases para
criar um “Espaço de Trabalho” lógico, como mostrado na Figura 2-11. Leia com atenção esta seção, pois o seu
conteúdo não é complicado, mas pode ser um pouco confuso para quem nunca trabalhou com bancos de dados
antes.
Namespace
ACME
Database
ACME
Database
CACHELIB
Database
CACHETEMP
Figura 2-11 – Os databases que compõem o namespace ACME
Na figura, podemos ver o namespace ACME como um losango. Todo namespace precisa ter um
database para armazenar seus dados. De fato, podemos especificar mais de um database para compor um
namespace para diversos fins diferentes mas, por enquanto, basta saber que pelo menos um database de dados
é necessário para que um namespace exista e, neste caso, o namespace ACME utiliza como database de dados
o Database ACME.
Enquanto que o Database ACME representa um arquivo CACHE.DAT criado por nós em alguma parte
do disco, os outros dois databases que aparecem na figura, CACHELIB e CACHETEMP são databases que
veem com o próprio Caché.
O database CACHELIB, que vem com o Caché, traz toda uma biblioteca de classes muito úteis para
qualquer aplicação básica que criamos. Portanto, todo namespace criado no Caché automaticamente mapeia,
obrigatoriamente, todas as classes do database CACHELIB.
Além disto, todo namespace usa o database CACHETEMP para armazenamento de informações
temporárias. CACHETEMP é um database muito especial. O Caché sabe que nele só estarão dados temporários
de vários namespaces assim que o Caché evita gravar estes dados em disco, mantendo-os em memória o maior
tempo possível. Nos próximos capítulos deste livro, conheceremos mais sobre o database CACHETEMP.
Preparando o Caché para Nossos Estudos  39
O nome do namespace não precisa ser igual ao nome de seu database. Na maioria das vezes o é, por
pura conveniência. Mas podemos ter dois ou mais namespaces diferentes que usam um mesmo
database, por exemplo. Existem boas razões para isto, mas que fogem a característica introdutória
deste capítulo.
Você verá em outros capítulos que o processo de criar um novo namespace é muito simples. Como todo
namespace usa, internamente, os databases CACHELIB e CACHETEMP, o assistente de criação de
namespaces nem se dá ao trabalho de mencionar qualquer coisa a respeito. Está implícito! A única coisa que
você tem que informar é o database do seu novo namespace. Mas vamos deixar isto para a hora certa.
O Importante é saber que quando trabalhamos com o Caché, trabalhamos em namespaces. Por
exemplo, no próximo capítulo, construiremos uma pequena aplicação no namespace USER que, como dissemos
acima, já vem criado com o Caché e está vazio, o que é perfeito para nossos testes!
40  Preparando o Caché para Nossos Estudos
2.5 Iniciando e Parando o Caché
Este tópico é muito importante por dois motivos: Entender como o Caché é instalado como um serviço
do Windows e que benefícios isto pode nos trazer e, para aqueles que estiverem usando Windows Vista, pode
ser que este tópico ajude a resolver alguns problemas na hora de parar ou iniciar o Caché.
O processo de instalação do Caché configura um Cubo , na
sua bandeja (canto inferior direito de sua tela, ao lado do relógio) que é
a principal interface para se interagir com o Caché. Clicando neste
cubo, você poderá ver opções para Parar o Caché, ver sua
Documentação ou abrir algumas de suas ferramentas como o Caché
Terminal ou o Caché Studio.
Se você quiser se aventurar um pouco, pode começar pela
Documentação do Caché, clicando na opção respectiva no Cubo do
Caché.
Se você resolver parar o Caché, perceberá que, depois de dar
um boot em sua máquina, o Caché poderá estar no ar sozinho
novamente. Isto ocorre porque o processo de instalação do Caché
configurou o Caché como um Serviço5 no Windows.
Figura 2-12- Opções do Cubo do Caché
Você pode averiguar isto abrindo o Painel de Controle de seu Windows, seguindo por Ferramentas
Administrativas e, por fim, clicando em Serviços
. No Windows Vista o caminho é um pouco mais longo e é
mais fácil digitar “serviços” na caixa de busca do botão iniciar. O Windows mostrará o programa de
Serviços.
Ao executar o programa, aparecerá uma lista de todos os serviços existentes na sua máquina. Se você
procurar um pouco, verá que um serviço com o nome “Caché Controller for <NomeDaInstancia>” estará na sua
lista. Como no processo de instalação (Item 2.3 deste Capítulo) recomendamos que se usasse o nome “CACHE”
como nome de instância, sua lista deve mostrar um item de serviço de nome “Caché Controller for CACHE”. Não
tem problema algum se você usou outro nome de instância.
Se você clicar duas vezes no serviço do Caché, uma janela de configuração do serviço aparecerá
(Figura 2-13). Nesta janela você poderá ver várias informações importantes do serviço como, por exemplo, na
Aba Geral (General), o nome do programa executável que ele chama quando deseja iniciar o serviço e o Tipo de
Inicialização (Startup type), que permite que você configure se deseja que o Caché seja iniciado de forma
Automática ou Manual, ou ainda desabilitar o serviço completamente. Você também poderá Parar ou Iniciar o
serviço temporariamente o que é muito útil, principalmente em instalações com Windows Vista, que em alguns
casos bloqueia a opção de Iniciar e Parar o Caché pelo Cubo do Caché. Mas por aqui sempre funciona.
Serviço do Windows – Programa que é iniciado automaticamente com o sistema operacional com privilégios específicos
para cumprir tarefas importantes sem que o usuário tenha que ativá-los manualmente.
5
Preparando o Caché para Nossos Estudos  41
Figura 2-13 - Janela de Configuração do Serviço
Existe outra configuração muito importante nesta janela, na Aba Log On, que permite que você defina
sob qual usuário do sistema operacional o serviço será inicializado e, por conseguinte, que privilégios ele terá na
máquina local e nas outras máquinas da rede. Concluindo:
•
Se você não fizer nada, o Serviço Windows do Caché permanecerá configurado para Inicialização
Automática (Automatic), subindo o Caché automaticamente toda vez que você ligar sua máquina.
Assim, você pode usar o Cubo do Caché para parar o Caché ou reiniciá-lo sempre que quiser.
•
Se você alterar o Serviço Windows do Caché para Inicialização Manual (Manual), o Caché só subirá
quando você clicar em Iniciar o Caché, no Cubo do Caché.
•
Se você alterar o Serviço Windows do Caché para Desabilitado (Disabled), o Caché não poderá
mais subir até que você reconfigure o serviço para Inicialização Automática ou Manual novamente.
Se você, acidentalmente, clicar na opção Sair do Cubo do Caché, não se preocupe. O Caché não
depende do Cubo para funcionar e vai continuar no ar. Você pode abrir o Cubo do Caché novamente
clicando no botão Iniciar de seu Windows, seguindo por Programas, Iniciar (Startup), e aqui você verá
vários programas que são inicializados automaticamente, incluindo o Cubo do Caché. Basta clicar nele
que o seu Cubo voltará!
42  Preparando o Caché para Nossos Estudos
2.6 Abrindo o Portal Administrativo do Caché
Para terminar este capítulo, vamos abrir o portal administrativo do Caché. Este portal é usado para
muitas coisas como executar consultas SQL, criar bases de dados e namespaces, executar backups, fazer
ajustes nas configurações do Caché, etc. Para abri-lo, basta clicar no cubo do Caché e escolher a opção Portal
de Administração do Sistema (ou System Management Portal em inglês).
Figura 2-14 - Portal de Administração do Sistema do Caché
É possível que ao abrir o portal de administração, um usuário e uma senha sejam solicitados. Se você
seguiu as instruções e fez uma instalação de Caché para Desenvolvedores ou instalou o Caché PC, você poderá
entrar com o usuário _SYSTEM e a senha SYS. Este é um usuário muito especial pois é criado automaticamente
pelo Caché e possui privilégios para fazer tudo no Caché, sem restrições.
Se você escolheu uma opção de instalação diferente, o processo de instalação deve haver perguntado
para você a senha do usuário _SYSTEM. Você deve usar esta senha para entrar no portal.
Por agora, isto é tudo. Sinta-se a vontade para explorar o portal de administração. Vamos usá-lo de
verdade no próximo capítulo, junto com o Caché Studio e o Caché Terminal!
Preparando o Caché para Nossos Estudos  43
3 Conhecendo o Terreno: Criando sua primeira
aplicação e se familiarizando com as
ferramentas
Toda vez que estou aprendendo algo novo, gosto de sentir que estou progredindo. É tedioso ser
obrigado a ler páginas e páginas de um livro ou manual para, só depois, conseguir produzir algo interessante e
concreto. Foi por isto que decidi fazer uma aplicação simples com o Caché logo no início. Não se preocupe se
você não conhece conceitos como classe ou objeto. Eu os explicarei resumidamente na medida em que
progredirmos. De fato, não construiremos uma aplicação inteira, mas teremos a chance de conhecer as principais
ferramentas do Caché que seriam usadas para construir uma. É por isto que recomendo a leitura deste capítulo
por todos os leitores. Neste capítulo você:
•
Aprenderá a usar o Caché Studio e suas principais funcionalidades
•
Aprenderá sobre como criar Projetos no Caché Studio e como são importantes para qualquer
metodologia de desenvolvimento de software. Trabalhar com Projetos também nos traz facilidades
para exportar nosso trabalho de forma que possamos guardá-lo ou levá-lo para outro servidor e
importá-lo novamente.
•
Verá uma introdução muito rápida sobre o que é e como criar uma classe simples no Caché usando
o Caché Studio.
•
Aprenderá a criar objetos desta classe em seu banco de dados de forma manual usando o Caché
Terminal.
•
Aprenderá a usar o Portal de Administração do Sistema do Caché para listar os objetos de sua
classe usando comandos SQL (Structured Query Language)
•
Verá como é fácil criar uma Página CSP (Caché Server Pages) e uma página Zen, usando de novo
o Caché Studio para listar os objetos de nossa classe na Web e ver a diferença que existe entre o
CSP e o Zen
•
E, por fim, verá como o Caché permite a criação de rotinas poderosas que podem compor
aplicações inteiras ou nos servir para diversas tarefas úteis no dia-a-dia de desenvolvimento e
manutenção do sistema.
Caché Server Pages: Criando Aplicações Web com o Caché  44
3.1 Conceitos e Definições necessárias para nossa Primeira
Aplicação
Para aprender sobre como usar as principais ferramentas do Caché, vamos criar uma simples Agenda
de Contatos com funções básicas de incluir, listar e excluir contatos. Toda agenda de contatos possui Contatos,
que são na verdade a razão de ser da agenda. Uma agenda sem contatos não é nada mais do que um livro
vazio. No mundo da Orientação a Objetos, um contato teria uma representação básica definida por uma classe.
Isto é: A classe define, entre outras coisas, que todo contado deve ter determinados atributos como nome,
telefone, e-mail, etc.
Se fossemos listar nossos contatos em uma folha de papel, poderíamos colocar cada contato em uma
linha da folha e em cada linha poderíamos teríamos que escrever o valor correspondente a cada um dos atributos
definidos pela classe (como nome, telefone e e-mail). No mundo da orientação a objetos, cada uma destas linhas
na folha seria chamada de um objeto ou instancia da classe contato.
Dedicaremos um capítulo inteiro para detalhar o uso de Classes e Objetos no Caché, mas, por hora,
basta saber que as classes servem para descrever entidades como Contatos, Clientes, Produtos, e tudo o mais
que precisemos usar e guardar em qualquer aplicação que quisermos construir. No nosso caso, como estamos
construindo uma agenda de contatos bem simples, só construiremos uma única classe: A Classe Contato.
Cada linha da nossa folha de papel tinha os mesmos dados: Nome, Telefone e EMail. A estes dados
chamamos de atributos ou propriedades de um contato (de um objeto da classe contato) e estas propriedades
são definidas na classe Contato de forma que cada objeto da classe contato tenha as mesmas propriedades.
Cada contato que criarmos em nossa agenda é um objeto que segue o modelo determinado por sua classe,
tendo assim todos os atributos devidamente preenchidos como pode ser visto na Figura 3-1.
Base de Dados
Classe Contato
(Modelo)
Contato
- Nome
- Telefone
- EMail
1
João da Silva
555-5676
1
[email protected]
João da Silva
1
555-5676
João da Silva
[email protected]
555-5676
[email protected]
Objetos
(Contatos)
Figura 3-1 - A classe como modelo de criação dos objetos
Preparando o Caché para Nossos Estudos  45
Conforme explicamos no Capítulo 1, o Caché é um banco de dados objeto-relacional. É por isto que
vamos falar o tempo inteiro sobre classes e objetos. Mas o Caché também é um Banco de Dados SQL6, podendo
substituir perfeitamente qualquer banco de dados no mercado. Na verdade, é muito comum, no Caché, usar
comandos SQL (Structured Query Language) como SELECT para obter uma listagem de todos os objetos de
uma classe da mesma forma que um desenvolvedor ou analista faria para obter uma listagem de todos os
registros de uma tabela.
Tabela 3-1 – Exemplo de Listagem de objetos da Classe Contato
ID
Nome
Telefone
EMail
1
João da Silva
555-5676
[email protected]
2
Maria Silvina
555-6789
[email protected]
...
...
...
...
Na Tabela 3-1, podemos ver uma listagem tabular de alguns objetos de exemplo de nossa classe
Contato. Cada objeto contato aparece como uma linha da tabela da mesma forma como apareciam em nossa
folha de papel. A propriedade ID, que aparece na listagem, identifica cada objeto de forma inequívoca. Esta
identificação será muito útil como veremos mais tarde e não é necessário especificá-la como propriedade de
nossa classe. Trata-se de uma propriedade que toda classe persistente (cujos objetos podem ser salvos em
disco) possui e está presente também na Figura 3-1.
Para criar esta estrutura, a classe, vamos aprender a usar o Caché Studio, o ambiente de
desenvolvimento do Caché. Trata-se de um tópico muito importante, que fornece dicas muito úteis para o dia-adia de qualquer desenvolvedor Caché.
Se você já conhece um pouco de bancos de dados, especificamente os Bancos de Dados SQL, você
deve estar se perguntando por que dar um novo nome para uma coisa que já existe? No mundo dos
bancos de dados relacionais, chamaríamos a tabela acima, nossa agenda de contatos, de “tabela”, e
não “classe”. Mas você verá nos próximos capítulos que uma classe pode ser muito mais que uma
simples tabela. Estamos tentando manter as coisas simples para quem está vendo estes conceitos pela
primeira vez. No Caché, estes termos são quase intercambiáveis, mas, em verdade, o conceito classe
incorpora o conceito tabela, estendendo-o para algo mais completo.
Eu poderia ter usado a expressão “Banco de Dados Relacional”, mas ela seria imprecisa. O Caché, como todos os bancos
de dados orientado a objetos e relacionais, é apenas mais uma implementação de banco de dados Relacionais, que são
baseados na teoria matemática dos conjuntos. Não podemos confundir a implementação com a teoria base. Relações entre
elementos e conjuntos de elementos existem em qualquer banco de dados SQL e Orientado a Objetos.
6
46  Preparando o Caché para Nossos Estudos
3.2 Caché Studio
3.2.1 Abrindo o Caché Studio pela Primeira vez
Neste capítulo, vamos conhecer o Caché Studio e algumas de
suas principais janelas. Para tanto, primeiramente, tenha a certeza de
que o Caché está funcionando (o cubo do Caché deve estar azul). Clique
no cubo do Caché
na bandeja de seu Windows e selecione a opção
Studio. O Studio lhe perguntará seu Usuário e Senha. Você poderá usar o
usuário _SYSTEM (não esqueça o underscore, ou “sublinha”, na frente).
Este é um usuário especial de sistema criado automaticamente pelo
processo de instalação do Caché. A senha deste usuário dependerá do
tipo de ambiente que você pediu para instalar.
Durante o processo de instalação descrito no capítulo anterior,
sugerimos instalar um ambiente de desenvolvimento (Development). Se você escolheu esta opção de instalação,
o programa de setup automaticamente define a senha “SYS” (tudo maiúsculo para o usuário _SYSTEM). Por
outro lado, caso você tenha escolhido uma instalação Server, o programa de instalação perguntará várias coisas
específicas para um ambiente Server de produção, incluindo a senha para o usuário _SYSTEM.
Figura 3-2 - Caché Studio trabalhando no namespace USER
Preparando o Caché para Nossos Estudos  47
Após ter entrado com o seu usuário e senha, você deverá ver o Caché Studio aberto no namespace
USER conforme a Figura 3-2. Você pode ver em que namespace você está no momento ao olhar a barra de título
da janela do Caché Studio. A barra de título mostra algo parecido com o seguinte:
_SYSTEM – CACHE/USER/Agenda.Contato.cls
Nome do Documento
Namespace
Nome da Instância de Caché
Nome do usuário
Figura 3-3 - Barra de Título do Caché Studio
A única coisa estranha aqui para você no momento deve ser o nome do documento, que exploraremos
logo adiante. Verifique se você está no namespace USER e, se não estiver, o tópico 3.2.2 explica como mudar de
namespaces. Outros pontos importantes a se observar no Studio estão numerados na Figura 3-2 e são melhor
explicados abaixo na Tabela 3-2.
Tabela 3-2 – Descrição de elementos Importantes do Caché Studio
1
2
Janela de Inspeção – Esta janela será muito útil quando estivermos trabalhando com nossa
nova classe e aprenderemos a usá-la em breve.
Janela de Saída – Esta janela sempre mostrará o resultado de uma operação qualquer
como compilar uma classe, fazer uma busca, e etc.
Alt + 1
Alt + 2
Espaço de Trabalho (Workspace) – Esta janela é muito importante, pois nos permite ver as
classes, rotinas e páginas CSP com as quais podemos trabalhar. Se você observar bem, ela
possui três pequenas “abinhas” em sua parte inferior que nos permite especificar o escopo
3
de nossa visão. Por exemplo, se a abinha Namespace estiver selecionada, a janela de
espaço de trabalho estará mostrando acima, todas as classes, rotinas e páginas CSP do
Alt + 3
namespace ao qual estamos conectados. Por outro lado, se a abinha Projeto estiver
selecionado, estaremos vendo apenas as classes, rotinas e páginas de nosso namespace
que pertencem ao nosso projeto atual (explicaremos o que é um projeto em breve).
Janela de Debug – Esta janela é muito importante quando estivermos depurando uma
4
classe, rotina ou página CSP e quisermos ver o resultado de cada passo do processo de
depuração. Falaremos mais sobre depuração em capítulos posteriores.
Alt + 4
Botão “Novo” – É através deste botão que iniciamos todo o processo de criação de classes,
rotinas, páginas CSP e etc. Usaremos este botão em breve. O resultado do processo de criar
5
uma nova classe, rotina ou página CSP é que este novo artefato é aberto para edição na
área descrita pelo item 7 logo abaixo.
48  Preparando o Caché para Nossos Estudos
Ctrl + N
Compilar – Este é um botão muito importante pois nada do que criarmos será útil se não for
6
compilado. É preciso compilar uma classe sempre que a modificarmos. O processo de
compilação inclui o processo de salvar o artefato que está sendo compilado.
Janela de Codificação – É aqui onde escrevemos código. Normalmente, nesta área,
7
8
estaríamos editando uma classe, rotina ou página CSP. Quando criarmos nossa primeira
classe de nosso projeto Agenda, é nesta janela que trabalharemos.
Ctrl + F7
CTRL + Tab (troca de
janela)
CTRL + F4 (fecha a
janela)
Exibir Página Web – Quando estivermos trabalhando com páginas CSP ou páginas Zen,
usaremos este botão para visualizar nossas páginas no navegador padrão do sistema.
É muito importante que você teste agora alguns dos atalhos de teclado mostrados acima, pois eles lhe
darão agilidade na codificação. É claro que você sempre pode recorrer ao seu mouse. Mas uma sequência rápida
de comandos como Alt+1, Alt+2 e Alt+3 pode liberar um bom espaço para sua janela de codificação, que se
expandirá ocupando toda a tela.
3.2.2 Verificando o Namespace (Conectando em Outro Namespace com o
Caché Studio)
Este tópico explica como fazer o
Caché Studio se conectar a outro
namespace. Se por algum motivo o seu
Studio abriu em outro namespace qualquer,
mude de volta para o namespace USER
para que possamos continuar criando nossa
aplicação no lugar certo.
Para fazer com que o seu Studio se
conecte a outro namespace, basta clicar no
menu Arquivo > Mudar Namespace, ou
pressionar F4. A janela da Figura 3-4
aparecerá.
Esta janela permite reconhecer
Figura 3-4 – Conectando a Outro Namespace
uma importante característica do Studio:
Que ele pode se conectar a qualquer namespace de qualquer instância, mesmo que esta instância esteja em
outra máquina na rede (o que é muito comum). Como pudemos constatar isto? Basta olhar, na Figura 3-4, que
um dos campos na janela refere-se ao Servidor que queremos nos conectar e abaixo, podemos ver a lista de
namespaces deste servidor específico.
Como demos o nome de CACHE à nossa instância de Caché, durante o processo de instalação descrito
no Capítulo 2, o campo Servidor mostra que estamos conectados a esta instância específica, que se localiza na
Preparando o Caché para Nossos Estudos  49
nossa própria máquina (localhost7) e está usando a porta TCP/IP 56773, que, em seu caso, pode ter um número
diferente.
Se quisermos, portanto, trabalhar em outro namespace, que esteja em outra instância que não seja a
instância CACHE, bastaria clicar no botão Conectar ao lado do campo Servidor e escolher outra instância na
nossa máquina ou em outra.
Se você clicar no botão Conectar, é provável que veja uma lista de um só item que será a própria
instância que estávamos usando (CACHE), a não ser que você tenha mais de uma instância instalada
em sua máquina ou que alguém tenha configurado instâncias remotas (que estão rodando em outras
máquinas na rede) para você. Veremos como configurar instâncias remotas nos próximos capítulos.
Para este capítulo, tenha a certeza de estar trabalhando no namespace USER, selecionando-o na lista
de namespaces e clicando no botão OK.
3.2.3 Trabalhando com Projetos (Uma questão de metodologia)
Este tópico explica como podemos organizar as coisas que criamos em projetos e trata-se de um tópico
extremamente importante.
Uma vez que você tenha verificado que está no namespace correto (USER), vamos prosseguir criando
nosso primeiro Projeto para abrigar os componentes de nossa aplicação. Aprender a trabalhar com projetos é
essencial para qualquer metodologia de desenvolvimento. Não adotaremos nenhuma metodologia em especial
neste livro, mas daremos várias dicas essenciais que permitirão que qualquer metodologia existente possa ser
usada com o Caché.
Quando você abre o Caché Studio, ele tenta abrir o último projeto em que você estava trabalhando,
assumindo que você vai simplesmente continuar seu trabalho anterior. É possível que você esteja abrindo o
Caché Studio pela primeira vez em sua máquina. Neste caso, o Caché Studio não terá projeto anterior para abrir
e, por isso, criará um novo projeto padrão de nome semelhante ao que mostramos na Figura 3-3 (veja o nome do
projeto na barra de título de seu Caché Studio).
Logo, querendo ou não, sempre estaremos trabalhando com um projeto, seja um criado
automaticamente pelo Studio com um nome qualquer, seja um criado por nós mesmos com um nome mais
adequado ao que estamos fazendo.
Para que serve um Projeto?
Um projeto serve para agrupar um conjunto de classes, rotinas, páginas CSP e outros tipos de
documentos que o Studio pode criar, sob um nome que identifique este grupo de documentos. Na parte de baixo
do Espaço de Trabalho (Workspace - Item 3 da Figura 3-2), existe uma Aba chamada Projeto, que, quando
clicada, mostra todas as classes, rotinas e páginas CSP do projeto atual, ao contrário da Aba Namespace, que
7 Localhost – Trata-se de um endereço que é sempre traduzido para o endereço TCP/IP 127.0.0.1 que chamamos de
endereço de loopback por sempre representar a nossa própria máquina.
50  Preparando o Caché para Nossos Estudos
mostra todas as classes, rotinas e páginas CSP do namespace atual inteiro. Este agrupamento e visualização
restritos são muito úteis em diversas situações muito comuns quando estamos desenvolvendo um sistema:
•
•
Uma aplicação Caché normalmente é constituída por um conjunto de classes, rotinas, páginas CSP
ou Zen. Mas e se estivermos trabalhando com mais de uma aplicação? Como poderíamos separar
as classes de uma aplicação X das classes de outra aplicação Y?
o
Uma alternativa seria criar uma aplicação em cada Namespace. Por enquanto, estamos
trabalhando no namespace USER, que vem com o Caché, mas vamos aprender a criar nossos
próprios namespaces com os nomes que quisermos. Assim, poderíamos criar um novo
namespace para cada aplicação que resolvermos criar.
o
A alternativa acima é interessante em alguns casos específicos e deve ser sempre
considerada. Mas outra alternativa é continuarmos trabalhando em um mesmo namespace e
criar um projeto diferente para cada aplicação nova que criarmos. Assim, poderíamos ter um
“Projeto X” para a nossa aplicação X e um “Projeto Y” para nossa aplicação Y, no mesmo
namespace USER. Esta alternativa é especialmente interessante se as duas aplicações
compartilham classes em comum. Por exemplo, você poderia ter uma classe com utilitários que
as duas aplicações poderiam usar. Logo, esta classe especial estaria com certeza nos dois
projetos X e Y e não estaríamos trabalhando com duas classes diferentes pois mesmo estando
em dois projetos, trata-se da mesma classe pois está em um único namespace.
Você poderia estar construindo uma grande aplicação e cada módulo de sua aplicação poderia
estar em um projeto diferente. Assim, você poderia trabalhar apenas com uma pequena porção de
sua aplicação de cada vez. Enquanto a aplicação inteira poderia ter três mil classes, rotinas e
páginas CSP, um módulo de cadastro de clientes teria apenas as classes, rotinas e páginas usadas
por este módulo e estas estariam agrupadas no projeto de cadastro de clientes.
o
•
Isto é muito útil pois, uma vez que você terminar de trabalhar com aquele módulo específico,
você poderia exportar o módulo inteiro para um arquivo XML (explicaremos isto depois), para
levar para o ambiente de homologação e testes, por exemplo.
Outra situação muito comum que pode ser resolvida com o uso de projetos é a fase de manutenção
de uma aplicação que já esteja pronta. Você pode criar um novo projeto para cada manutenção
(correção de bug, melhoria, criação de nova funcionalidade, etc.), seguindo uma codificação de
nome de sua escolha.
o
Assim, cada classe, rotina ou página CSP que você for modificando ou criando para efetivar
sua manutenção pode ser, antes, adicionada ao novo projeto, para que só então comecemos a
trabalhar com ela. Dia após dia você vai trabalhando neste projeto de manutenção, que só
mostrará as classes, rotinas e páginas que de fato são importantes para você e que você teve
que ajustar, até que a manutenção esteja terminada.
Preparando o Caché para Nossos Estudos  51
o
•
Finalizada a manutenção, você poderá exportar este projeto inteiro para importá-lo em um
ambiente de testes e homologação, por exemplo. Isto de fato ajuda a evitar aquela pergunta
que fazíamos antes: “Será que eu esqueci de trazer alguma classe?”.
Outro motivo para usar projetos igualmente importante, que exploraremos em outro capítulo, é a
integração do Caché Studio com ferramentas de Controle de Versão como o Visual Source Safe e o
CVS. Esta integração normalmente é feita através de Projetos.
Como você pode ver, existem alguns bons motivos para trabalharmos com projetos. E, como afirmamos
no início deste tópico, projetos são base para qualquer metodologia de desenvolvimento que você possa
imaginar. Portanto, vamos aprender a usá-los desde o início.
52  Preparando o Caché para Nossos Estudos
Criando um Novo Projeto
Para criar um novo Projeto, verifique se o seu Caché Studio está
conectado no namespace correto e clique na opção de menu Arquivo > Novo
Projeto. Você poderá verificar na barra de título do seu Caché Studio, o nome
de seu novo projeto. Será algo como Project1. Você também poderá verificar
que o mesmo nome aparece no seu Espaço de Trabalho conforme mostrado na
Figura 3-5. Se você não está vendo o seu Espaço de Trabalho (Workspace),
pressione Alt+3 para exibi-lo ou clique no menu Exibir > Espaço de Trabalho.
Na parte de baixo de seu Espaço de Trabalho, clique na Aba Projeto e veja, na
parte de cima, o nome de seu novo Projeto.
Para dar um nome mais adequado ao nosso novo projeto, basta clicar
no menu Arquivo > Salvar Projeto Como. Uma janela aparecerá
perguntando pelo Nome do Arquivo. Entre com o nome “Agenda” (sem as
aspas) e clique em salvar.
Figura 3-5 - Novo Projeto
Adicionando Documentos ao Projeto
Agora tudo que você criar, automaticamente é adicionado neste
projeto. Se você quiser, no entanto, adicionar algo que já existe, basta clicar
com o botão direito do mouse no item em que você deseja adicionar (Classe,
Rotinas, etc.) e clicar em Adicionar, como na Figura 3-6 ao lado. Uma janela
aparecerá perguntando que tipo de arquivo você quer e seu nome.
Outra opção para se adicionar documentos ao seu projeto é através
do menu Projeto > Adicionar Item. Se você está no namespace USER, é
provável que você não encontre nenhuma classe, rotina ou página CSP para
adicionar em seu novo projeto. Não se preocupe.
Figura 3-6 - Adicionando uma Classe
Existente ao Projeto
Não adicione nada em seu projeto Agenda. Nós vamos criar nossa primeira classe e nossa primeira
página CSP nele em breve.
Preparando o Caché para Nossos Estudos  53
Salvando o Projeto
Para salvar o seu projeto, você pode clicar no menu Arquivo > Salvar Projeto ou clicar no botão da
barra de ferramentas do Studio Salvar Tudo
. Clicar em Salvar Tudo é interessante, pois ele não só salva a
definição de seu projeto como também todas as classes, rotinas e páginas CSP abertas para edição. Se você
estiver salvando o nosso projeto Agenda, então dê o nome Agenda para o projeto.
Exportando o Projeto
Mencionei que projetos podem ser exportados para arquivos XML com muita facilidade. Para fazer
isto, clique no menu Ferramentas > Exportar. Aparecerá uma janela perguntando o que exatamente você deseja
exportar. Você pode usar os botões Adicionar e Remover para adicionar e remover manualmente classes, rotinas
ou páginas CSP na lista de documentos a serem exportados ou você pode clicar no Checkbox Exportar o
Projeto Atual para exportar não só a definição do projeto como também todos os documentos que ele contém.
Uma vez definido o que será exportado, basta definir se você deseja exportar o projeto para um arquivo
no servidor ou para um arquivo local em sua máquina. Lembre-se que o Caché é dividido em duas partes: a parte
cliente e a parte servidor. Isto quer dizer que você pode estar usando seu Caché Studio (cliente) conectado a um
Caché Server (servidor) em outra máquina na rede. É por isto que o Caché Studio lhe pergunta se você deseja
exportar seu projeto para a sua máquina (local) ou para a máquina servidora (remoto). Se o Caché Studio está
conectado a um Caché server na sua própria máquina, esta escolha não faz diferença e, portanto, o único tipo de
exportação permitido será Local.
Depois de decidir em que máquina seu arquivo vai ser gerado, basta dar um nome para ele (com
extensão XML) e clicar em Ok. Se você estiver salvando o nosso projeto de agenda, você pode dar o nome de
Projeto Agenda.xml para seu arquivo.
Importando um Projeto
Se você tem em sua máquina um arquivo
XML resultado da exportação de um projeto Caché
Studio, e deseja importar este projeto em seu
namespace atual, basta abrir o Caché Studio neste
namespace, clicar no menu Ferramentas > Importar
Local, selecionar o seu arquivo XML de projeto e
clicar em Abrir. O Studio mostrará uma lista com
todos os documentos dentro do arquivo XML. Você
pode marcar o que você deseja importar conforme
mostra a Figura 3-7.
Na Figura 3-7 ao lado, você pode ver que
estamos tentando importar o nosso próprio Projeto
Agenda salvo nos tópicos anteriores. Perceba que
a própria definição do projeto aparece na lista de
54  Preparando o Caché para Nossos Estudos
Figura 3-7 - Importando um Projeto
documentos a serem importados. Isto quer dizer que, de acordo com a figura, se você importar tudo, aparecerá
em seu namespace um projeto chamado Agenda, com uma classe chamada Agenda.Contato.
Se um projeto chamado Agenda já existe em seu namespace, ele será sobreposto por este que está
sendo importado. Tenha cuidado.
É claro que você pode desmarcar a importação da definição do projeto Agenda e importar somente a
classe Agenda.Contato, por exemplo. Outra opção muito interessante é o checkbox Adicionar os itens importados
ao projeto que permite que todos os itens importados sejam adicionados automaticamente no projeto atual aberto
no Caché Studio.
Por fim, a opção Compilar os itens importados permite que, após importado os itens, eles sejam
compilados automaticamente para estarem prontos pra uso. É quase sempre uma boa idéia deixar esta opção
ligada, mas existem situações onde você não vai querer compilar as classes importadas. Pode ser que você
esteja importando um projeto com muitas classes e a compilação poderia tomar muito tempo e tudo o que você
quer é dar uma olhada no projeto.
Abrindo um Projeto
Para abrir um projeto, basta clicar no menu Arquivo > Abrir Projeto. Um quadro de diálogo aparecerá
com uma lista de projetos de seu namespace atual. Basta selecionar o projeto desejado e clicar em Abrir.
3.2.4 Criando Nossa Primeira Classe
Para iniciar a criação de nossa primeira classe,
novamente verifique se você está com o Caché Studio
aberto e conectado ao namespace USER e que está com
um projeto apropriado para nosso projeto também aberto.
Clique no botão Novo da barra de ferramentas do Caché
Studio (use a Figura 3-2 da página 47 para localizá-lo na
sua janela). Você verá uma janela que lhe permite
escolher que tipo de novo componente você deseja criar
(Figura 3-8). Na Aba Geral, podemos ver que podemos
escolher criar uma rotina Caché Object Script8, uma
Definição de Classe Caché, e etc.
Para criar a nossa primeira classe, selecione
Definição de Classe Caché e clique no botão Ok. Isto
Figura 3-8 - Janela de Seleção de Novo Artefato
Caché Object Script – Conhecida pela sigla COS no mundo do Caché, é a principal linguagem de desenvolvimento com o
Caché. Usada para escrever rotinas, código de métodos de classes, stored procedures, e etc. Aprenderemos um pouco de
COS neste capítulo e começaremos a nos aprofundar no próximo.
8
Preparando o Caché para Nossos Estudos  55
acionará o assistente de criação de classes do Caché. No primeiro passo do assistente de criação de classes,
temos que informar qual é o pacote da classe e qual é o seu nome. Podemos também informar uma descrição de
nossa classe, de forma que isto vá fazer parte da documentação automática de classes que o Caché mantém.
Pacotes de Classes, como o nome sugere, nos ajudam a organizar as nossas classes em pacotes de
forma que, quando tivermos muitas classes, a coisa não fique muito confusa. Para a nossa aplicação de
exemplo, você pode informar o nome de pacote Agenda, para indicar que as classes que criaremos dentro deste
pacote farão parte de nossa aplicação de agenda de contatos.
É importante desde já adotar uma boa convenção de nomes de pacotes e classes. Como você já deve
ter percebido, uso a convenção de escrever cada primeira letra, de cada palavra que compõe o nome do
pacote ou nome da classe em maiúscula e o restante das letras em minúsculas como em:
AgendaEletronica ou ContatoImportante. A InterSystems adota esta convenção para nomear seus
pacotes e classes, mas esta é uma convenção bastante usada também em outras tecnologias como
.NET da Microsoft. Eu recomendo o uso desta convenção no Caché exatamente por ser a convenção
adotada pela InterSystems. Usar outra convenção fará com que suas classes estejam sempre
dissonantes das outras classes existentes. Isto não causará problemas para você, mas parecerá... feio.
O Nome da Classe é, obviamente, muito importante e deve representar muito bem a que entidade se
refere. No nosso caso, nomearemos nossa primeira classe como Contato. Desta forma, teremos uma classe,
chamada Contato, dentro do pacote Agenda. É muito comum, no entanto, nos referirmos a uma classe pelo seu
nome completo como Agenda.Contato.
Agora que você deu um bom nome para a
nossa primeira classe, você pode entrar com uma boa
descrição para ela no último campo do assistente e
clicar no botão Próximo. O próximo passo do
assistente lhe perguntará que tipo de classe você
deseja criar. Não vamos entrar em detalhes sobre os
diversos tipos de classe que o Caché suporta neste
capítulo. Basta selecionar que você deseja criar uma
classe Persistente e clicar no botão Finalizar (exato,
não precisamos ir para o próximo passo).
Figura 3-9 - Escolhendo o Tipo da Classe
Uma classe Persistente permitirá que criemos
objetos que possam ser salvos no banco de dados e
recuperados mais tarde quando quisermos. Ora, é para isto que um banco de dados serve, não? De fato, este é
um dos tipos de classe que mais criaremos com o Caché. Após ter pressionado o botão Finalizar do assistente, o
Caché Studio abrirá uma janela para que possamos continuar trabalhando no código fonte de nossa nova classe
como pode ser visto na Figura 3-10.
56  Preparando o Caché para Nossos Estudos
No código fonte mostrado na figura, podemos ver que a nossa classe Agenda.Contato é declarada com
a diretiva Class e herda (Extends) da classe %Persistent9. É esta herança que transmite a nossa classe as
habilidades necessárias para que consigamos salvar objetos dela no banco de dados e recuperá-los mais tarde.
Como nossa classe agora possui tais habilidades, dizemos que ela é uma Classe Persistente.
Figura 3-10 - Nossa primeira Classe
Adicionando Propriedades na Classe Contato
Vamos prosseguir com a criação de nossa classe adicionando a ela as propriedades que todo contato
deve ter. Para criar uma propriedade, basta seguir os seguintes passos:
1. Clique com o botão direito de seu mouse em qualquer parte da área
de codificação para fazer aparecer um menu de contexto10. Selecione
a opção Adicionar > Nova Propriedade
.
2. Ao aparecer o Assistente de Criação de Propriedades, informe o
nome da nova propriedade (Telefone, por exemplo) e uma descrição
(opcional).
3. Clique em Finalizar.
Figura 3-11 - Propriedades
da Classe Contato
Execute os três passos acima para cada uma das propriedades da classe contato como pode ser
observado na Figura 3-11.
%Persistent – Falaremos mais das classes que vem com o Caché nos próximos capítulos. O sinal de percentual na frente
do nome da classe significa que a classe é uma classe de sistema, que vem com o Caché e, na verdade, é um atalho para o
pacote %Library de classes de sistema.
10 Menu de Contexto – No ambiente Windows, é comum usarmos o botão direito do mouse para acionar um menu de
contexto que nos permite executar diversas atividades relativas ao contexto em que clicamos. Neste caso, como o contexto
é o código fonte da classe, o menu de contexto mostrará várias atividades relativas a edição e construção de classes.
9
Preparando o Caché para Nossos Estudos  57
O código fonte de sua classe agora deve estar parecido com isto:
/// Contato da Agenda.
Class Agenda.Contato Extends %Persistent
{
Property Nome As %String;
Property Telefone As %String;
Property EMail As %String;
}
Observe que usamos a mesma regra de nomenclatura de nomes de pacotes e de classes para nomes
de propriedades. Eu recomendo fortemente que você siga esta convenção. Você verá que ao trabalhar
com páginas Zen, Java ou .NET junto com o Caché, esta convenção também lhe será bastante útil.
Todas as propriedades são declaradas com a diretiva Property. Como clicamos em Finalizar logo no
início do Assistente de Criação de Classes, para cada propriedade criada, todas foram definidas como Strings11
(As %String). Poderíamos ter usado outros tipos de dados, como inteiros (%Integer), mas vamos deixar a
discussão de tipos de dados do Caché para os próximos capítulos.
Salvando Tudo
Antes de prosseguirmos, é importante parar para salvar nosso trabalho. Para tanto, você pode clicar o
botão Salvar Tudo
na sua barra de ferramentas ou clicar no menu Arquivo > Salvar Todos. Isto não só
salvará tudo que estamos editando (neste caso, apenas a nossa classe Agenda.Contato) como também
perguntará se não queremos salvar também o nosso projeto (já que acabamos de adicionar uma nova classe
nele). É importante cultivar o hábito de salvar o seu trabalho de tempos em tempos.
Compilando a Classe
Chegou a hora de compilar a nossa nova classe. Quando compilamos uma classe, o Caché define todas
as estruturas necessárias para armazenar os dados de nossos futuros objetos. Além disto, o Caché também gera
todo o código necessário para que estes dados possam ser acessados não só via objetos, mas também via SQL
(modelo relacional).
Para compilar a nossa nova classe, basta clicar no botão Compilar
de sua barra de ferramentas ou
clicar no menu Compilar > Compilar. Também é possível usar o atalho de teclado CTRL+F7. Atalhos de teclado
podem agilizar bastante tarefas rotineiras como esta. Veja novamente a Tabela 3-2 na página 48 que mostra uma
lista de atalhos de teclado muito úteis que você pode testar agora.
11
String – Uma string é uma seqüência de caracteres que podem ser letras, números, caracteres de pontuação e etc..
58  Preparando o Caché para Nossos Estudos
Observe que todos os passos da compilação são exibidos na Janela de Saída do Caché Studio como as
linhas abaixo:
Compilation started on 08/16/2007 23:14:50 with qualifiers 'cuk'
Compiling class Agenda.Contato
Compiling table Agenda.Contato
Compiling routine Agenda.Contato.1
Compilation finished successfully in 0.468s.
Qualquer mensagem de erro de compilação aparece na Janela de Saída e você deve prestar atenção
aos resultados que ela mostra. Se tudo estiver bem, você pode usar o atalho de teclado (Alt+2) para esconder de
novo a Janela de Saída e continuar trabalhando com mais espaço na tela.
3.2.5 Usando a Janela de Inspeção
Vamos alterar um pouco a nossa classe Agenda.Contato e configurar melhor a nossa propriedade
Nome, para aceitar um máximo de 100 caracteres. Se não informarmos nada, o tipo de dados %Library.String
(%String) determina 50 como máximo.
Para tanto, abra a sua classe Agenda.Contato e a Janela de
Inspeção (Alt+1). Clique na lista de contexto da Janela de Inspeção e
selecione Property conforme mostra a Figura 3-12 ao lado.
A janela de inspeção mostrará as propriedades da classe
Agenda.Contato. Dê um duplo clique na propriedade Nome. A janela
de inspeção mostrará os parâmetros da propriedade Nome. Procure
pelo parâmetro MAXLEN e mude-o de 50 para 100.
Depois de mudar o valor, clique com o mouse de novo na
Área de Codificação. Você verá que o código fonte de sua classe será
atualizado para refletir a mudança como mostrado abaixo:
Figura 3-12 - Janela de Inspeção
/// Contato da Agenda.
Class Agenda.Contato Extends %Persistent
{
Property Nome As %String(MAXLEN = 100);
Property Telefone As %String;
Property EMail As %String;
}
Agora, nossos contatos poderão ter nomes de até 100 caracteres. Aprender a usar a Janela de
Inspeção é uma ótima maneira de codificar sem escrever código. Depois de usar os Assistentes para inserir as
Preparando o Caché para Nossos Estudos  59
propriedades, basta explorar a Janela de Inspeção para fazer as mudanças que quisermos sem escrever uma
linha de código a mão!
Não se esqueça de compilar a sua classe novamente (CTRL+F7). Acostume-se com esta rotina!
3.3 Criando nossos Primeiros Objetos
Agora que temos a nossa classe Agenda.Contato pronta e compilada, poderemos criar objetos a partir
dela: Nossos Contatos.
Para tanto, vamos aprender a usar outra ferramenta muito importante do Caché, o Caché Terminal. O
Caché Terminal nos permite chegar à interface de linha de comandos (shell ou terminal do Caché).
O Caché Terminal é uma espécie de cliente de Telnet para o Caché12. Mas o Caché também permite
que você use seu client de Telnet preferido para chegar à sua linha de comandos, mas não vamos nos
aprofundar neste assunto agora.
Esta interface via linha de comandos é muito comum em muitos bancos de dados e com o Caché não é
diferente. Ela nos permite emitir comandos que são executados imediatamente pelo banco de dados como, por
exemplo, criar um objeto. Estes comandos normalmente fazem parte de uma linguagem de script suportada pelo
banco de dados que, no caso do Caché, se chama Caché Object Script ou COS, para abreviar.
Veremos bastante do COS no próximo capítulo. Por enquanto, vamos aprender aqui alguns comandos
básicos da linguagem COS que poderão ser usados não somente na linha de comandos do Caché, mas também
para construir rotinas, escrever métodos de classes, stored procedures, páginas CSP e Zen e etc.
3.3.1 Abrindo o Caché Terminal
Para abrir o Caché Terminal, basta clicar no Cubo do Caché > Terminal. A janela da Figura 3-13
aparecerá, perguntando por seu usuário e sua senha. Você pode informar o usuário _system de sistema e a
senha que você escolheu para ele durante o processo de instalação do Caché.
Uma vez que você tenha entrado com um usuário e
senha válidos, o Caché lhe mostrará a sua linha de
comandos (shell) que sempre exibe o nome do namespace
atual seguindo de um sinal de “maior que” (“USER>”) e
estará pronto para os seus comandos. O usuário _system
está configurado para sempre cair no namespace USER
quando se abre o Caché Terminal. É por isto que caímos
diretamente nele e não em outros namespaces como o
SAMPLES.
Figura 3-13 - Janela do Caché Terminal
12 Cliente de Telnet – Telnet é um protocolo padrão de comunicação muito usado para permitir que uma pessoa se conecte
a uma máquina remota na rede e tenha acesso à interface de linha de comandos (shell) do sistema operacional da máquina.
60  Preparando o Caché para Nossos Estudos
Trocando de Namespace
Se, por um acaso, você abriu o Caché Terminal e percebeu que está em outro namespace diferente do
USER, use o comando ZN “Namespace” para trocar para o namespace USER como no exemplo abaixo:
SAMPLES>ZN “USER”
USER>
Um Pouco de Caché Object Script
Agora que estamos em nosso namespace correto podemos aprender alguns comandos básicos de
Caché Object Script que serão muito úteis como o comando Write:
USER>Write “Olá!”
Olá!
USER>
O comando Write simplesmente escreve na tela o que passarmos como parâmetro para ele. Outro
comando muito importante é o comando Set:
USER>Set var = “Olá de Novo!”
USER>Write var
Olá de Novo!
USER>
O comando Set serve para atribuir o resultado de uma expressão a uma variável qualquer que é criada
automaticamente. Neste caso, usamos uma string, mas poderíamos fazer alguns cálculos como:
USER>Set a = 10
USER>Set b = a + 5
USER>Write b
15
USER>
Observe que não é preciso declarar as variáveis com um tipo específico para usá-las. Basta usar o
comando Set para atribuir o valor que queremos à variável, seja um número ou uma string. Isto é uma
característica de linguagens de script como o Caché Object Script, ao contrário de linguagens com “tipagem
forte”, que exigem que se especifique o tipo de dados da variável antes de criá-la e usá-la. Cada tipo de
linguagem tem suas vantagens e desvantagens que fogem ao escopo deste livro. Você vai perceber, ao longo
deste livro, que a linguagem Caché Object Script é muito poderosa e versátil.
O Caché Terminal mantém uma lista com os últimos comandos que você entrou. Você pode usar as
setinhas para cima ou para baixo de seu teclado para navegar na lista de comandos anteriores e
escolher qualquer um deles.
Preparando o Caché para Nossos Estudos  61
Agora que aprendemos como criar variáveis, com o comando Set, e imprimir seu conteúdo na tela, com
o comando Write, vamos aprender como apagamos as variáveis que criamos para liberar a memória ocupada por
elas com o comando Kill.
No exemplo abaixo, criamos uma variável atribuindo a ela o valor 1. Imprimimos o seu conteúdo e
vemos que ela de fato foi criada e que está com o valor que colocamos lá. Finalmente, usamos o comando Kill
para apagar a variável e, para verificar que ela foi apagada, usamos novamente o comando Write para tentar
imprimir seu conteúdo. Veja o que ocorre:
USER>Set a = 1
USER>Write a
1
USER>Kill a
USER>Write a
WRITE a
^
<UNDEFINED> *a
USER>
Perceba que após o último comando Write, o Caché retornou um erro <UNDEFINED> *a que significa
que “A variável a não foi Definida” ou que “a está Indefinida”.
Se você entrar com o comando Kill, sem parâmetros, e der ENTER, todas as variáveis de seu processo
(partição) serão apagadas. Também o comando Write pode ser usado sem parâmetros e imprimirá
todas as variáveis de sua partição.
Toda vez que abrimos uma conexão, de uma máquina A (cliente), ao Caché de uma máquina B
(Servidor), o Caché na máquina B cria um processo para nos atender. Dentro deste processo, existe
uma área de memória local para as variáveis locais e outros dados criados durante o trabalho do
processo. Chamamos esta área de partição. Usamos o termo partição e processo de forma
intercambiável.
Com estes três comandos - Write, Set e Kill -, já estamos prontos para criar nosso primeiro objeto,
preenche-lo e salvá-lo!
62  Preparando o Caché para Nossos Estudos
Criando Alguns Objetos Caché
Quando estávamos criando nossa classe Agenda.Contato, vimos que ela herdava todas as habilidades
necessárias para salvar seus objetos em disco a partir de uma classe de sistema do Caché chamada
%Persistent. Estas habilidades, na verdade, se apresentam na forma de Métodos especiais que nos permitem
criar um novo objeto, salvá-lo, apagá-lo e etc.
Um Método nada mais é do que uma função ou subrotina de uma classe, que executa uma série de
operações codificadas em Caché Object Script. Estes métodos podem ser criados na própria classe ou herdados
a partir de outras classes. A nossa classe Agenda.Contato herda da classe %Persistent muitos métodos
importantes, alguns dos quais estão listados na Tabela 3-3.
Tabela 3-3 – Alguns Métodos Importantes da Classe %Persistent
Método
%New()
%Save()
Descrição
Retorno
Tipo
Permite criar um novo objeto da classe.
O novo Objeto Criado
Método de Classe
Permite salvar um objeto.
1 se foi salvo ou %Status se
houve um erro.
Método de Instância
Permite abrir um objeto através de seu ID.
Se um objeto existe com o ID
passado, o objeto aberto. Caso
contrário, o valor nulo (“”)
Método de Classe
Permite excluir um objeto através de seu
ID.
1 se foi excluído ou %Status se
houve um erro.
Método de Classe.
Retorna o ID de um objeto
Se o objeto já tem um ID, então
retorna o ID. Caso contrário,
retorna o valor nulo (“”)
Método de Instância
%OpenId(id)
%DeleteId(id)
%Id()
Para exemplificar o uso destes métodos, vamos começar criando um novo objeto da classe contato.
Abra o seu Caché Terminal, certifique-se de estar no namespace USER, onde criamos a nossa classe com o
Caché Studio no tópico 3.2.4 deste capítulo, e entre com os seguintes comandos:
1.
USER>Set contato = ##class(Agenda.Contato).%New()
2.
USER>Set contato.Nome = “João da Silva”
3.
USER>Set contato.Telefone = “555-5676”
4.
USER>Set contato.EMail = “[email protected]”
A primeira instrução Caché Object Script acima usa o comando Set, discutido anteriormente, para criar
uma variável chamada contato e atribuir a ela o resultado da expressão depois do sinal de igual, que, neste caso,
será um (novo) objeto da classe Agenda.Contato.
A expressão depois do sinal de igual usa o operador ##class(Nome da Classe), que nos posiciona
dentro do contexto da classe cujo nome foi passado entre parêntesis. Assim, estando no contexto da classe
Preparando o Caché para Nossos Estudos  63
Agenda.Contato, podemos agora usar o operador ponto (“.”) para acionar qualquer método de classe desta
classe. Neste caso, estamos chamando o método %New() que, como pode ser visto na Tabela 3-3, é, de fato, um
método de classe que nos retorna um novo objeto da classe.
O ato de criar um novo objeto de uma classe também é chamado instanciar um objeto, pois
normalmente nos referimos a um objeto de uma classe como uma instância da classe. Lembre-se
destes termos, já que são muito comuns no mundo da orientação a objetos.
Um método de classe é um método que pode ser invocado diretamente a partir da classe. Esta
definição parece ridícula, mas existe outro tipo de método, chamado “método de instância” que só pode ser
invocado a partir de um objeto (uma instância da classe) e é muito importante que você saiba a diferença entre
uma coisa e outra. Vamos voltar a este tema mais adiante.
As outras instruções, das linhas dois, três e quatro usam novamente o operador ponto (“.”), mas agora
no contexto do objeto contato criado anteriormente, para referenciar suas propriedades e preenche-las com
valores string adequados.
Ou seja, o operador ponto (“.”) sempre servirá para referenciar métodos de classe ou propriedades e
métodos de objetos. Enquanto que na primeira linha de código, o contexto era o operador ##class(), uma classe,
nas linhas seguintes o contexto passou a ser a variável contato, um objeto.
É muito importante perceber que, diferente do comando Set da primeira linha, não estamos agora
criando novas variáveis (ex: “contato.Nome”), mas sim preenchendo propriedades de uma única variável
chamada contato, que só aceita o uso do operador ponto (“.”) porque é, de fato, um objeto, que possui
propriedades a serem lidas ou preenchidas.
Seguindo com nosso exercício, precisamos salvar nosso objeto, pois, no momento, tudo que criamos
está em memória (na nossa partição ou processo) e se fechamos o Caché Terminal neste instante, tudo será
perdido. Mas antes de salvar nosso objeto contato, vamos pedir para ver algumas informações a respeito do que
preenchemos para ver se está tudo certo:
5.
USER>Write contato.Nome
6.
João da Silva
7.
USER>Write contato.%Id()
8.
9.
USER>Set status = contato.%Save()
10. USER>Write status
11. 1
12. USER>Write contato.%Id()
13. 1
64  Preparando o Caché para Nossos Estudos
Na linha cinco, usamos o comando Write para imprimir na tela do terminal o conteúdo da propriedade
Nome do objeto contato (usamos novamente o operador ponto). Verificamos que o nome do contato está correto
e, em seguida, pedimos para imprimir na tela o resultado da chamada ao método %Id() do objeto contato, que
retorna nulo pois acabamos de criar o objeto e ainda não o salvamos em disco.
Vale ressaltar que, usamos novamente o operador ponto para invocar o método %Id(), que, como pode
ser visto na Tabela 3-3 é um método de instância.
Um método de instância só pode ser invocado a partir de uma variável de objeto (uma instância).
Normalmente não faz sentido (e não funciona) invocar métodos de instância com o operador ##class(). Por
exemplo, o método %Id() é um método de instância que retorna o ID do objeto em questão. Ou seja: Se não há
objeto, o método perde seu sentido. Na verdade, o Caché simplesmente retorna, dizendo que aquele método não
existe. É uma forma que a orientação a objetos tem de garantir que determinados métodos só possam ser
chamados dentro do contexto certo:
USER>Write ##class(Agenda.Contato).%Id()
WRITE ##CLASS(Agenda.Contato).%Id()
^
<METHOD DOES NOT EXIST> *%Id,Agenda.Contato
USER>
Mas voltando ao nosso exemplo, na linha nove, usamos o comando Set para criar uma nova variável
chamada status, atribuindo a ela o resultado da chamada ao método de instância %Save() do objeto contato.
Como pode ser visto na Tabela 3-3, o método %Save() tentar salvar o objeto contato em disco e retorna o
resultado de sua tentativa. A linha dez imprime o conteúdo da variável status, que, se for igual a “1”, significa que
o objeto foi de fato salvo com sucesso.
Toda vez que um objeto é salvo, o Caché lhe atribui um novo ID único para sua classe, que poderá ser
usado para identificar este objeto de forma inequívoca mais tarde. Um ID nada mais é do que um número inteiro.
Neste caso, como acabamos de criar nosso primeiro objeto de nossa primeira classe, o ID aparece, na linha
treze, como “1” (como trata-se do primeiro objeto que criamos para a classe, o ID assume o valor 1).
Como exercício, tente criar mais um ou dois objetos, salvá-los, e exibir seus IDs como fizemos. Tente
anotar em algum lugar o ID que cada objeto ganhou, associando-o ao Nome ou ao EMail do contato. Assim, os
próximos tópicos ficarão mais interessantes. Lembre-se sempre de usar o método %New() para criar o novo
objeto.
Abrindo Objetos
Agora que você já criou e salvou alguns objetos no Caché, vamos aprender como recuperá-los do disco.
Para começar, entre com o comando Kill, sem parâmetros, para apagar todas as variáveis da memória. Ou
então, simplesmente feche esta sessão do Caché Terminal e abra outra.
Preparando o Caché para Nossos Estudos  65
Agora, vamos usar o método de classe %OpenId() que, conforme vimos na Tabela 3-3, nos permite abrir
um de nossos objetos salvos anteriormente:
1.
USER>Kill
2.
USER>Set obj = ##class(Agenda.Contato).%OpenId(1)
3.
USER>Write obj.EMail
4.
[email protected]
Observe que novamente usamos o comando Set, na segunda linha, para atribuir o resultado da
expressão do lado direito do operador de igualdade à variável obj no lado esquerdo. Usamos o nome de variável
“obj”, ao invés de “contato”, desta vez, para que você veja que o nome da variável pouco importa: Escolha um
nome de variável e siga com ele. Na expressão do lado direito, usamos novamente o operador ##class() para
indicar que queremos trabalhar com a classe Agenda.Contato, seguido do operador ponto (“.”) para podermos
invocar o método %OpenId() que recebe como parâmetro um ID de um objeto previamente salvo.
No exemplo acima, ainda na segunda linha, passamos o ID 1 como parâmetro para o método
%OpenId(), pois sabemos que existe um objeto com este ID salvo em disco resultado de nossos exercícios do
tópico anterior. O método %OpenId() retorna então o objeto aberto e o comando Set termina atribuindo à variável
obj o objeto retornado. Observe, na linha três e quatro, que, de fato, conseguimos imprimir o conteúdo da
propriedade EMail.
Nos próximos capítulos aprenderemos como podemos encontrar um objeto por outros atributos, como
EMail ou Telefone, além do ID.
Se você passar um ID inexistente para o método %OpenId(), o método retornará uma referencia nula.
Assim, sua variável obj conterá uma referencia inválida de objeto como pode ser observado abaixo:
1.
USER>Set obj = ##class(Agenda.Contato).%OpenId(999)
2.
USER>Write obj
3.
4.
USER>Write obj.EMail
5.
6.
WRITE obj.EMail
7.
^
8.
<INVALID OREF>
9.
USER>
No exemplo anterior, tentamos abrir um objeto com um ID que não existe (999). Na linha dois, pedimos
para imprimir o conteúdo da variável obj e vimos, na linha três, que não havia nada nela, como esperado. Mas
mesmo assim prosseguimos e pedimos para imprimir a propriedade EMail do objeto na linha quatro. O Caché
percebe que a variável obj não contém uma referência válida de objeto e determina que cometemos um erro. Ele
reimprime na linha seis o código Caché Object Script que provocou o erro, marcando o comando culpado
66  Preparando o Caché para Nossos Estudos
(circunflexo abaixo do comando Write na linha sete) e descrevendo o problema na linha oito como <INVALID
OREF>13.
Voltando ao nosso exercício, uma vez que você tenha aberto com sucesso um objeto, você pode usar o
comando Set novamente para alterar algumas de suas propriedades e voltar a salvá-lo se quiser.
USER>Set obj2 = ##class(Agenda.Contato).%OpenId(1)
USER>Set obj2.EMail=”[email protected]”
USER>Set status = obj2.%Save()
USER>Write status
1
USER>Write obj2.%Id()
1
No exemplo acima, após salvarmos o objeto com sua propriedade EMail alterada, pedimos, por
curiosidade, para ver de novo o valor do ID dele, chamando novamente o método de instância %Id(). Observe
que o ID não muda.
Uma vez que um objeto tenha ganhado um ID, ele permanece o mesmo durante toda a sua vida. Além
disto, quando apagamos um objeto, o ID que ele usava nunca mais será usado por nenhum outro objeto
da mesma classe.
Como exercício, tente abrir os outros objetos que você criou, passando para o método %OpenId() outros
IDs de objetos que você tenha salvo no tópico anterior. Tente alterar o conteúdo de outras propriedades de seus
objetos e salvá-los.
Excluindo Objetos
Finalmente, vamos aprender agora como podemos excluir alguns dos objetos que criamos. Para tanto,
vamos usar o método de classe %DeleteId() que, conforme vimos na Tabela 3-3, espera o ID do objeto a ser
apagado como parâmetro. Seu funcionamento é muito parecido com o do método %OpenId(), mas ao invés de
abrir e retornar um objeto que tenha determinado ID, o método %DeleteId() tenta apagá-lo e retorna 1 se
conseguiu ou um erro em caso contrário:
USER>Set apagou = ##class(Agenda.Contato).%DeleteId(2)
USER>Write apagou
1
USER>
OREF – Veremos com mais detalhes todos os aspectos de orientação a objetos do Caché, mas OREF é a abreviação
para “Object REFerence” ou referencia para um objeto.
13
Preparando o Caché para Nossos Estudos  67
No exemplo acima, você pode ver que usamos o comando Set para atribuir à variável apagou o
resultado da expressão do lado direito do sinal de igualdade. Neste caso, a expressão novamente usa o operador
##class() para indicar que queremos trabalhar com a classe Agenda.Contato, e, com o operador ponto (“.”)
invocamos o método %DeleteId() de nossa classe, passando-lhe como parâmetro o número do ID que queremos
excluir. Neste caso, passamos o ID de número 2. O método %DeleteId() então retorna o resultado da tentativa de
exclusão, o qual o comando Set atribui à variável apagou. Na linha seguinte, usamos o comando Write para ver
que a variável apagou de fato contem o valor 1, indicando que o resultado da tentativa de exclusão do objeto foi
um sucesso.
Como exercícios, tente:
•
Criar novos objetos e limpar a partição com o comando Kill
•
Recuperar um destes objetos, alterar algumas de suas propriedades, salvá-lo e limpar a partição
novamente com o comando Kill.
•
Excluir um outro objeto e tentar abri-lo novamente para verificar que o método %OpenId() retornará
uma referência nula já que o objeto não existirá mais.
68  Preparando o Caché para Nossos Estudos
3.4 Conhecendo o Portal de Administração
Até agora, usamos duas ferramentas do Caché: O Caché Studio, para criar nossa primeira classe e o
Caché Terminal, para aprender um pouco de Caché Object Script e criar alguns objetos de nossa classe. Neste
tópico vamos conhecer algumas das funcionalidades de mais uma ferramenta do Caché: O Portal de
Administração de Sistema.
Vamos usar o Portal de Administração do Caché para dar uma olhada nos objetos de nossa classe
Agenda.Contato sob outra perspectiva. Vamos ver como o Caché expôs a nossa classe como uma tabela para o
mundo SQL e vamos trabalhar com alguns comandos SQL (Structured Query Language) para obter uma listagem
dos objetos de nossa classe, inserir alguns novos e alterar contatos existentes.
3.4.1 Abrindo o Portal de Administração do Caché
Para abrir o Portal de Administração, clique no Cubo do Caché > Portal de Administração do Sistema. O
Cubo do Caché abrirá um Navegador Internet que mostrará uma página pedindo um usuário e senha. Você pode
entrar com o usuário _system e a senha que você deu para este usuário quando instalou o Caché (ou a senha
padrão “SYS” – sem as aspas).
Se você está usando o Caché PC (a versão de Caché demo baixada do site da InterSystems que não
precisa de licença para funcionar) você não terá que entrar com senha alguma e o portal simplesmente
se abrirá na Home Page abaixo.
Figura 3-14 - Portal de Administração do Sistema do Caché
Ao entrar com a senha correta, o Caché mostrará a página da Figura 3-14. O Portal de Administração do
Sistema do Caché separa suas funcionalidades em três papéis ou perfis muito bem definidos. Como você entrou
com o usuário _system, que é um super usuário, você terá acesso a todas as funcionalidades de todos os três
Preparando o Caché para Nossos Estudos  69
perfis. Veremos em outros capítulos como criar novos usuários e definir seus perfis de forma que determinadas
pessoas só tenham acesso a determinadas funcionalidades do Caché de acordo com a sua função dentro da
empresa.
Os três papéis ou perfis que o Portal de Administração do Sistema do Caché mostra na sua página
principal são fixos e não podem ser mudados. No entanto, aprenderemos nos próximos capítulos a criar
novos papéis para uso em nossas próprias aplicações.
Podemos ver na Figura 3-13, os três perfis principais do Portal de Administração do Sistema do Caché:
•
Administração do Sistema – Que permite configurar todos os parâmetros de funcionamento do
Caché, criar bases de dados, namespaces, usuários, definir parâmetros de backup, segurança,
espelhamento, distribuição de bases de dados e etc. Este perfil, essencialmente só faz uma coisa:
Configura o sistema.
•
Administração dos Dados – Que permite consultar, manipular e exportar todo tipo de objeto
Caché (classes, tabelas, rotinas e globais). Este seria o perfil de quem se preocupa com os dados
armazenados.
•
Operações – Que permite executar todo tipo de tarefa de manutenção e monitoração do Caché. A
este perfil pertencem as pessoas responsáveis pelas tarefas rotineiras: Executar os backups
previamente configurados pelo administrador, executar e verificar as tarefas rotineiras de sistemas,
monitorar a tabela de locks, etc.
Neste capítulo usaremos principalmente o papel de Administração de Dados, do meio da página Figura
3-13.
3.4.2 A Documentação de Nossa Classe
Neste tópico aprenderemos como encontrar e modificar a documentação gerada dinamicamente para
nossa classe Agenda.Contato. Esta documentação pode ser acessada via Web através do Portal de
Administração do Sistema e pode ser usada por desenvolvedores que estejam usando nossa classe e querem
saber exatamente como ela funciona, que propriedades possui, e etc. Trata-se de um recurso muito útil e
importante.
Uma vez que você tenha entrado no Portal de Administração do Sistema do Caché, clique em
Administração de Dados > Classes. Você verá uma tela com a listagem de todas as classes do namespace
%SYS.
Aprenderemos mais sobre o Namespace %SYS nos próximos capítulos. Trata-se de um namespace
especial de administração do Caché. Conseguimos ver seu conteúdo aqui, pois entramos no portal com
o super usuário _system.
70  Preparando o Caché para Nossos Estudos
No lado esquerdo da tela, você verá uma lista de namespaces. Clique no namespace USER para ver a
lista de classes do namespace USER que aparecerá conforme a Figura 3-15.
2 Barra de Navegação
1 Lista de seleção de Namespaces
4 Menu de Contexto
5 Barra de Filtros
3 Lista de classes do Namespace
selecionado com link para
documentação.
Figura 3-15 - Lista de Classes do Namespace User
Agora estamos no contexto do namespace USER. É claro que se você criou outras classes no
namespace USER além da classe Agenda.Contato, estas também aparecerão na listagem. A Tabela 3-4
descreve cada um dos componentes de tela apontados pela Figura 3-15.
Tabela 3-4 – Descrição dos Principais componentes de [Home] > [Classes] do Portal de Administração do Caché
1
Lista de Seleção de Namespaces – Esta seção da tela mostra uma lista com todos os namespaces do Caché.
Tenha sempre o cuidado de observar em qual namespace você está trabalhando. No nosso caso, o namespace
USER.
2
Barra de Navegação – Permite que você possa ver o caminho que você fez para chegar na tela atual. Na figura,
seguimos o caminho [Home] > [Classes]. A qualquer momento, você pode clicar em [Home], por exemplo, para voltar
para a página principal do Portal.
3
Lista de Classes do Namespace Selecionado – Esta seção da tela mostra a lista de classes do namespace
selecionado. A lista ainda pode ser filtrada, caso existam muitas classes no namespace, para que se encontre mais
facilmente a classe com que se deseja trabalhar.
4
Menu de Contexto – Apresenta ferramentas importantes para o contexto atual. Como estamos lidando com classes,
veremos opções para Importar, Exportar e Excluir classes. Estas ferramentas são muito úteis, por exemplo, em um
ambiente de produção onde o uso do Caché Studio não é permitido. Importaríamos classes novas para o ambiente de
produção através do portal Web, que poderia estar sendo usado de uma máquina remota fora do datacenter onde o
servidor do Caché está instalado.
5
Barra de Filtros – Permite impor um filtro a lista para que possamos encontrar as classes que queremos com mais
facilidade. Você pode entrar com máscaras como: Agenda.*, *Contato* ou ?genda* no campo Classes, e clicar em
Exibir para filtrar. O campo Filtro, por outro lado, faz a filtragem em tempo real, sem ir no servidor, trabalhando apenas
com as classes que já estão na tela.
Preparando o Caché para Nossos Estudos  71
Agora que você conhece bem esta seção do Portal de Administração do Caché, encontre a sua classe e
clique no link Documentação relativo à nossa classe Agenda.Contato. Você verá uma página parecida com a da
Figura 3-16. Ela variará um pouco de acordo com a quantidade de documentação que você tenha colocado na
sua classe durante sua criação.
Link para Pesquisar a Documentação de Classes
Figura 3-16 - Documentação da Classe Contato
Para fazer um teste, abra a sua classe Agenda.Contato usando o Caché Studio e modifique a sua
propriedade Nome para ficar assim:
/// Contato da Agenda.
Class Agenda.Contato Extends %Persistent
{
///Nome completo do Contato
Property Nome As %String;
///Telefone do contato. <font color="red">Com DDD!</font>
Property Telefone As %String;
///Email do contato.
Property EMail As %String;
}
Compile a sua classe (CTRL+F7) e volte a abrir a documentação da classe (atualizando a janela do
navegador que mostrava a documentação antes, por exemplo). Ou aproveite que você está no Caché Studio e
aprenda outra forma de se pedir a documentação da classe: Ainda com sua classe Agenda.Contato aberta no
Caché Studio, clique no menu Exibir > Exibir Documentação da Classe.
72  Preparando o Caché para Nossos Estudos
Observe que usamos três barras (“///”) acima do item que desejamos documentar. Por exemplo, acima
da instrução Class e acima da instrução Property. São instruções de comentário especiais para documentação.
Além disto, você também pode
verificar que podemos usar comandos HTML14
na documentação da classe de forma que a
documentação on-line possa se tornar ainda
mais interessante conforme mostrado na Figura
3-17.
Você pode usar duas barras (“//”) ao
invés de três para fazer comentários sobre suas
propriedades e métodos sem que estes
comentários apareçam na documentação online.
Também é possível criar comentários
de várias linhas com os operadores de início de
Figura 3-17 - Documentação da Classe
comentário “/*” e fim de comentário “*/”. Veja
abaixo alguns exemplos de comentários na nossa própria classe Agenda.Contato. Observe que a propriedade
EMail foi comentada e documentada. O comentário não aparecerá na documentação on-line:
/// Contato da Agenda.
Class Agenda.Contato Extends %Persistent
{
// Comentário de uma só linha
Property Nome As %String(MAXLEN = 100);
/// Comentário de documentação
Property Telefone As %String;
/*
Comentário
de várias
linhas.
*/
///Email do contato.
Property EMail As %String;
}
Como exercício, tente documentar um pouco mais a sua classe e ver como a documentação é exibida
na documentação on-line. Tente usar alguns comandos HTML simples como <p>, <br>, <font>, <ol> e <li> e
comentários simples de uma e várias linhas.
HTML – HyperText Markup Language – Linguagem usada para descrever e formatar páginas web. Se você não conhece
um pouco de HTML, recomendo comprar um livro ou buscar um tutorial na Internet sobre o assunto (existem muitos).
14
Preparando o Caché para Nossos Estudos  73
3.4.3 Listando os Objetos usando SQL
Neste tópico, vamos aprender algumas maneiras diferentes de listar os objetos (registros) de nossa
classe (tabela) usando funcionalidades do Portal de Administração do Sistema do Caché. Para tanto, abra o
Portal de Administração e, na página principal (Home), clique em Administração dos Dados > SQL. Nesta seção
do Portal, temos várias usadas no dia-a-dia de qualquer DBA (DataBase Administrator) ou desenvolvedor de
software como pode ser visto na Figura 3-18.
Figura 3-18 - Ferramentas SQL do Portal de Administração do Caché
Observe que no lado esquerdo da tela temos uma lista com todos os namespaces de nossa instância de
Caché. É muito importante que você não se esqueça de clicar no namespace com o qual você gostaria de
trabalhar. No nosso caso, conforme mostrado na Figura 3-18, vamos trabalhar com o namespace USER.
Depois de ter selecionado o namespace correto, clique em
Operações SQL > Exibir Esquemas SQL, como mostrado na Figura 3-19.
Aparecerá uma lista de esquemas.
Um esquema, no mundo relacional, serve para agrupar um
conjunto de tabelas de forma que um banco de dados com muitas tabelas
pode ser melhor organizado em esquemas. Neste momento, é provável que
a lista de esquemas que o seu Caché está exibindo para você seja bem
curta, com apenas um esquema chamado Agenda, equivalente ao pacote
Agenda de nossa classe Contato como exibido na Figura 3-20.
74  Preparando o Caché para Nossos Estudos
Figura 3-19 - Operações SQL
Figura 3-20 - Lista de Esquemas do Namespace USER
Cada esquema listado apresenta um link para que você possa ver as Tabelas nele contidas. Clique no
link do esquema Agenda para ver as tabelas que ele contém.
É possível, quando se está criando uma classe no Caché Studio, informar um nome de tabela e de
esquema diferentes dos nomes dados como nome de classe e pacote, de forma que seja possível
seguir um padrão de nomenclatura no mundo orientado a objetos e outro padrão de nomenclatura no
mundo SQL. Por exemplo, poderíamos ter definido que o nome de tabela e de esquema de nossa
classe
Agenda.Contato
para
que
ela
aparecesse,
para
o
mundo
relacional,
como
AGENDA.AGENDA_CONTATO.
Além do mais, ao contrário de outros bancos de dados, o Caché só usa esquemas para facilitar o
trabalho de organização das tabelas, agrupando-as em grupos de tabelas ou pacotes. Controle de
usuários e autorização não tem relação alguma com esquemas no Caché, por exemplo, como ocorre em
outros bancos de dados. Um esquema não precisa ser criado antes das tabelas que conterá. Basta criar
as tabelas ou classes e os esquemas aparecerão, de acordo com os pacotes das classes ou esquemas
informados nas instruções de criação de tabela (CREATE TABLE). Simples, não?
Agora estamos no contexto do esquema Agenda e no centro da tela, como pode ser visto na Figura
3-21, aparece a lista de tabelas do esquema. Observe também que, do lado esquerdo da tela, o Caché exibe a
lista de esquemas do namespace USER. Como só criamos até agora uma única classe, no pacote Agenda,
apenas o esquema Agenda aparece na lista. Se houvesse mais de um esquema listado, poderíamos clicar nos
esquemas da lista para ver, imediatamente, do lado direito, a lista de tabelas do esquema selecionado.
Preparando o Caché para Nossos Estudos  75
Figura 3-21 - Exibindo as Tabelas do Esquema Agenda
Recordando o que vimos no tópico anterior, onde explicamos como ver a documentação de uma classe
usando o Portal de Administração do Caché, aqui também poderemos pedir a documentação SQL da nossa
tabela Contato. Para tanto, basta clicar no nome da tabela, que é um link para sua documentação, que pode ser
vista na Figura 3-22.
Figura 3-22 - Documentação Relacional da Tabela Agenda.Contato
Estamos agora dentro do contexto da tabela Agenda.Contato. Observe que existe um menu de contexto
com opções diversas como Abrir Tabela, Otimizar Tabela, Reconstruir Índices e etc. Vamos usar a opção Abrir
Tabela em breve. Perceba que, logo abaixo, temos a lista de campos da tabela Agenda.Contato e que existe um
filtro de campos. Pode ser que uma tabela tenha tantos campos que seja necessário fazer uma busca para que
possamos encontrar o campo que queremos. Trata-se de uma documentação viva de tabelas e campos, da
mesma forma que temos para classes! Infelizmente aqui, não são exibidos os comentários de documentação que
colocamos em nossa classe.
Veja que todas as propriedades (EMail, Nome e Telefone) da classe Agenda.Contato, aparecem listadas
como Colunas da tabela Contato. Podemos ver o tipo de dados Orientado a Objetos de cada uma das
76  Preparando o Caché para Nossos Estudos
propriedades na coluna Tipo de Dados e o tipo de dados Relacional da coluna Tipos xDBC15. A propriedade
EMail, por exemplo, que no mundo orientado a objetos do Caché foi definida com o tipo de dados %Library.String
(%String), é exposta para o mundo SQL, automaticamente, como VARCHAR.
Observe também que as propriedades (colunas) EMail e Telefone aceitam um máximo de 50 caracteres
enquanto que a propriedade (coluna) Nome já aceita um tamanho máximo de 100, conforme mudança que
fizemos usando a Janela de Inspeção no tópico 3.2.5 na página 59.
Finalmente, veja que a Barra de Navegação não só nos mostra que estamos vendo uma tabela
específica ([Home] > [SQL] > [Esquemas] > [Tabelas] > [Tabela]), como também nos permite que voltemos para
de onde viemos.
Vamos aproveitar que estamos nesta tela e clicar no link Abrir Tabela para ver uma listagem dos
registros (objetos) de nossa tabela (classe) Agenda.Contato. Uma janela pop-up aparecerá com a listagem
parecida com a da Figura 3-23: Os números de ID poderão ser diferentes no seu sistema já que você
provavelmente criou mais objetos, alterou-os, excluiu-os e etc. Esta é a forma mais simples de se obter uma
listagem dos objetos de uma tabela, sem qualquer critério. Apenas uma parte dos objetos é listada, nunca todos.
Esta opção é só para termos uma ideia do conteúdo da tabela.
Figura 3-23 - Listagem dos Registros da Tabela Agenda.Contato
Se quisermos buscar registros de uma tabela usando critérios e filtros específicos, temos que usar a
linguagem de consulta a banco de dados SQL (Structured Query Language). A SQL é uma linguagem declarativa
que nos permite descrever o que queremos que o banco de dados faça (ao invés de fazer um pequeno programa
para isto). Assim, podemos de fato “pedir por escrito” o que queremos listar usando uma linguagem que o banco
de dados consiga entender e processar. Para tanto, se você ainda estiver com a janela pop-up aberta, exibindo a
listagem de objetos, feche-a. Volte para ver a lista de tabelas de seu esquema (como mostrado anteriormente na
Figura 3-21), clicando em [Tabelas] na sua barra de navegação.
Agora estamos de volta ao contexto do esquema Agenda. A lista de tabelas aparece em baixo e o menu
de contexto em cima. Clique na opção Executar Comando SQL. Você verá uma tela como a da Figura 3-24.
Tenha a certeza de que está no namespace USER, olhando no lado esquerdo de sua tela, o namespace
selecionado.
xDBC – ODBC ou JDBC, que são os dois padrões mais reconhecidos de acesso relacional a banco de dados. Todos os
outros “padrões” são, na verdade, APIs proprietárias dos fornecedores de bancos de dados relacionais, que normalmente
apresentam limitações de portabilidade.
15
Preparando o Caché para Nossos Estudos  77
Figura 3-24 - Executar Comando SQL
Agora podemos digitar no campo texto que aparece no centro da tela o comando SQL abaixo:
Select * From Agenda.Contato
Pressione o botão Executar Consulta para executar o comando SQL. O resultado deve ser parecido com
o mostrado na Figura 3-24. Talvez apareçam mais ou menos registros de acordo com o número de objetos que
você tenha criado nos tópicos anteriores.
O comando SQL acima é bem simples de entender:
Select
Selecionar (Listar)
*
Todas as Colunas
From Agenda.Contato
Da tabela Agenda.Contato
O asterisco é uma máscara que substitui a lista de todas as colunas da tabela. Você pode substituir o
asterisco pelos nomes das colunas que você quer separadas por vírgulas assim:
Select Nome, EMail, Telefone From Agenda.Contato
78  Preparando o Caché para Nossos Estudos
Mas o asterisco é mais fácil não? Mas nem sempre é mais eficiente. Agora imagine que queiramos
saber o telefone do registro (objeto) de ID 1 (um):
Select Telefone From Agenda.Contato Where ID=1
Simples não? Usamos o comando WHERE da linguagem SQL para explicar para o Caché que estamos
interessados apenas no objeto de ID um. Mas e se quiséssemos listar o Telefone de um registro a partir de seu
EMail?
Select Telefone From Agenda.Contato Where EMail = '[email protected]'
Novamente usamos o comando WHERE, mas agora impusemos uma restrição em outra coluna: EMail.
Perceba que usamos aspas simples para envolver o endereço de e-mail. Isto é essencial.
Aprendemos em tópicos anteriores como criar objetos (registros) usando Caché Object Script. Vamos
aprender agora como criar registros (objetos) usando SQL:
Insert Into Agenda.Contato (Nome, Telefone, EMail) Values (‘Carlos Silva’, ‘555-5454’,
‘[email protected]’)
O comando INSERT da linguagem SQL serve, como o nome sugere, para inserir novos registros em
uma tabela (Into Agenda.Contato). Como você pode ver no exemplo, primeiro listamos os nomes das colunas
que queremos preencher no novo registro, separando-as com vírgulas, entre parêntesis. Depois informamos os
valores destas colunas (Values), na mesma ordem, colocando cada valor entre aspas simples, separando-os por
vírgulas.
Depois de executar o comando INSERT acima, você pode tentar executar o comando SELECT
novamente para ver o seu novo registro aparecer na listagem. Perceba que ao lado de cada registro, também
aparece o seu ID. Observe que o seu novo registro também ganhou um novo ID automaticamente.
Como exercício, você pode tentar inserir mais alguns registros usando o comando INSERT da SQL.
Depois você pode usar o comando SELECT para listar seus registros e ver os IDs que eles ganharam. Por fim,
pode escolher um ou mais IDs para abrir os registros de forma orientada a objetos, usando Caché Object Script
através do Caché Terminal, com o método %OpenId() da classe Agenda.Contato como explicamos no Tópico
3.3.1 na página 60.
A esta altura, você já deve ter percebido a natureza híbrida do Caché, que permite que você trabalhe
tanto com o modelo orientado a objetos quanto com o modelo SQL, sem mapeamentos ou sobreposição
de camadas. O acesso aos dados é sempre direto, independente da via que escolhemos.
Preparando o Caché para Nossos Estudos  79
3.5 Criando Nossa Primeira Página Web
Agora que você já conhece a arquitetura do Caché, aprendeu a usar o Caché Studio e o Portal de
Administração do Caché, sabe um pouco de Caché Object Script e SQL, vamos aprender como criar uma página
Caché Server Pages (CSP) e listar todos os nossos contatos de nossa agenda na Web.
Na Figura 3-25, você pode ver uma
variação do diagrama de arquitetura do
Caché que mostramos no início do Capítulo 1.
Observe que a infraestrutura que suporta o
Caché Server Pages se apoia no Caché
Database Engine, no Engine de Objetos do
Caché e no Engine SQL do Caché. Isto
significa que quando desenvolvemos
aplicações usando Caché Server Pages,
podemos ter acesso direto a todos os
recursos do Caché de forma Orientada a
Figura 3-25 - Arquitetura do Caché
Objetos, SQL ou usando diretamente o Caché
Database Engine para tarefas que exigem o máximo de desempenho.
Acima de toda a infraestrutura oferecida pelo Caché Server Pages, como pode ser observado na Figura
3-25, podemos ver o Zen, um framework para construção de aplicações web ultra interativas com tecnologia
AJAX (Asynchronous Javascript And XML). O Zen traz componentes web como formulários, grids, calendários,
etc., prontos para construção rápida de aplicações e portais Web integradas ao banco de dados objeto-relacional
do Caché. Veremos um pouco mais de Zen nos próximos capítulos. Por agora, vamos nos concentrar no Caché
Server Pages (CSP), que não só é a base do Zen, como também permite a construção de aplicações Web
completas por si só. O Zen surgiu com o Caché 2007.1 e, antes disto, dezenas de milhares de aplicações web
foram construídas em Caché somente com o uso de CSP.
3.5.1 Criando Nossa Primeira Página CSP
Para começar a criar nossa primeira página CSP, abra novamente o Caché Studio no namespace
USER. Se o Caché Studio já não abriu o seu projeto automaticamente para você, abra-o, pois vamos adicionar
nossa primeira página CSP como mais um componente do projeto!
Clique no botão Novo, na barra de ferramentas do Caché Studio, ou use a combinação de teclas
CTRL+N. Na janela que aparece, clique na aba CSP, e selecione Caché Server Pages, como mostrado na Figura
3-26, e clique no botão Ok para que o Caché Studio crie uma nova página CSP.
80  Preparando o Caché para Nossos Estudos
Figura 3-26 - Nova Página Caché Server Pages
A primeira página CSP que o Caché Studio cria para nós já vem com um modelo básico de página
HTML que podemos continuar a estender, adicionando mais código, como pode ser visto abaixo:
<html>
<head>
<!-- Put your page Title here -->
<title> Cache Server Page </title>
</head>
<body>
<!-- Put your page code here -->
My page body
</body>
</html>
3.5.2 Salvando e Compilando nossa Primeira Página CSP
Neste momento, já podemos pedir ao Caché Studio para salvar a nossa primeira página Web clicando
no botão Salvar, na barra de ferramentas do Caché Studio ou usando a tecla de atalho CTRL+S. Uma janela
aparecerá perguntando pelo nome que será dado a nossa nova página CSP e a pasta onde ela será salva.
Preparando o Caché para Nossos Estudos  81
No campo, Nome do Arquivo, entre com “contatos.csp” (sem as aspas). Selecione, na lista de pastas
acima do campo, a pasta “csp/user”, dando um duplo clique nela. Esta é uma pasta virtual que está mapeada
para a pasta física em disco <InstallDir>\CSP\user. Portanto, depois que você clicar no botão Salvar, você já
pode abrir o seu Windows Explorer, na pasta física acima mencionada, e verificar que, de fato, um arquivo com o
nome “contatos.csp” foi criado.
Estamos criando nossa nova página no namespace USER, que já vem com o Caché. Mais tarde,
quando aprendermos a criar novos namespaces, veremos como criar novas aplicações CSP e como mapeá-las
para pastas físicas no disco.
Por fim, vamos compilar nossa página CSP, clicando no botão Compilar na barra de ferramentas do
Caché Studio ou usando a tecla de atalho CTRL+F7. Agora sim já podemos tentar dar uma olhada na nossa
página Web clicando no botão de Exibir Página Web
, na barra de ferramentas do Caché Studio, ou através
da mesma opção no menu Exibir > Exibir Página Web. O seu navegador web padrão será aberto. Mas ao invés
de ver diretamente a sua página Web, você verá uma tela de login. Você pode entrar diretamente com o super
usuário _system como sempre.
Lembre-se desta rotina: Alterar a página, salvá-la, compilá-la e, finalmente, pedir para exibi-la em seu
navegador padrão. Se você não compilar a página, não verá as mudanças. Além disto, pode ser que o
Caché não peça por um usuário e senha, se você instalou o Caché PC ou se você fez uma instalação
mínima ou para desenvolvimento.
3.5.3 Alterando a Página para Exibir Nossos Contatos
Agora que aprendemos a criar, editar e compilar uma página Caché Server Pages, e já criamos a nossa
primeira página, vamos fazer com que ela faça algo realmente útil. Neste nosso exemplo, aprenderemos como
usar os mesmos comandos SQL que usamos no Portal de Administração do Sistema, para obter uma lista de
contatos (objetos de nossa base de dados) e exibir algumas de suas informações em uma lista na Web.
Para tanto, vamos abrir a página CSP criada no tópico anterior (se você a fechou) para começar a
adicionar algum código nela. Para abrir a página CSP, basta clicar no menu Arquivo > Abrir. Uma janela
aparecerá perguntando que tipo de arquivo você deseja abrir. Na parte de baixo da janela, no campo Arquivos do
tipo, selecione Caché Server Pages (*.csp, *.csr). Depois, na lista acima, encontre a sua página CSP e clique no
botão Abrir.
Altere a seção body de sua página CSP para que ela se pareça com o código a seguir:
1. <body>
2.
3. <table border="1">
4. <tr>
5.
<td>Nome</td>
6.
<td>Telefone</td>
82  Preparando o Caché para Nossos Estudos
7. </tr>
8.
<script language="cache" runat="server">
9.
Set rs = ##class(%Library.ResultSet).%New()
10. Set status = rs.Prepare("select Nome, Telefone from Agenda.Contato")
11. Set status = rs.Execute()
12. While rs.Next()
13. {
14.
Write "<tr><td>",rs.Get("Nome"),"</td>"
15.
Write "<td>",rs.Get("Telefone"),"</td></tr>"
16. }
17. </script>
18. </table>
19.
20. </body>
Não copie a numeração de linhas. Elas servem apenas para nos ajudar a fazer comentários sobre o
código.
Iniciamos criando uma tabela e definindo uma linha fixa com duas colunas: Nome e Telefone. Em
seguida, na linha oito, usamos a tag <script> para abrir um bloco de código Caché Object Script
(language=”cache”), que vai ser executado no servidor (runat=”server”). Isto faz muito sentido já que a tag
<script> pode ser usada para se enviar código JavaScript ou VBScript para o navegador (cliente) e o que
queremos é um código que vai rodar no servidor, consultando a base de dados e gerando o HTML que vai ser
enviado ao cliente.
Se você não conhece HTML, sugiro procurar um pequeno tutorial na Internet sobre o assunto. Existem
muitos e é realmente muito fácil!
Na linha nove já começamos a escrever código em Caché Object Script. O código que podemos
escrever aqui é o mesmo que escreveríamos na linha de comando do Caché Terminal, só que agora, podemos
escrever os comandos que queremos que sejam executados na ordem que quisermos, um abaixo do outro, e
todos eles serão executados de uma vez quando a página for chamada!
Começamos usando o comando Set para criar um objeto chamado rs (de ResultSet) da classe
%Library.ResultSet. Esta classe possui vários métodos muito úteis para criar e executar comandos SQL no
Caché. Em seguida, na linha dez, usamos novamente o comando Set para atribuir à variável status o resultado
Preparando o Caché para Nossos Estudos  83
da execução do método de instância Prepare do objeto rs, passando como único parâmetro para o método a
instrução SQL que queremos executar que, neste caso, é uma consulta (SELECT).
Vale ressaltar novamente que um objeto da classe %Library.ResultSet pode executar quase todo tipo de
instrução SQL como SELECT, INSERT, UPDATE, DELETE, CREATE TABLE, etc. Basta passar a
instrução para o método Prepare.
Agora nosso objeto rs já preparou a consulta e só espera a ordem para executá-la. Na linha onze,
novamente usamos o comando Set para atribuir à variável status o resultado da chamada ao método de instância
Execute do objeto rs.
Observe que tanto o método Prepare quanto o método Execute, retornam um valor de status,
informando se eles de fato conseguiram fazer o que se propõem ou se tiveram problemas. Por exemplo,
poderíamos ter passado uma instrução SQL inválida, pedindo um nome de coluna de nossa tabela que
não existe. É por isto que usamos o comando Set para chamar estes métodos. Se eles não retornassem
valor algum, poderíamos usar o comando Do, que vamos aprender nos próximos tópicos. De qualquer
forma, não estamos verificando o conteúdo da variável status depois de chamar os métodos e isto é
uma falta gravíssima, que pode fazer com que bugs passem despercebidos. Mas para este exemplo,
vamos tolerar esta falta e seguir em frente. Aprenderemos como escrever código seguro em breve.
Agora que já preparamos e executamos a nossa consulta, o objeto rs contém uma lista de linhas com o
resultado. Para percorrer esta lista, usaremos o método Next, que tenta mover o ponteiro ao longo da lista de
resultados para a próxima linha da lista. Se o método Next conseguiu mover o ponteiro para uma próxima linha
ele retorna 1 (verdadeiro) e em caso contrário ele retorna 0 (falso).
Portanto, para percorrer todas as linhas do resultado de nossa consulta, teríamos que chamar o método
Next várias vezes! Para isto, na linha doze, usamos o comando de repetição While que recebe como parâmetro
uma condição. Se esta condição for verdadeira, o comando While executará o bloco de código entre chaves logo
abaixo. Caso contrário, o comando While desviará a execução para a próxima linha depois do bloco entre
chaves. A condição que passamos para o comando While é a chamada ao método Next do objeto rs. Assim, se o
método Next conseguir mover o ponteiro interno para o próximo item da lista de resultados, ele retornará 1
(verdadeiro), indicando ao comando While que o bloco de código entre chaves pode ser executado. Caso
contrário, o método Next terá chegado ao fim da lista e retornará 0 (falso) e o comando While saberá que não é
mais preciso executar o bloco de código entre chaves. Podemos ler o bloco de código da linha 12 a 16 assim:
ENQUANTO rs.TemMaisUmaLinha FAÇA:
Escreva...
Escreva...
PROXIMO.
84  Preparando o Caché para Nossos Estudos
Agora, podemos escrever o código, dentro do bloco entre chaves, que será executado para cada linha
do resultado de nossa consulta. Este código Caché Object Script deverá gerar o código HTML que será enviado
ao navegador para terminar de desenhar a nossa listagem de contatos na Web.
Para enviar coisas para o navegador, em Caché Object Script, usamos o comando Write. Enquanto que
no Caché Terminal, o comando Write servia para enviar coisas para a nossa própria tela, em um bloco <script>
de uma página Caché Server Pages, o comando Write serve para enviar coisas para o navegador Web.
Começamos, na linha 14, enviando as tags <tr> para abrir uma nova linha na <table> que criamos antes
e, em seguida, a tag <td> para já criarmos a primeira coluna da linha. Em seguida, usamos uma vírgula, para
continuar escrevendo coisas para o navegador:
12. While rs.Next()
13. {
14.
Write "<tr><td>",rs.Get("Nome"),"</td>"
15.
Write "<td>",rs.Get("Telefone"),"</td></tr>"
16. }
O comando Write permite que várias coisas sejam escritas em sequência, separando cada uma delas
com vírgulas. Assim, depois da primeira vírgula, usamos o método de instância Get do objeto rs para obter o
valor da coluna Nome e, por fim, usamos outra vírgula para enviar a tag </td> que fecha a nossa primeira coluna.
Na linha 15, fazemos a mesma coisa com a ressalva de que a linha já está aberta (não precisamos imprimir outro
<tr>). Mas depois de imprimir o valor da coluna Telefone, não temos mais colunas para imprimir assim que
terminamos fechando a linha com a tag </tr>.
Agora compile a sua página e peça para ser visualizada no navegador. Se você quiser melhorar um
pouco a página, pode tentar adicionar a coluna EMail que está faltando e usar um pouco de cores para formatar a
tabela de forma que ela fique mais bonita. Use seus conhecimentos de HTML!
3.5.4 Usando Tags Caché Server Pages Especiais
Podemos fazer a mesma coisa que fizemos no tópico anterior sem usar quase nada de Caché Object
Script. Veja no exemplo abaixo que começamos, na linha dois, com uma tag <script> da mesma forma que no
exemplo anterior, só que agora especificamos SQL como linguagem (language=”sql”). Observe também que
definimos um nome para o consulta (name=”rs”).
De fato, a tag <script>, com esta configuração, usará a consulta SQL que passarmos no seu interior
para criar um objeto da classe %Library.ResultSet, idêntico ao que usamos no tópico anterior, colocando-o na
variável cujo nome foi passado para o atributo name (rs).
Por fim, a tag <script> já executará a consulta, chamando o método Execute do objeto rs
automaticamente para nós, deixando assim tudo pronto para que já possamos percorrer o resultado!
Preparando o Caché para Nossos Estudos  85
Lembre-se: Não copie a numeração de linhas. Elas servem apenas para nos ajudar a comentar o
código.
1.
2.
<script language="sql" runat="server" name="rs">
select ID, Nome, Telefone, EMail from Agenda.Contato
3.
</script>
4.
<table border="1">
5.
<tr>
6.
<td>Id</td><td>Nome</td><td>Telefone</td><td>EMail</td>
7.
</tr>
8.
<csp:while condition="rs.Next()">
9.
<tr>
10.
<td>#(rs.GetData(1))#</td>
11.
<td>#(rs.GetData(2))#</td>
12.
<td>#(rs.GetData(3))#</td>
13.
<td>#(rs.GetData(4))#</td>
14.
</tr>
15.
</csp:while>
16.
</table>
Em seguida, das linhas 5 a 7, imprimimos normalmente os comandos HTML para o cabeçalho de nossa
tabela e, na linha 8, usamos a tag <csp:while> para percorrer o resultado de nossa consulta. A tag <csp:while>
tem uma condição (condition=”rs.Next()”) que indica até quando o seu interior será repetido. Funciona da mesma
maneira que o comando While que usamos no tópico anterior.
No interior da tag <csp:while>, abrimos uma linha com a tag <tr> e abrimos uma coluna para cada
coluna que queremos imprimir de nossa linha atual. Observe que na linha 10 usamos a expressão
#(rs.GetData(1))#. O resultado da expressão que estiver entre #( e )# será simplesmente enviado ao navegador
Web. Isto é equivalente ao comando Write rs.GetData(1).
O método GetData é semelhante ao método Get com a diferença de que, ao invés de esperar o nome
da coluna como o método Get, ele espera o número da coluna: 1 para a primeira, 2 para a segunda e assim por
diante. É só mais uma maneira de se pedir o valor de uma coluna de uma consulta. Você pode optar pela
maneira que você achar melhor (Get() ou GetData()). A vantagem de pedir a coluna pelo numero, com GetData,
é que você não precisa saber o nome da coluna, só que ela está ali.
86  Preparando o Caché para Nossos Estudos
Como exercício, tente alterar a página para mostrar a lista de contatos em ordem alfabética. Para isto,
você precisará alterar o seu comando SQL, adicionando uma cláusula de ordenação como o exemplo abaixo:
<script language="sql" runat="server" name="rs">
Select ID, Nome, Telefone, EMail from Agenda.Contato
Order By Nome
</script>
A cláusula ORDER BY do comando SELECT aceita como parâmetros os nomes das colunas pelas
quais desejamos ordenar a listagem. No exemplo acima, passamos apenas a coluna Nome, mas poderíamos ter
passado mais de uma coluna de ordenação, separando seus nomes por vírgulas, de forma que o Caché
ordenaria primeiro por uma coluna, em seguida pela segunda e assim por diante.
No próximo tópico, vamos seguir com o nosso tour e aprender o que são e como criar rotinas. Depois de
conhecer as rotinas, terminaremos nosso tour aprendendo como construir páginas Web usando Zen!
Preparando o Caché para Nossos Estudos  87
3.6 Criando Nossa Primeira Rotina Caché Object Script
Rotinas Caché Object Script são muito úteis quando queremos escrever pequenos trechos de código ou
utilitários. Poderíamos escrever tudo em métodos de classes (que ainda não aprendemos a criar, só a usar), mas
rotinas representam outra forma de fazê-lo sem a necessidade de criar uma classe só para isso.
Por outro lado, toda vez que compilamos uma Classe no
Caché, o compilador gera uma série de rotinas que, depois, são
transformadas em código objeto para a máquina virtual do Caché.
Mesmo páginas CSP, quando compiladas, são transformadas em
Classes para, em seguida, serem compiladas em rotinas e em
código objeto da máquina virtual do Caché.
Comandos SQL também são compilados em Rotinas
antes de serem executados. Portanto, todo código que
escrevemos no Caché, no fim, vira uma rotina que será compilada
no código objeto para a máquina virtual do Caché.
Figura 3-27 - No fim, sempre temos rotinas!
É por esta razão que é muito importante aprender a criar
e usar rotinas, pois esbarraremos com elas a todo momento. A ideia deste capítulo é praticar um pouco mais de
Caché Object Script ao criar uma rotina que nos permita criar um novo contato em nossa agenda.
3.6.1 Criando nossa primeira Rotina Caché Object Script
Para começar a criar nossa primeira Rotina Caché Object Script, abra novamente o Caché Studio no
namespace USER. Se o Caché Studio já não abriu o seu projeto automaticamente para você, abra-o, pois
vamos adicionar nossa primeira página CSP como mais um componente do projeto!
Figura 3-28 - Nova Rotina Caché Object Script
88  Preparando o Caché para Nossos Estudos
Clique no botão Novo, na barra de ferramentas do Caché Studio, ou use a combinação de teclas
CTRL+N. Na janela que aparece, clique na aba Geral, e selecione Rotina Caché Object Script, como mostrado
na Figura 3-28, e clique no botão Ok para que o Caché Studio crie uma nova Rotina.
A nova Rotina Caché Object Script aparecerá, em branco. Para começar, vamos fazer uma simples
rotina “Olá Mundo!”.
Para digitar o código do exemplo abaixo, tenha certeza de preceder cada linha com um espaço ou com
um TAB. Não se pode escrever código Caché Object Script “colado” na margem esquerda da rotina, pois o
Caché Object Script entende que qualquer texto que comece na margem esquerda está, na verdade, definindo
um Rótulo. Aprenderemos sobre Rótulos no Capítulo 4.
Write !,“Olá Mundo!”
Write !,”Pressione ENTER para terminar.”
Read lixo
Observe que cada linha de comando na rotina possui um TAB antes.
3.6.2 Salvando e Compilando nossa Primeira Rotina
Neste momento, já podemos pedir ao Caché Studio para salvar a nossa primeira Rotina clicando no
botão Salvar, na barra de ferramentas do Caché Studio ou usando a tecla de atalho CTRL+S. Uma janela
aparecerá perguntando pelo nome que será dado a nossa nova Rotina.
No campo Nome do Arquivo entre com “Contatos.MAC” (sem as aspas e cuidado com maiúsculas e
minúsculas).
Observe que nossa rotina tem a extensão “.MAC”. Páginas CSP tem a extensão “.CSP”, classes têm a
extensão “.CLS” e Rotinas tem a extensão “.MAC”. Existem, no entanto, outros tipos de rotinas, com
outros tipos de extensões. No nosso caso, estamos criando o tipo de rotina mais comum. Mas existem,
por exemplo, rotinas Caché Basic, que ao contrário de serem programadas em Caché Object Script,
permitem que se use VBScript e possuem a extensão “.BAS”. No final, uma rotina Caché Basic também
é compilada para o mesmo código objeto interpretável pela máquina virtual do Caché. Além disto,
existem também rotinas de Include (extensão “.INC”) e rotinas intermediárias (“.INT”). Falaremos com
mais detalhes sobre os tipos específicos de rotinas nos próximos capítulos.
Por fim, vamos compilar nossa Rotina, clicando no botão Compilar na barra de ferramentas do Caché
Studio ou usando a tecla de atalho CTRL+F7. Agora podemos abrir o Caché Terminal, no namespace USER, e
usar o comando Do para executar a nossa nova rotina.
Preparando o Caché para Nossos Estudos  89
Veja no exemplo abaixo que precisamos preceder o nome da rotina com o caractere ^ (chapeuzinho,
circunflexo, up arrow, caret ou simplesmente “seta para cima”). Explicaremos a razão disto no próximo capítulo.
Por enquanto, assuma como uma regra:
USER>Do ^Contato
Olá Mundo!
Pressione ENTER para terminar.
Observe que o comando Read, usado na rotina, fez com que a rotina não retornasse imediatamente
para a linha de comando. O comando Read permite que o usuário entre com texto até que a tecla ENTER seja
pressionada. Todo o texto digitado é então armazenado na variável passada como primeiro parâmetro para o
comando. No nosso caso, chamamos a variável de lixo, já que não estamos de fato interessados no que o
usuário digitou, só queríamos fazer uma pausa. No próximo tópico, usaremos o comando Read para obter
informações importantes do usuário.
Lembre-se desta rotina: Alterar a rotina, salvá-la, compilá-la. Se a rotina não for compilada, o novo
código objeto não será gerado e você poderá estar executando ainda a versão antiga da rotina.
3.6.3 Expandindo as Funcionalidades
Agora que já aprendemos a criar, salvar, compilar e testar nossa rotina Caché Object Script, vamos
terminar de ampliar as suas funcionalidades. Se você fechou a sua rotina ou o Caché Studio, abra o Caché
Studio e a sua rotina através da opção de menu Arquivo > Abrir. Aparecerá uma janela perguntando que arquivo
você deseja abrir. Selecione no campo Arquivos do Tipo o tipo de arquivo Rotina Macro (*.mac) e encontre a
sua rotina na lista acima do campo para, então, clicar em Abrir.
Apague a linha onde imprimimos “Olá Mundo” e entre com o código abaixo.
Lembre-se: Não copie a numeração de linhas. Elas servem apenas para nos ajudar a comentar o
código.
1.
Write !,"Entre com os dados do contato:"
2.
Read !,"Nome :", nome
3.
Read !,"Telefone:", tel
4.
Read !,"EMail :" , email
5.
6.
Set contato = ##class(Agenda.Contato).%New()
7.
Set contato.Nome=nome
8.
Set contato.Telefone=tel
90  Preparando o Caché para Nossos Estudos
9.
Set contato.EMail=email
10. Set status = contato.%Save()
11.
12. If status=1
13. {
14.
Write !!,"Contato salvo!"
15. }
16. Else
17. {
18.
Do $System.Status.DisplayError(status)
19. }
Nas linhas 1 a 4, usamos os comandos Write e Read para pedir informações para o usuário. Assim, ao
final da execução deste bloco de comandos, teremos as variáveis nome, tel e email, criadas e preenchidas com o
nome, telefone e e-mail, respectivamente, do novo contato a ser criado.
Observe que a variável passada como parâmetro para o comando Read não precisa existir de antemão.
O comando cria a variável automaticamente com o que foi digitado pelo usuário no Caché Terminal.
Nas linhas de 6 a 10, usamos o já conhecido método %New() da nossa classe Agenda.Contato para
criar um novo objeto na variável contato, e preenchemos cada uma das propriedades do objeto com o conteúdo
das variáveis coletado no bloco anterior. Na linha 13, chamamos o método %Save(), para tentar salvar o nosso
novo objeto.
Na linha 12 usamos o comando If (“se”) para verificar se a variável status, preenchida com o retorno da
chamada ao método %Save(), contém o valor 1 (verdadeiro), indicando que o objeto foi salvo com sucesso e sem
problemas. É a primeira vez que você está vendo o comando If em Caché Object Script, mas a sua estrutura é
muito simples. O único parâmetro esperado pelo comando If é uma expressão. Se o resultado da expressão for
verdadeiro, o bloco de código entre chaves (“{“ e “}”) logo após o comando If é executado. Caso contrário, se
houver um comando Else em seguida, seu bloco de código entre chaves é executado.
No nosso caso, se status for igual a 1, imprimiremos na tela a frase “Contato salvo!”. Caso contrário,
usaremos o método DisplayError, da variável de sistema $System.Status para imprimir na tela a descrição do
problema. Precisamos disto, pois a descrição do problema pode ser complexa, envolvendo vários eventos. É por
isto que o Caché retorna a descrição do problema codificada. E para conseguirmos decodificar o conteúdo da
variável status, precisamos dos métodos do objeto especial de sistema $System.Status. Existem vários outros
métodos ali que aprenderemos a usar depois.
Preparando o Caché para Nossos Estudos  91
A variável de sistema $System dá acesso a vários objetos de sistema. Ela expõe vários métodos úteis
que podemos chamar. No nosso caso, usamos o método $System.Status.DisplayError() para decodificar
e mostrar na tela o conteúdo da variável status passada como primeiro parâmetro. Veremos mais sobre
variáveis de sistema no Capítulo 4.
Agora tente compilar a sua rotina para que possamos testá-la no Caché Terminal. A Figura 3-29 mostra
o resultado da execução da rotina.
Como exercício, tente:
1. Criar alguns novos contatos (comando INSERT) e buscá-los (comando SELECT) usando comandos da
SQL através do Portal de Administração do Caché.
2. Chamar a página CSP para listar os contatos na Web.
3. Tente criar um contato com um EMail com mais de 50 caracteres. Você verá um erro informando que o
valor da propriedade excede os 50 caracteres (O MAXLEN padrão é 50, lembra?).
Figura 3-29 - Exemplo de execução
92  Preparando o Caché para Nossos Estudos
3.7 Criando a sua Primeira página Zen
Agora que já estamos familiarizados com as principais ferramentas do Caché e conhecemos alguns dos
principais conceitos como classes e rotinas, vamos terminar o nosso pequeno tour construindo uma página Zen
para permitir a listagem e edição livre de contatos. Quando pronta, a nossa primeira aplicação Zen terá a
seguinte aparência:
Figura 3-30 A aparência de nossa primeira aplicação Zen
Uma aplicação Web qualquer, é normalmente composta de várias páginas. Uma aplicação Zen não é
diferente: Normalmente criamos várias páginas Zen que, juntas, entregam a funcionalidade completa da
Aplicação. Vamos ver que uma página Zen nada mais é do que uma classe Caché especial, mas além das
páginas Zen, uma aplicação Zen exige que você defina uma classe para representar a aplicação Zen
propiamente dita. Está classe define estilos CSS e javascripts padrão para todas as páginas Zen que façam
referencia a ela:
Figura 3-31 - Uma aplicação Zen
Preparando o Caché para Nossos Estudos  93
É claro que cada página Zen individual pode definir estilos CSS e javascript próprios, mas quando
quisermos definir estilos e scripts que serão usados em todas as páginas, a classe da aplicação é o melhor lugar
para defini-los. Por ser tão essencial, vamos começar criando uma nova classe de aplicação Zen!
3.7.1 Criando a Classe de Aplicação Zen
Abra o Caché Studio e verifique se você está trabalhando no namespace USER e se você está com o
seu projeto aberto. Clique no menu Arquivo > Novo ou pressione CTRL + N. A seguinte janela aparecerá:
Figura 3-32 - Nova Aplicação Zen
Selecione “Nova Aplicação Zen” para iniciar o assistente de criação da classe de Aplicação Zen que
pode ser visto na Figura 3-33. Sendo uma classe, uma aplicação Zen sempre é definida em um pacote. Vamos
criar a nossa classe de aplicação no pacote Agenda.UI, a classe se chamará Application e também estamos
definindo o nome “Agenda de Contatos” como nome de nossa aplicação:
94  Preparando o Caché para Nossos Estudos
Figura 3-33 - Criando uma nova aplicação
Depois de preencher os campos do assistente, basta com pressionar Finalizar para que o assistente crie
a classe de Aplicação para você. A nossa nova classe pode ser vista na Figura 3-34.
Figura 3-34 - A nossa primeira classe de aplicação Zen
Observe que a nossa nova classe Agenda.UI.Application herda de %ZEN.application e que existe um
lugar (bloco XData) para definir as folhas de estilo CSS padrão de toda aplicação. Vamos definir um estilo básico
Preparando o Caché para Nossos Estudos  95
padrão para toda a nossa aplicação imediatamente. Faça com que o XData Style de sua classe de aplicação
fique assim:
/// This Style block contains application-wide CSS style definitions.
XData Style
{
<style type="text/css">
body { background: #eeeeee; font-size: 1em; font-family: Verdana; }
#title {
background: #36393D;
color: white;
font-size: 1.5em;
padding: 10px;
}
fieldSet { color: #D15600; font-weight: bold; }
form { margin: 15px; }
.text {
background: white;
border: 1px solid black;
margin:0 0 10px 5px;
height: 25px;
padding: 5px;
}
.button {
color: white;
background: #3F4C6B;
border: 1px solid black;
padding: 2px;
margin: 5px;
}
table.tpTable tr.tpSelected { background: #c3d9ff;}
</style>
}
Se você não está familiarizado com HTML e CSS (Cascade Style Sheets), não se preocupe. Basta
saber que com os comandos acima, definimos as cores e estilos de varias coisas básicas de nossa aplicação
como o título, fundo da página, etc. Existem muitos tutoriais de CSS na Internet e quando abordemos o Zen em
mais detalhes, vamos fazer uma pequena introdução.
Não deixe de compilar a sua nova classe de Aplicação Zen!
96  Preparando o Caché para Nossos Estudos
3.7.2 Criando a nossa primeira página Zen
Agora que temos uma classe de aplicação Zen básica pronta, podemos continuar e criar a nossa
primeira página Zen. Clique no menu Arquivo > Novo ou pressione CTRL + N. A seguinte janela aparecerá:
Figura 3-35 - Criando a nossa primeira página Zen
Na janela que se abre, selecione Nova Página Zen (New Zen Page) e clique no botão OK para iniciar o
assistente de criação de uma nova página Zen:
Preparando o Caché para Nossos Estudos  97
Figura 3-36 - Assistente de Criação de uma nova página Zen
Conforme explicamos, uma página Zen também é uma classe Caché e por isto temos que informar o
pacote e o nome da classe. Vamos criar a nossa classe Contato no pacote Agenda.UI como pode ser visto na
Figura 3-36. Além disto, também é muito importante definir a qual aplicação esta página Zen pertence
98  Preparando o Caché para Nossos Estudos
(Agenda.UI.Application). Finalmente, defina um nome para a página e o seu domínio conforme mostra a figura.
Explicaremos para que serve o domínio quando abordemos Zen nos próximos capítulos.
Clique no botão próximo (Next) para ver a próxima tela do assistente. Nesta tela, você deve escolher o
estilo geral da página Zen:
Figura 3-37 - Definindo o estilo geral da página
Escolha o estilo Title Page de acordo com o mostrado na Figura e clique no botão Finalizar (Finish). O
assistente de criação de páginas Zen criará uma nova classe no seu projeto com o conteúdo abaixo:
1. /// Created using the page template: Title Page
2. Class Agenda.UI.Contato Extends %ZEN.Component.page
3. {
4.
/// Class name of application this page belongs to.
5.
Parameter APPLICATION = "Agenda.UI.Application";
6.
7.
/// Displayed name of this page.
8.
Parameter PAGENAME = "Agenda de Contatos";
9.
10. /// Domain used for localization.
11. Parameter DOMAIN = "Agenda";
12.
13. /// This Style block contains page-specific CSS style definitions.
14. XData Style
15. {
Preparando o Caché para Nossos Estudos  99
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41. }
<style type="text/css">
/* style for title bar */
#title {
background: #C5D6D6;
color: black;
font-family: Verdana;
font-size: 1.5em;
font-weight: bold;
padding: 5px;
border-bottom: 1px solid black;
text-align: center;
}
</style>
}
/// This XML block defines the contents of this page.
XData Contents [XMLNamespace="http://www.intersystems.com/zen"]
{
<page xmlns="http://www.intersystems.com/zen" title="">
<html id="title">Agenda de Contatos</html>
<vgroup width="100%">
<!-- put page contents here -->
</vgroup>
</page>
}
Como podemos ver na primeira linha, a nossa nova página herda de %ZEN.Component.page e possui
três parâmetros que contém exatamente o que informamos no assistente de criação de páginas Zen: A aplicação
a qual pertence a página, o domínio e o nome da página.
Observe que entre a linha 13 e 29, o assistente incluiu um bloco XData com estilos específicos para esta
página. Não vamos necessitar este bloco assim que você pode exclui-lo completamente ou só apagar o que está
entre as linhas 17 e 27 (o #title).
Finalmente, podemos ver outro bloco XData chamado Contents que é onde está definida a nossa
página. Você pode compilar a página do jeito que está e clicar no menu Ver > Página Web para dar uma olhada
na página em seu navegador. Você verá que ela só mostrará um título e nenhum outro conteúdo, mas observe
como ela já está usando alguns dos estilos CSS definidos na classe da aplicação!
Vamos começar a adicionar alguns componentes a nossa página, começando por uma tabela que
mostrará todos os contatos cadastrados na nossa agenda atualmente. Para tanto, basta com substituir o
comentário na linha 37 por:
1.
2.
3.
4.
5.
6.
XData Contents [XMLNamespace="http://www.intersystems.com/zen"]
{
<page xmlns="http://www.intersystems.com/zen" title="">
<html id="title">Agenda de Contatos</html>
<vgroup width="100%">
<spacer width="5px"/>
100  Preparando o Caché para Nossos Estudos
7.
<tablePane id="myTable" tableName="Agenda.Contato" useKeys="true"
valign="top">
8.
<column colName="ID" hidden="true"/>
9.
<column colName="Nome" header="Nome" filterType="text"/>
10.
<column colName="Telefone" header="Telefone" filterType="text"/>
11.
<column colName="EMail" header="EMail" filterType="text"/>
12.
</tablePane>
13.
</vgroup>
14. </page>
15. }
16. }
Na linha 6, usamos a tag <spacer> para criar um pequeno espaço de 5 pixels e afastar a nossa tabela
um pouco da margem esquerda da página. Em seguida adicionamos à nossa página o componente <tablePane>.
Vamos a referenciar este componente depois e é por isto que definimos um id (myTable) para ele. Em seguida,
também definimos o atributo tableName com o valor “Agenda.Contato” e assim especificamos a origem dos
dados. Compile a página e peça para ve-la novamente no seu navegador. Se você tem registros guardados na
sua classe Agenda.Contato, eles deverão aparecer na tabela.
Ainda no seu navegador, clique no interior da tabela e use as setinhas para cima e para baixo de seu
teclado para navegar nos registros. O atributo useKeys do componente tablePane é que habilita esta
funcionalidade.
Agora que temos a tabela com nossos registros, não seria interessante se pudéssemos clicar em um
deles e modifica-lo? Para fazer isto, precisamos, primeiro, definir um formulário e para isto, coloque logo depois
da tag final do tablePane o seguinte trecho de código:
<spacer width="15px"/>
<dataController id="myController" modelClass="Agenda.Contato" onsave="zenPage.getCom
ponentById('myTable').refreshContents();" ondelete="zenPage.getComponentById('myTabl
e').refreshContents();"/>
<fieldSet legend="Contato:" valign="top" layout="horizontal">
<form controllerId="myController" layout="vertical">
<text dataBinding="Nome" label="Nome:"/>
<text dataBinding="Telefone" label="Telefone:"/>
<text dataBinding="EMail" label="EMail:"/>
</form>
</fieldSet>
Adicionamos um componente dataController que também tem um id (myController) que servirá para
interagir com este componente depois. Em seguida, definimos a classe que a nossa classe Agenda.Contato
servirá de fonte de dados (atributo modelClass) e também definimos implementações para os eventos onsave e
ondelete do controller. Estas implementações definem que toda vez que alguém pedir a este controller para
Preparando o Caché para Nossos Estudos  101
salvar ou para apagar um objeto, temos que atualizar o conteúdo da tabela. É a primeira vez que você vê um
componente fazendo referencia ao outro e, para isto, usamos um pouco de javascript!
No evento onsave, por exemplo, pedimos ao objeto que representa toda a nossa página Zen (objeto
zenPage) que nos devolva o componente myTable (getComponentById) e sobre este componente (myTable),
chamamos o método refreshContents. É simples não? O método getComponentById do objeto zenPage é o
método mais usado em qualquer aplicação Zen!
Além do dataController, também adicionamos um fieldSet, que simplesmente desenha uma caixa ao
redor de nosso formulário e, finalmente, o formulário propriamente dito. Observe que o formulário tem um atributo
controllerId que aponta para o nosso dataController de forma que agora o nosso novo formulário mostrará o que
o componente dataController definir.
Uma vez conectado o formulário ao dataController, podemos definir dentro do formulário os campos que
nos interessam mostrar. Cada campo (componente text) está conectado com uma das propriedades de nossa
classe Agenda.Contato graças à propriedade dataBinding.
Agora temos de um lado o nosso componente tablePane que pode navegar livremente pelos registros
de nossa classe Agenda.Contato e por outro um formulário conectado a um dataController pronto para mostrar os
dados de nossos registros. Como conectamos os dois de forma que ao selecionar uma linha de nossa tabela, os
dados do registro selecionado apareçam no nosso formulário?
Basta com adicionar ao nosso componente tablePane dois novos atributos:
<tablePane id="myTable" tableName="Agenda.Contato" useKeys="true" valign="top"
valueColumn="ID" onselectrow="zenPage.getComponentById('myController').setModelId(ze
nThis.getValue())">
O atributo valueColumn especifica que ao selecionar uma linha da tabela, a coluna que o componente
tomará como dado representativo do registro selecionado é a coluna ID. O atributo onselectrow permite
especificar um código javascript que será executado sempre que o usuário selecionar (com o mousse ou teclado)
uma linha da tabela. Neste caso, escrevemos código para chamar o método setModelId() de nosso dataController
e, para obter o ID do objeto selecionado, pedimos para o componente tablePane o valor atual da tabela (por isto
devemos especificar o atributo valueColumn). Simples não?
Agora está tudo conectado! Você já deveria ser capaz de compilar e executar esta página, selecionar
alguns registros usando o teclado ou o mouse e ver os dados do registro selecionado aparecerem no formulário
automaticamente.
3.7.3 Incluir, Excluir e Alterar
Agora que podemos navegar livremente, vamos implementar a funcionalidade restante para permitir
incluir, excluir e alterar contatos de nossa agenda simples. Para tanto, vamos criar os botões para fazer isto e
código javascript adicional para conectar estes botões ao dataController.
102  Preparando o Caché para Nossos Estudos
Para simplificar e concluir, abaixo segue o código completo da página:
1. /// Created using the page template: Title Page
2. Class Agenda.UI.Contato Extends %ZEN.Component.page
3. {
4.
/// Class name of application this page belongs to.
5.
Parameter APPLICATION = "Agenda.UI.Application";
6.
7.
/// Displayed name of this page.
8.
Parameter PAGENAME = "Agenda de Contatos";
9.
10. /// Domain used for localization.
11. Parameter DOMAIN = "Agenda";
12.
13. /// This Style block contains page-specific CSS style definitions.
14. XData Style
15. {
16.
<style type="text/css">
17.
/* style for title bar */
18.
#title {
19.
background: #C5D6D6;
20.
color: black;
21.
font-family: Verdana;
22.
font-size: 1.5em;
23.
font-weight: bold;
24.
padding: 5px;
25.
border-bottom: 1px solid black;
26.
text-align: center;
27.
}
28.
</style>
29. }
30.
31. /// This XML block defines the contents of this page.
32. XData Contents [ XMLNamespace = "http://www.intersystems.com/zen" ]
33. {
34. <page xmlns="http://www.intersystems.com/zen" title="Agenda de Contatos">
35. <html id="title">Agenda de Contatos</html>
36. <vgroup width="100%">
37. <spacer height="5px"/>
38. <hgroup>
39.
40. <spacer width="5px"/>
41. <tablePane id="myTable" tableName="Agenda.Contato" valueColumn="ID" useKeys=
"true" valign="top" onselectrow="zenPage.getComponentById('myController').set
ModelId(zenThis.getValue())">
42. <column colName="ID" hidden="true"/>
43. <column colName="Nome" header="Nome" filterType="text"/>
44. <column colName="Telefone" header="Telefone" filterType="text"/>
45. <column colName="EMail" header="EMail" filterType="text"/>
46. </tablePane>
47.
48. <spacer width="15px"/>
49.
Preparando o Caché para Nossos Estudos  103
50. <dataController id="myController" modelClass="Agenda.Contato" onsave="zenPag
e.getComponentById('myTable').refreshContents();" ondelete="zenPage.getCompon
entById('myTable').refreshContents();"/>
51.
52. <fieldSet legend="Contato:" valign="top" layout="horizontal">
53. <form controllerId="myController" layout="vertical">
54. <text dataBinding="Nome" label="Nome:"/>
55. <text dataBinding="Telefone" label="Telefone:"/>
56. <text dataBinding="EMail" label="EMail:"/>
57.
58. <hgroup>
59. <button caption="Apagar" onclick="zenPage.deleteButton()"/>
60. <spacer width="50px"/>
61. <button caption="Salvar" onclick="zenPage.getComponentById('myController').sa
ve();"/>
62. <button caption="Novo"
onclick="zenPage.getComponentById('myController'
).createNewObject();"/>
63. </hgroup>
64.
65. </form>
66. </fieldSet>
67. </hgroup>
68. </vgroup>
69. </page>
70. }
71.
72. ClientClassMethod deleteButton() [ Language = javascript ]
73. {
74.
var controller = zenPage.getComponentById('myController');
75.
controller.deleteId(controller.getModelId());
76.
controller.createNewObject();
77. }
Observe que entre as linhas 58 e 63, adicionamos os botões para Apagar, Salvar e criar um Novo
contato em nossa agenda simples. Os eventos onclick dos botões Salvar e Novo são autoexplicativos. O evento
onclick do botão Apagar é diferente pois chama um método que executa todo o trabalho. Este método está
definido entre as linhas 72 e 77. Neste método, obtemos o controller e pedimos a ele que apague o objeto e crie
um novo.
Nada mais é necessário pois o componente dataController atualizará o formulário e a tabela
automaticamente! Poderíamos implementar um pouco mais de código javascript para mostrar algumas
mensagens ao usuário como “Contato excluído!” e etc., mas estes detalhes fogem ao objetivo deste capítulo que
já está bastante extenso.
3.7.4 Conclusão
Só usamos alguns dos componentes do Zen, que possui uma biblioteca bastante vasta, suporte a
gráficos SVG (Scalable Vector Graphics), multi-idiomas, acesso simples e direto à base de dados do Caché
(SQL, Objetos e acesso direto) e é totalmente baseado em padrões W3C e, por isto, não necessita plugins para
104  Preparando o Caché para Nossos Estudos
funcionar em todos os principais navegadores (inclusive navegadores móveis como o Safari para iPad ou
iPhone).
O Zen também permite a construção de relatórios que podem ser abertos como PDF, HTML ou XML e
está totalmente integrado ao modelo de segurança e controle de acesso do Caché que veremos em capítulos
futuros. Em resumo, todos os recursos do Caché estão disponíveis naturalmente para o Zen e tudo isto junto
permite a construção de aplicações corporativas muito rapidamente, sem abdicar de coisas importantes como
desempenho, segurança, flexibilidade e disponibilidade em varias plataformas Web distintas (IE, FireFox, Safari,
Opera, etc.).
3.8 Consultando a Documentação do Caché
Aprendemos bastante coisa neste capítulo. Não só aprendemos bastante sobre como usar as principais
ferramentas do Caché, como também um pouco de Caché Object Script, SQL e Caché Server Pages! Agora que
você já se sente um pouco mais a vontade, é provável que queira saber onde pode conseguir mais informações e
é por isto que vou tomar um tempo para apresentar a documentação on-line do Caché.
Se você clicar no Cubo do Caché > Documentação, verá que um navegador se abrirá mostrando o
índice da documentação on-line do Caché. Abaixo, segue uma lista de tópicos bastante interessante da
documentação que podem ser consultados após a leitura deste capítulo:
Tabela 3-5 – Tópicos de Interesse da Documentação do Caché
Introduction to Caché
Agora que você terminou este capítulo do livro, leia este tópico da documentação para
ter uma visão geral dos vários recursos do Caché. Não é uma leitura obrigatória, mas é
interessante.
Caché Development References
Aqui você vai encontrar
o
A documentação de todos os comandos da linguagem Caché Object Script (Caché
Object Script Reference)
o
A documentação de todos os comandos da linguagem SQL que são suportados
pelo Caché (Caché SQL Reference)
o
A documentação de todos os possíveis erros que o Caché pode emitir, com uma
breve descrição de suas causas (Caché Error Reference)
o
A documentação da linguagem de definição de classes do Caché, usada, por
exemplo, quando definimos nossa classe Agenda.Contato no Caché Studio
(Caché Class Definition Reference)
Caché Tutorials
Trataremos de muitos assuntos neste livro, mas quem sabe você encontre alguns
tutoriais neste tópico que não são cobertos por este livro. Dê uma olhada e veja os
tutoriais que existem!
Preparando o Caché para Nossos Estudos  105
Como você deve ter notado, existe um campo para fazer buscas na documentação. Simplesmente entre
com as palavras que você está buscando e o Caché retornará uma lista de tópicos de toda a documentação que
contenha todas as palavras passadas como argumento da pesquisa.
106  Preparando o Caché para Nossos Estudos