Curso

DELPHI6 e tecnologias de bancos de dados
DELPHI 6
E tecnologias de bancos de dados
Esta apostila foi criada recuperando informaes de diversas fontes. Porm, algumas merecem ser citadas tanto por sua importncia como material de referncia, como por terem sido usadas extensivamente na montagem dos textos desta apostila: Borland Delphi 5 Developers Guide. Editado pela Borland. Borland Delphi 6 Developers Guide. Editado pela Borland. Object Pascal Language Reference. Editado pela Borland. Borland Delphi 6 Quick Start. Editado pela Borland.
Diversos trechos destas obras foram traduzidos e adaptados para o contexto desta apostila. Todos os direitos referentes a estas obras so de propriedade da Borland Corporation. proibida a comercializao desta apostila.
Delphi 6.0 e tecnologias de bancos de dados

Parte I - Delphi, Kylix e o Object Pascal
CAPTULO 1 - VISO GERAL ............................................................................................ 15 O que o Delphi? ............................................................................................................ 16 Aplicativos Windows e aplicativos Linux..............................................................................................16 Tipos de aplicativos ............................................................................................................................16 Suporte a tecnologias.........................................................................................................................17 Verses do Delphi...............................................................................................................................18 Delphi.NET .........................................................................................................................................18 O que o Kylix? .............................................................................................................. 19 Escolhendo uma linguagem de desenvolvimento................................................................................19 Tipos de aplicativos ............................................................................................................................20 Suporte a tecnologias.........................................................................................................................20 Verses do Kylix .................................................................................................................................21 CAPTULO 2 - O AMBIENTE DELPHI ................................................................................. 22 O ambiente Delphi........................................................................................................... 23 A Janela Principal ...............................................................................................................................23 O Editor de Cdigo (Code Editor).......................................................................................................24 O Object Inspector .............................................................................................................................24 O Object Treeview..............................................................................................................................25 A Palheta de Componentes ................................................................................................................26 O Object Repository ...........................................................................................................................27 O Project Manager .............................................................................................................................28 Organizao do programa ............................................................................................... 29 Arquivos fontes pascal........................................................................................................................29 Outros arquivos de aplicaes ............................................................................................................29 Arquivos gerados pelo compilador......................................................................................................30 Uma simples aplicao console...........................................................................................................30 Alguns recursos importantes da IDE ................................................................................ 30 Encaixe de janelas (Dock) ..................................................................................................................31 Preenchimento de classes ..................................................................................................................31 Navegao entre sees de interface e implemntation.......................................................................32 AppBrowser........................................................................................................................................32 TO-DO List..........................................................................................................................................33 Code Insight.......................................................................................................................................33 CAPTULO 3 CONHECENDO O OBJECT PASCAL............................................................... 34 Programao orientada a objetos.................................................................................... 35 Orientao a objeto............................................................................................................................35 O Object Pascal .............................................................................................................. 36 O que um objeto? ...........................................................................................................................37 3
Classes, objetos e componentes .........................................................................................................37 Programao estruturada e syntax.................................................................................. 38 Unidades estruturadas e syntax..........................................................................................................38 A seo Interface ...............................................................................................................................39 A seo Implementation.....................................................................................................................39 A seo Initialization...........................................................................................................................39 A seo Finalization ............................................................................................................................40 Referncias circulares.........................................................................................................................40 Identificadores, diretivas, palavras-chaves ...................................................................... 41 Diretivas .............................................................................................................................................41 CAPTULO 4 - TIPOS DE DADOS E ESTRUTURAS ............................................................... 43 Classificao................................................................................................................... 44 Simples...............................................................................................................................................44 Tipos subrange...................................................................................................................................44 Tipos real ...........................................................................................................................................44 Tipos string ........................................................................................................................................45 Tipo Boolean ......................................................................................................................................45 Tipos estruturados..............................................................................................................................45 Conjuntos (sets) .................................................................................................................................46 Arrays.................................................................................................................................................46 Arrays dinmicos ................................................................................................................................47 Records ..............................................................................................................................................47 Tipos variant.......................................................................................................................................48 Tipo OleVariant ..................................................................................................................................48 Converses de tipos ........................................................................................................ 49 Converses implcitas e explcitas .......................................................................................................50 Trabalhando com strings................................................................................................. 50 Concatenando strings.........................................................................................................................51 Manipulando strings ...........................................................................................................................52 Copiando strings.................................................................................................................................52 Inserindo strings ................................................................................................................................53 Deletando strings ...............................................................................................................................53 Formatando strings ............................................................................................................................53 Mais sobre strings...............................................................................................................................54 Trabalhando com datas................................................................................................... 54 Dias, meses, anos...............................................................................................................................55 Interpretando horas ...........................................................................................................................56 CAPTULO 5 - PROCEDIMENTOS E FUNES .................................................................... 58 Procedimentos e funes................................................................................................. 59 Diferenciando procedimentos e funes.............................................................................................59 Conhecendo procedimentos e funes .............................................................................. 59 Declaraes de procedimentos ...........................................................................................................60 Declaraes de funes......................................................................................................................60 Overloading de procedimentos e funes...........................................................................................61 Valor padro de parmetros...............................................................................................................62
CAPTULO 6 - OBJETOS E CLASSES .................................................................................. 63 Tipo de Classe ( class type ) .............................................................................................. 64 Campos de tipos.................................................................................................................................64 TObject e TClass ............................................................................................................. 65 Visibilidade de membros de classes.................................................................................. 66 Campos .......................................................................................................................... 68 Mtodos ......................................................................................................................... 68 Declaraes e implementaes de mtodos .......................................................................................69 Inherited ........................................................................................................................ 69 Self ................................................................................................................................ 69 Tipos de mtodos ...............................................................................................................................70 Mtodos estticos ...............................................................................................................................70 Mtodos virtuais .................................................................................................................................71 Mtodos dinmicos .............................................................................................................................71 CAPTULO 7 - CONHECENDO A VCL E A CLX...................................................................... 72 Bibliotecas de classes no Delphi 6 .................................................................................... 73 Conhecendo a VCL........................................................................................................... 73 Classes razes da VCL .........................................................................................................................74 TObject ..............................................................................................................................................74 TPersistent .........................................................................................................................................75 TComponent.......................................................................................................................................75 TControl .............................................................................................................................................76 TWinControl .......................................................................................................................................76 TGraphicCotrol ...................................................................................................................................76 Classes de manipulao de excees................................................................................ 77 Conhecendo a CLX........................................................................................................... 78 Obtendo compatibilidade entre Delphi e Kylix ....................................................................................78 Amplo suporte ao desenvolvimento WEB e banco de dados...............................................................79 Diferenas tecnolgicas bsicas entre a VCL e a CLX......................................................... 79 CAPTULO 8 - TAREFAS COMUNS DE PROGRAMAO ....................................................... 81 Trabalhando com listas de strings.................................................................................... 82 As classes Tstrings e TStringList.........................................................................................................82 Usando listas de strings com arquivos................................................................................................82 Contando strings na lista....................................................................................................................83 Acessando uma string em particular ..................................................................................................83 Movendo uma string dentro da lista ...................................................................................................83 Deletando uma string da lista.............................................................................................................84 Copiando uma lista completa de strings.............................................................................................84 Manipulando Excees .................................................................................................... 84 Excees e o controle de fluxo ...........................................................................................................84 Try ... Exception .................................................................................................................................86 5
Que tipo de recursos proteger?..........................................................................................................86 Manipulando classes de excees .................................................................................... 87 Definindo suas prprias excees.......................................................................................................88 Guardando informaes na Registry e em arquivos .ini ..................................................... 89 A classe TRegistry ..............................................................................................................................89 A classe TIniFile .................................................................................................................................91 A classe TRegistryIniFile.....................................................................................................................92 Estudando o objeto TForm .............................................................................................. 92 Janelas e formulrios no Win32..........................................................................................................92 Mtodos de acesso e destruio .........................................................................................................93 Tipos de formulrios...........................................................................................................................95 O objeto TFrame ................................................................................................................................95 Construindo a interface com o usurio ............................................................................. 96 Action Lists .........................................................................................................................................96 Centralizando cdigo com listas de aes...........................................................................................97 Executando aes...............................................................................................................................97 Atualizando aes...............................................................................................................................98 Aes pr-definidas ............................................................................................................................98 Desenvolvendo menus..................................................................................................... 98 O Menu Designer................................................................................................................................99 Menus estilo Windows 2000 e XP........................................................................................................99 Outras barras de ferramentas ..........................................................................................................100 Trabalhando com arquivos .............................................................................................101 Tipos de arquivos .............................................................................................................................101 Usando arquivos texto ......................................................................................................................101 Criando um editor de texto funcional ...............................................................................................102 Controles de edio de texto ............................................................................................................102 O projeto MemoEdit .......................................................................................................102 Inserindo um ActionManager ...........................................................................................................102 Desenhando as barras de ferramentas e menus ..............................................................................103 Exibindo informaes sobre as funcionalidades de MemoEditor .......................................................104 Editando textos.................................................................................................................................105 Salvando os dados em arquivo .........................................................................................................107 Inserindo uma tela de crditos (About) .........................................................................................108 Inserindo o cone da aplicao na tela About ................................................................................109 Trabalhando com imagens e desenhos ............................................................................114 Usando TCanvas como uma superfcie de desenho..........................................................................114 Tipos de objetos grficos................................................................................................114 Conhecendo TImage ........................................................................................................................115 Criando um aplicativo de desenho funcional ....................................................................115 O projeto do aplicativo .....................................................................................................................115 Implementando os recursos de manipulao de arquivos ................................................................116 Implementando recursos de trabalho com imagens.........................................................................116 Implementando recursos de desenho...............................................................................................116 Informaes de arquivos ..................................................................................................................116 Tcnicas avanadas de trabalho com grficos .................................................................116 Espectros de cores ...........................................................................................................................116 6
Rotacionando imagens .....................................................................................................................117 Invertendo imagens .........................................................................................................................117 CAPTULO 9 - TECNOLOGIAS DE ACESSO A FONTES DE DADOS ........................................119 Tipos de bancos de dados e acessos................................................................................120 Tipos de bancos de dados...............................................................................................120 Bancos de dados locais.....................................................................................................................121 Servidores de bancos de dados remotos ..........................................................................................121 Arquiteturas de aplicaes de bancos de dados ...............................................................121 Pensando em escalabilidade.............................................................................................................122 Aplicaes de uma camada ..............................................................................................................123 Aplicaes de duas camadas ............................................................................................................123 Aplicaes multi-camadas ................................................................................................................124 A evoluo das arquiteturas de acesso............................................................................125 Terminais burros e aplicativos Desktop.............................................................................................125 Aplicativos Client/Server ...................................................................................................................126 Aplicativos distribudos .....................................................................................................................127 Por que escrever aplicaes distribudas?........................................................................128 A tecnologia DataSnap .....................................................................................................................128 Entendendo aplicaes que acessam providers ................................................................................129 Os protocololos da DataSnap..........................................................................................129 COM, DCOM e COM+ .......................................................................................................................130 CORBA .............................................................................................................................................131 TCP/IP (Sockets) ..............................................................................................................................132 HTTP (WEB) .....................................................................................................................................133 Entendendendo datasets ................................................................................................134 O que um TDataset? .....................................................................................................................134 Famlias de datasets .........................................................................................................................134 Tipos de datasets .............................................................................................................................135 CAPTULO 10 - TRABALHANDO COM A BDE .....................................................................138 Conhecendo a BDE .........................................................................................................139 Drivers usados pelo BDE...................................................................................................................139 O BDE Administrator ........................................................................................................................140 Suporte Delphi a aplicaes BDE.....................................................................................140 Datasets baseados em BDE ..............................................................................................................140 Mtodos de TDatabase e TSession....................................................................................................141 Recursos avanados do BDE ...........................................................................................141 CACHING BLOBs...............................................................................................................................142 Obtendo um handle BDE..................................................................................................................142 Manipulando transaes ...................................................................................................................142 Usando passthroug SQL ...................................................................................................................143 Usando transaes locais..................................................................................................................143 Ferramentas de trabalho com a BDE ...............................................................................143 O futuro da BDE .............................................................................................................145 7
Acesso a dados para tabelas locais...................................................................................................145 CAPTULO 13 - APLICAES BASEADAS EM ADO .............................................................147 A arquitetura ADO..........................................................................................................148 Tecnologia OLEDB ............................................................................................................................149 Conhecendo a interface ADO ...........................................................................................................149 Conhecendo a ADOExpress ..............................................................................................................150 Conectando com fontes de dados ADO ............................................................................151 TADOConnection x Connection string...............................................................................................152 Logins e timeout...............................................................................................................................153 Transaes em ADO .......................................................................................................153 Usando mtodos de transaes ........................................................................................................154 Usando eventos de transao...........................................................................................................154 Trabalhando com comandos...........................................................................................154 Especificando o comando .................................................................................................................155 Usando o mtodo Execute................................................................................................................155 Cancelando comandos......................................................................................................................155 Retornando dados com comandos....................................................................................................156 ADO.NET .......................................................................................................................156 A arquitetura ADO.NET ....................................................................................................................157 Datasets ADO.NET............................................................................................................................157 Provedores de dados .NET................................................................................................................158 CAPTULO 14 - APLICAES INTERBASE EXPRESS ..........................................................159 A arquitetura Interbase Express .....................................................................................160 Conhecendo a IBX............................................................................................................................160 Herana baseada em TDataset.........................................................................................................161 Datasets unidirecionais.....................................................................................................................162 Extensibilidade da arquitetura IBX ...................................................................................................162 Compatibilidade inter-plataformas .................................................................................173 Conectando com bancos de dados Interbase/Firebird......................................................174 Transaes no Interbase................................................................................................174 Usando o TIBTransaction .................................................................................................................175 Nveis de isolamento de transaes ..................................................................................................175 Trabalhando com comandos...........................................................................................176 O componente TIBSQL.....................................................................................................................176 Executando comandos......................................................................................................................177 Controlando um servidor Interbase.................................................................................177 A InterbaseAdmin ............................................................................................................................177 CAPTULO 15 - APLICAES BASEADAS NA DBEXPRESS ..................................................180 A arquitetura DBExpress ................................................................................................181 Como trabalha a DBExpress?............................................................................................................181 Tipos de datasets unidirecionais.......................................................................................................181 8
Conectando com um servidor SQL...................................................................................182 Configurando o objeto TSQLConnection ...........................................................................................182 Identificando o driver .......................................................................................................................182 Especificando parmetros de conexo..............................................................................................183 Nomeando uma descrio de conexo .............................................................................................183 Especificando quais dados exibir.....................................................................................184 Representando o resultado de uma consulta....................................................................................184 Representando os registros em uma tabela......................................................................................184 Representando uma tabela usando TSQLTable ................................................................................185 Representado os resultados de uma stored procedure .....................................................................185 Obtendo os dados ..........................................................................................................186 Preparando o dataset .......................................................................................................................186 Transferindo dados de mltiplos datasets ........................................................................................186 Executando comandos ...................................................................................................187 Mtodos de execuo .......................................................................................................................187 CAPTULO 16 - APLICAES COM PROVEDORES E DATASETS CLIENTES ..........................188 A arquitetura dos datasets clientes .................................................................................189 Estudando TClientDataset ..............................................................................................189 Editando dados.................................................................................................................................189 Desfazendo alteraes......................................................................................................................190 Salvando as alteraes .....................................................................................................................191 Indexando colunas com TClientDataset ..........................................................................191 Adicionando um novo ndice.............................................................................................................192 Excluindo e alternando ndices .........................................................................................................192 Campos calculados e agregados .....................................................................................192 Campos internamente calculados .....................................................................................................193 Usando campos agregados...............................................................................................................193 Copiando dados de outros datasets ................................................................................194 Assinalando dados diretamente........................................................................................................194 Clonando um cursor de dados..........................................................................................................195 Manipulando TClientDataset com um provedor de dados .................................................195 Especificando um provedor de dados ( data provider ).......................................................196 Obtendo parmetros da aplicao servidora....................................................................196 Pasando parmetros para a aplicao servidora..............................................................197 Enviando consultas ou parmteros de procedimentos armazenados ................................................197 Limitando registros com parmetros ................................................................................................197 Sobrescrevendo o resultset de um provedor de dados ......................................................197 Requisitando dados de uma aplicao servidora ..............................................................................198 Manipulando constries ................................................................................................199 Manipulando constries do servidor de dados.................................................................................199 Adicionando constries personalizadas ...........................................................................................200
Atualizando registros em um servidor .............................................................................200 Gravando as alteraes ....................................................................................................................201 Reconciliando erros de alteraes ...................................................................................201 Atualizaes em uma s tabela ........................................................................................................201 Atualizaes em dados com joins .....................................................................................................202 TClientDataset com dados baseados em arquivos............................................................202 O que o modelo porta-arquivos? (briefcase) .................................................................................203 Carregando dados de um arquivo ou stream ...................................................................................203 Salvando dados em um arquivo ou stream.......................................................................................203 Outros datasets clientes.................................................................................................204 TBDEClientDataset............................................................................................................................204 TIBClientDataset...............................................................................................................................204 TSQLClientDataset............................................................................................................................205 CAPTULO 17 USANDO PROVEDORES DE DADOS ..........................................................206 Determinando a fonte dos dados ....................................................................................207 Usando um dataset como fonte de dados ........................................................................................207 Usando um documento XML como fonte de dados...........................................................................207 Comunicando-se com um dataset cliente ........................................................................207 Como aplicar atualizaes com um TDatasetProvider ......................................................208 Controlando as informaes em um pacote de dados.......................................................208 Especificando os campos que sero inclusos ....................................................................................208 Opes que influenciam os pacotes de dados ..................................................................................209 Informaes personalizadas em pacotes ..........................................................................................209 Respondendo a requisies de datasets clientes ..............................................................210 Respondendo a atualizaes de datasets clientes ............................................................210 Resolvendo erros de atualizaes no provider ..................................................................................210 Respondendo a eventos gerados nos clientes...................................................................................211 CAPTULO 18 - TRABALHANDO COM O COMPONENTE TFIELD ..........................................212 A arquitetura dos componentes fields .............................................................................213 Criando um novo objeto TField.........................................................................................................214 Campos calculados ...........................................................................................................................214 Campos Lookup ................................................................................................................................215 Campos Agregados...........................................................................................................................215 Configurando propriedades de TField ..............................................................................215 Conjuntos de atributos e mscaras...................................................................................................216 Manipulando eventos .....................................................................................................217 Mtodos de componentes fields ......................................................................................218 Converses de valores de campos...................................................................................218 Acessando valores de campos.........................................................................................219 Acessando valores de componentes field..........................................................................................220 10
Conferindo o valor corrente de um field...........................................................................................220 Constries de componentes fields .................................................................................221 Constries de servidores SQL..........................................................................................................221 Constries personalizadas ...............................................................................................................221 Descendentes complexos de TField .................................................................................222 Usando campos de objetos...............................................................................................................222 Trabalhando com fields ADT ............................................................................................................222 Trabalhando com TArray Field .........................................................................................................223 CAPTULO 19 - CRIANDO UMA APLICAO DESKTOP ......................................................225 Projeto de aplicao Desktop .........................................................................................226 Bancos de dados locais.....................................................................................................................226 Usando ADOExpress como mecanismo de acesso.............................................................................226 Modelo de dados ..............................................................................................................................227 Iniciando o desenvolvimento do aplicativo ......................................................................227 Criando um novo projeto..................................................................................................................227 Mdulos de dados.............................................................................................................................228 Trabalhando com um mdulo de dados ...........................................................................229 Conectando com o banco MS Acess .................................................................................................229 Inserindo datasets para acesso aos dados........................................................................................230 CAPTULO 20 - CRIANDO APLICAES CLIENT/SERVER ..................................................233
Introduo ao modelo cliente/servidor ...........................................................................234 Arquitetura cliente/servidor ..............................................................................................................234 Primeira gerao cliente/servidor .....................................................................................................235 Segunda gerao cliente/servidor ....................................................................................................235 SGDB - Sistemas gerenciadores de banco de dados..........................................................236 Modelos de banco de dados .............................................................................................................236 Sistema de gerenciamento de arquivos............................................................................................237 Banco de Dados Hierrquico ............................................................................................................237 Banco de dados de rede...................................................................................................................238 Banco de dados relacional................................................................................................................239 A linguagem SQL..............................................................................................................................240 Categorias da Linguagem SQL..........................................................................................................240 Consistncia e integridade dos dados...............................................................................................241 Integridade Referencial ....................................................................................................................241 Integridade Referencial Declarativa..................................................................................................242 Triggers............................................................................................................................................242 Domnio dos dados ...........................................................................................................................242 Regras de Negcio ...........................................................................................................................243 Distribuio da consistncia e integridade dos dados.......................................................................243 Trabalhando com Bancos de Dados Relacionais ...............................................................243 Componentes da arquitetura cliente/servidor - dlsf..........................................................................244 Projetando Aplicaes Cliente/Servidor ..........................................................................244 Estrutura de uma Aplicao .............................................................................................................245 Vantagens da organizao da aplicao em camadas ......................................................................246 Construindo Aplicaes Cliente/Servidor...........................................................................................246 Utilizando Interbase Express ............................................................................................................248 11
Componente TIBDatabase................................................................................................................249 Projeto de interface do software ......................................................................................................250 Trabalhando com o TQuery..............................................................................................................250 CAPTULO 21 - CRIANDO APLICAES MULTI-CAMADAS ................................................253 Escrevendo aplicaes distribudas .................................................................................254 Modelos de thread e instanciao de objetos...................................................................254 Mdulos de dados remotos...............................................................................................................254 Instanciao nica............................................................................................................................254 Instanciao interna.........................................................................................................................254 Instanciao mltipla .......................................................................................................................254 Modelo de thread simples.................................................................................................................254 Modelo de thread Apartment............................................................................................................254 Modelo de thread livre......................................................................................................................254 Modelo de thread neutro..................................................................................................................254 Modelos de thread em CORBA.........................................................................................254 Modelo de thread simples.................................................................................................................254 Modelo de thread mltiplo................................................................................................................254 CAPTULO 22 - CRIANDO UMA APLICAO PORTA-ARQUIVOS.........................................256
12
SGDB - Sistemas Gerenciadores de Banco de Dados
CURSO I DELPHI 6.0 E TECNOLOGIAS DE BANCOS DE DADOS
13
PARTE I DELPHI, KYLIX E O OBJECT PASCAL
Na primeira parte deste programa veremos as caractersticas fundamentais do ambiente Delphi e uma descrio detalhada dos fundamentos da linguage Object Pascal. Este programa no abrange o estudo do Borland Kylix, o novo ambiente da Borland de desenvolvimento para a plataforma Linux, mas como ele completamente baseado no Object Pascal e totalmente compatvel com o Delphi 6.0, faremos meno constatnte a este novo ambiente em muitos captulos. Uma vez que o programador tenha se introduzido suficientemente na programao em Object Pascal, poder livremente usar tanto o Delphi como o Kylix, conforme suas necessidades. Mais do que isto, poder portar seus aplicativos - com virtualmente nehuma mudana no cdigo-fonte - para a plataforma Linux. O princpio bsico de compreenso da programao orientada a objetos um dos aspectos mais importantes para o desenvovedor que se aproxima do Object Pascal (em sua verso Windows ou Linux). Afirmamos que possivelmente esta a caractersticaas mais forte da programao nestes ambientes. Todo o contedo programtico baseado na verso 6.0 do Borland Delphi.
14
CAPTULO 1 - VISO GERAL

Este captulo tem como objetivo apresentar o ambiente de desenvolvimento do Delphi. Tambm abordado como o Delphi se torna compatvel com o Kylix, bem como os tipos de aplicativos que voc pode criar com o Delphi 6.0. Finalamente, voc poder entender o suporte a tecnologias disponveis no Delphi, bem como as diferenas existentes neste aspecto com relao ao ambiente Kylix.
15
O que o Delphi?
O Borland Delphi um ambiente de desenvolvimento de aplicaes Windows bastante complexo e abrangente. Ao mesmo tempo, possui muitas caractersticas que o tornam uma ferramenta RAD (rapid application development). O que tem tornado o Delphi uma ferramenta preferencial para muitos justamente esta combinao de poder e facilidade, bem como um elemento que lhe nico: a existncia de um puro compilador assembler muito avanado e de altssimo desempenho. Na prtica, isto significa o desenvolvimento de aplicaes mais rpidas, um ambiente de desenvolvimento muito mais produtivo, possibilidade de usar-se diretamente cdigo assembler (de compilao extrememamente veloz) em seu cdigo-fonte e muito mais. Desde o lanamento do Delphi, seu compilador tem ganhado todos os testes de avaliao, superando at mesmo os mais rpidos compiladores C. Este fato resultou na sua adoo como medida de comparao nos testes entre outros compiladores; algo semelhante ao que acontece hoje em dia com as cotaes de moedas, sempre medidas tendo como relao o dlar norte-americano. Mas o Delphi bem mais que um compilador potente. Os programadores Delphi sabem que tm estado constantemente sempre na vanguarda das tecnologias Windows (e agora Linux). O Delphi, de fato, tem colocado o Windows de joelhos, como demonstra os recentes acordos entre a Microsoft e a Borland, reconhecendo o Delphi como ambiente de desenvolvimento prioritrio de aplicativos para o sistema operacional da Microsoft. A prpria Borland tem sido, em parte, responsvel direta pela introduo de alguns das mais recentes novidades lanadas no Windows 2000 em diante, como o desenvolvimento da arquitetura dos novos servios WEB (WebServices), a portabilidade da tecnologia XML para estes servios (.NET), servios DataSnap para COM+ e MTS e outras tecnologias. Estes acordos reconhecem a Borland como parceira no desenvolvimento de tecnologias para o sistema operacional Windows. Quanto a tudo isto, possvel encontrar uma grande massa de informaes nos sites da Borland e da Microsoft, bem como em muitos sites de programao Delphi.
Aplicativos Windows e aplicativos Linux O Delphi est ligado plataforma Windows. Todo o seu ambiente e ferramentas, bem como a sua bibliotaca de objetos (VCL) so construdos tendo como base a API do Windows. O seu compilador incapaz de gerar aplicativos para outras plataformas. Contudo, o Delphi 6.0 possui a biblioteca de objetos CLX, que pode ser usada para a construo de aplicativos multi-plataformas, sendo a mesma comum ao Delphi 6.0 e ao Kylix. possvel, ento, construir um aplicativo CLX no Delphi e gerar um aplicativo Windows e, depois, pegar os mesmos cdigos-fontes e compil-los no Kylix, gerando assim um aplicativo Linux. A Borland poderia, simplesmente, colocar disposio dos desenvolvedores o compilador Kylix para executar esta tarefa, mas talvez por razes comerciais criou o ambiente Kylix completo. Como conseqncia desta estratgia, podemos ver em pginas na Internet e mdia publicitria que o Kylix tem ganhado todos os prmios de melhor ferramenta de desenvolvimento para a plataforma Linux.
Tipos de aplicativos O sistema operacional Windows suporta trs tipos bsicos de aplicaes: Aplicaes Windows GUI; Aplicaes Console; Aplicaes de Servios.
Voc pode criar qualquer um destes tipos de aplicaes com o Delphi. 16
As aplicaes GUI (Graphic user interface) do Windows talvez sejam as mais conhecidas, porque possuem uma aparncia grfica. O prprio Delphi se enquadra neste tipo de aplicao bem como o Windows Explorer ou o Bloco de Notas. Evidentemente, dentro deste tipo de aplicao existem muitas com funes extremamente diversificadas ou, ainda, aquelas que incorporam objetos em seu ambiente (como objetos COM ou derivados). Qunado voc escolhe a criao de um novo aplicativo VCL (File|New Application) est criando um destes aplictivos. As aplicaes console so executveis 32bits que so ativados atravs de comandos, como na linha de comando ou na tela Executar do Windows. Aplicaes console so extremamente numerosas no ambiente Windows, e voc executa diversas vezes algumas delas ao longo de um tempo trabalhando em seu computador. Para criar um aplicativo console, escolha File | New e, na janela que se abre. Seleciona o cone Console Wizard. Aplicaes de servios so, talvez, as mais misteriosas para o susurio comum. Consistem, basicamente, em servidores que executam requisies de programas clientes e retornam a eles informaes. Estas aplicaes rodam tipicamente em background, sem muita ao do usurio. Um servidor WEB, FTP ou POP so alguns dos exemplos de aplicaes de servios. Para criar uma destas aplicaes, escolha File | New | Items. Na janela que se abre, escolha o cone Service Application. Apesar das caractersticas bastante diversificadas de cada um destes tipos de aplicaes, voc as desenvolve sempre da mesma maneira no ambiente Delphi, em um ambiente grfico, usando abordagens prprias de linguagens orientadas a objetos e com grande reaproveitamento de cdigo.
Suporte a tecnologias O Delphi oferece um muito amplo suporte a tecnologias e padres do ambiente Windows. Na prtica, no h nada que funcione neste sistema operacional que voc no possa fazer em Delphi. Voc pode desenvolver executveis de todos os tipos, dlls, objetos COM, ActiveX, Type Labriries, Automation Servers, Automation Controlers, Servidores ASP, COM+ ou MTS, servios WEB de todos os tipos, telas de descanso, fontes True Type (TTF) e ainda outros. Alm de tudo isto, voc pode desenvolver tambm objetos, controles ou formulrios WEB usando ActiveX. Para efeito de melhor compreenso, podemos destacar este suporte da seguinte maneira: Tecnologias de aplicativos: envolvem a criao de qualquer tipo de aplicativo e arquivo que voc desejar. Aqui podemos ver executveis diversos, multimdias, bibliotecas dinmicas (dlls) e controladores de servios. Tecnologias COM: envolvem um infinidade de objetos, interfaces etc que se encontram em executveis. Servidores e controladores Automation, Servidores COM em ou fora de processo, ActiveX, Servidores ASP, COM+ e objetos derivados do COM que suportam o ambiente MTS. Tecnologias voltadas para Internet : envolvem a criao de servidores ou clientes WEB, Pop, WebServices, CGIs, ISAPI, NSAPI, pginas ASP, WinCGI, Browsers etc. Tecnologias de Banco de Dados: uma das reas onde o Delphi oferece o maior suporte. Voc pode criar aplicativos de banco de dados que usam literalmente qualquer fonte de dados. Existe suporte diferenciado e baseado em mais de uma tecnologia para acesso a bancos Xbase, Acess, Paradox, FoxPro, VisualFoxPro, Sybase, Interbase, FireBird, Oracle, MS SQLServer, Informix, DB2, Arquivos Texto, Fontes ODBC, XML/CDS (MyBase), Formatos personalizados. Voc tambm pode escolher o uso de tecnologias de acesso diferentes, tais como: Fontes OleDB, ADO, DAO, Acesso nativo via API de SGDBs, BDE, DBExpress. Se voc mesmo desenvolver uma arquitetura de banco
17
(com formatos personalizados), o Delphi lhe permite desenvolver drivers IBExpress, BDE, OLEDB ou objetos com base em TDataset que atendam a este novo formato proprietrio.
Verses do Delphi O Delphi 6 distribudo em trs verses diferentes. Estas verses diferem significativamente quanto aos recursos e ferramentas disponveis: Enterprise. averso completa do produto. Esta verso suporta todas as tecnologias descritas acima. Professional. uma verso voltada para desenvolvedores que no trabalham com aplicaes distribudas e WEBServices. Alguns recursos (como a DataSnap e WEBSnap) no esto disponveis, mas podem ser adquiridos separadamente. Voc pode desenvolver aplicativos de banco de dados com esta verso. Standard. a verso mais simples. Originalmente, ela foi disponibilizada para estudantes, mas voc perceber que ainda assim uma ferramenta poderosa. Veja, por exemplo, um sumrio dos recursos disponveis nesta verso: compilador Object Pascal otimizado, bibliotecas VCL e CLX, suporte a pacotes, uma IDE com muitos recursos, suporte completo API do Windows.
Delphi.NET Mais recentemente a Borland anunciou o lanamento de uma verso do Delphi totalmente adapdata s necessidades do framework .NET, tambm recentemente adotado pela Microsoft. No podemos discutir aqui o que seja a tecnologia .NET, e afirmaremos apenas que tem o objetivo de prover o desenvolvimento de porte de aplicativos para a internet. A maneira como isto pode ser feito a utilizao de servios WEB (conhecidos, ento, como WEBServices) e aplicativos distribudos, usando tecnologias mais recentemente introduzidas no desenvolvimento para internet, como SOAP, ADO.NET e XML. Com o Delphi 6, voc j plenamente capaz de criar aplicaes .NET. Existem muitos exemplos de aplicativos deste tipo j disponveis. Dem observado, a prpria Borland uma das parceiras da Microsoft para o desenvolvimento da arquitetura .NET, conforme ditam alguns acordos assinados no ano passado; a Borland tem sido, de fato, provedora de tecnologias para esta arquitetura. Isso explica o fato de, em um determinado momento, o Delphi (e outras ferramentas da Borland) j possuirem suporte tecnologia .NET, antes mesmo de a Microsoft implementar tais tecnologias em suas ferramentas. O lanamento do Delphi 7.0 (codinome Aurora) est anunciado para ocorrer na segunda metade do ano de 2002, o do Kylix 3 (codinome Cortez) para julho de 2002, e o lanamento da verso 8.0 do Delphi (com codinome Galileo) j est prevista para 2003. Como se isto no fosse suficiente, a Borland tambm j anunciou o lanamento, tambm para o segundo semestre de 2002, de uma verso do Delphi estritamente direcionada para o desenvolvimento WEB e dedicada ao framework .NET. Esta ferramenta j possui o nome comercial oficial de Delphi.NET.
18
Figura. Uma viso cortada do Delphi.NET com o projeto ConvertIt.dpr aberto
Hoje, acredita-se que a migrao dos aplicativos Windows para a arquitetura .NET uma certeza. Muitos especialistas espimam que, dentre 3 anos, todos os novos desenvolvimentos de aplicaes Windows estaro baseados na arquitetura .NET. Voc j pode comear a criar aplicativos que trabalham nesta arquitetura, desde j.
O que o Kylix?
Historicamente, o desenvolvimento de aplicaes para Linux usando as ferramentas tradicionais tem sido uma experincia de custosas tentativas. Ferramentas Linux tradicionais, como GCC e Emacs so difceis de aprender e no provem a produtividade que os desenvolvedores corporativos demandam. O Kylix altera esta situao. O Kylix introduz, no sistema operacional Linux, uma soluo de desenvolvimento de alto desempenho que integra, a partir da verso 3.0, o desenvolvimento de aplicativos usando as linguagens Object Pascal do Delphi e, por outro lado, C++. A criao de aplicativos de banco de dados, GUI, WEB e WEBServices agora uma experincia muito mais rpida e simples com o Kylix. Como o Linux continua a crecer como uma soluo vivel para aplicaes corporativas, de e-business, de bancos de dados, GUI, WEB e WebServices, voc pode se beneficiar de todos os recursos implementados no ambiente Kylix para oferecer-lhe um ambiente de desenvolvimento de aplicaes muito rpido. De fato, os especialistas afirmam que o Kylix o primeiro ambiente RAD (rapid application development) disponvel para o mundo Linux. E devemos ainda acrescentar: ao contrrio de muitas outras ferramentas, o Kylix j nasceu grande e completo, pois surgiu como uma transposio do j muito desenvolvido ambiente Delphi 5.0 para a plataforma Linux.
Escolhendo uma linguagem de desenvolvimento
19
O kylix surgiu originalmente como um ambiente de desenvolvimento que usa a linguagem Object Pascal. Como grande parte dos programadores para Linux tradicionalmente desenvolvem na linguagem C, a Borland introduziu o suporte ao desenvolvimento usando a linguagem C++ no Kylix 3.0, a fim de suavizar ainda mais o esforo de aprendizado destes programadores. O Kylix 3 prov ambas linguagens de programao ANSI/ISSO C++ e Object Pascal, duas poderosas linguagens orientadas a objetos em uma nica ferramenta de desenvolvimento. Outra vantagem oferecida pelo Kylix a integrao de ambientes. O ambiente de desenvolvimento do Kylix (toda a IDE) praticamente idntico ao fornecido pelo Delphi, de forma que um programador Delphi se sentir em casa ao abrir o Kylix pela primeira vez. Isto permitir um ganho de produtividade enorme para os programadores Kylix/Delphi.
Tipos de aplicativos Com o Kylix voc pode desenvolver qualquer tipo de aplicativo para Linux. Voc pode desenvolver aplicativos visuais, servios, bibliotecas compartilhadas, aplicativos WEB etc. Podemos enumer-los da forma que segue: Aplicativos visuais : so programas que possuem uma interface (GUI) com o usurio. Bibliotecas: so programas compilados que exportam seus recursos para outros programas. So semelhantes s dlls da plataforma Windows. Aplicaes de banco de dados: so aplicaes que acessam e manipulam dados de um banco de dados. Aplicaes WEB. So aplicativos que fornecem algum tipo de funcionalidade em uma pgina da Internet, e servem como servidores WEB. WEBServices . So aplicativos distribudos que atuam como programas com funcionalidades especficas, e so acessados atravs de uma pgina da Intenet.
Suporte a tecnologias De modo geral, o Kylix suporta todas as tecnologias presentes no ambiente Delphi, exceto aquelas que se referem a recursos inexistentes no Linux. A ausncia mais marcante o suporte tecnologia COM, que exclusiva do mundo Windows. Contudo, existem algumas outras diferenas, como ausncia de suporte Registry e a alguns bancos de dados inexistentes na plataforma Linux. Um resumo do amplo suporte oferecido pelo kylix para o mundo Linux fornecido abaixo:
Tecnologias de aplicativos: envolvem a criao de qualquer tipo de aplicativo e arquivo que voc desejar. Aqui podemos ver executveis diversos, multimdias, bibliotecas compartilhadas e controladores de servios. Tecnologias voltadas para Internet : envolvem a criao de servidores ou clientes WEB, Pop, WebServices, CGIs, ISAPI, NSAPI, WinCGI, Browsers etc. Tecnologias de Banco de Dados: o suporte est baseado na arquitetura flexvel de TDataset e no uso da DBExpress como mecanismo de acesso a dados. Voc pode acessar bancos de dados Oracle, Firebird, Interbase, Informix, DB2, MySQL e outro. Adicionalmente, o acesso a bancos Interbase ou Firebird pode ser feito de forma direta, atravs da Interbase Express. 20
Tecnologias de acesso distribudo: o Kylix oferece grande suporte ao desenvolvimento de tecnologias de aplicaes distribudas, tanto no desenvolvimento de servidores como no de clientes.
Verses do Kylix O Kylix 3 tambm distribudo em trs verses diferentes. Analogamente ao Delphi, as verses diferem muito quanto aos recursos e ferramentas disponveis. Veja abaixo a relao das verses: Enterprise. averso completa do produto. Esta verso suporta todas as tecnologias descritas acima. A IDE vem com mais de 200 componentes instalados Professional. uma verso voltada para desenvolvedores que no trabalham com aplicaes distribudas e WEBServices. Alguns recursos (como a DataSnap, BizSnap e WEBSnap) no esto disponveis, mas podem ser adquiridos separadamente. Voc pode desenvolver aplicativos de banco de dados com esta verso. A IDE vem com mais de 165 componentes instalados Open. uma verso freeware e simples. No uma verso de cdigo-fonte aberto, como o nome pode sugerir. Consiste, basicamente, de um compilador Linux e uma IDE com bem menos recursos do que a das outras verses. A CLX vem com pouco mais de 75 componentes.
21
CAPTULO 2 - O AMBIENTE DELPHI

O Object Pascal uma linguagem compilada de alto nvel e fortemente tipada que suporta design estruturado e orientado a objetos. Seus benefcios incluem um cdigo de fcil leitura. Rpida compilao e o uso de mltiplas unidades de arquivos que propicia uma programao modular. Object Pascal oferece tambm recursos especiais que suportam um framework de componentes e uma ambiente RAD. Voc poder usar o Object Pascal para desenvolver qualquer tipo de aplicao usando ferramentas de desenvolvimento da Borland, tais como Delphi ou Kylix.
22
O ambiente Delphi
O ambiente de desenvolvimento do Delphi muito complexo. Voc encontr uma infinidade de recursos para o desenvolvimento dos mais diversos tipos de aplicaes. Uma caracterstica marcante deste ambiente a quantidade de ferramentas simultaneamente dispostas para uso do desenvolvedor. Algumas delas, contudo, so de uso evidente em praticamente todos os projetos que voc desenvolver, como o Code Editor, o Object Inspector e o Object Treeview. Na maioria das vezes, voc perceber que o seu ambiente ser marcado pela presena de janelas (ou formulrios) que voc criou e nos quais tanto trabalha de forma visual (desenhando a janela) como escrevendo cdigo no Code Editor. Abaixo voc pode ver uma imagem do ambiente Delphi com algumas de suas mais importantes ferramentas:
A Janela Principal A janela principal do Delphi um mecanismo de acesso fcil aos recursos do ambiente. Tambm denominada IDE, na verdade um recurso extremamente dinmico, podendo Ter seus menus, botes etc completamente alterados tanto pela configurao do usurio quanto pela instalao de componentes e addins. A instalao destes ltimos podem criar menus extras, novas ferramentas na IDE etc. Todas estes recursos instalveis na IDE (existem centenas ou milhares deles na internet) so criados no prprio Delphi. Observer abaixo o exemplo da ComponentBar, que agiliza o acesso aos objetos instalados na IDE. A janela principal tambm abriga a palheta de componentes, onde residem os componentes disponveis para uso. Voc deve analizar detalhadamente esta janela, pois descobrir uma quantidade muito grandes de recursos novos e ferramentas que facilitam muito o trabalho de desenvolvimento. 23
O Editor de Cdigo ( Code Editor ) O Editor de cdigo providencia total acesso ao cdigo gerado pelo projeto, incluindo alguns dos mais poderosos recursos para a edio. Pode ser selecionado tipos de cores para os elementos do programa (como por exemplo comentrios, palavras reservadas, cdigos assembler, ...). O Editor de Cdigo ser usado por voc sempre que desejar escrever algum cdigo em seu aplicativo. Tambm possui muitos recursos relacionados navegao entre cdigo e unidades, debugao de aplicativos e muitos outros recursos. Para outras informaes adicionais sobre o modo de usar este editor, procure referncias no Help OnLine no tpico Code Editor . Ao ser aberto um novo projeto, o Delphi gera automaticamente na pgina do Code Editor uma Unit com o arquivo cdigo (.PAS). Para ver o cdigo de uma Unit em particular, simplesmente Click na tabulao de pgina. O Code Editor mostrar sempre o nome do arquivo corrente ativo na tabulao de pgina. Voc pode personalizar por completo o comportamento e a aparncia do Code Editor.
O Object Inspector Providencia a conexo entre a interface visual e o cdigo de seu aplicativo. composto por duas pginas Properties (propriedades) e Events (Eventos) que mostram respectivamente as propriedades e eventos do objeto selecionado. O Object Inspector tambm disponibiliza um fcil caminho para a personalizao dos objetos. Voc usar a pgina de Propriedades para personalizar os objetos colocados no formulrio (inclusive o prprio formulrio), e a pgina de Eventos para gerenciar a navegao entre certas partes do cdigo do programa ou escrever novos manipuladores de eventos. O seletor de objetos (Object Selector - localizado em um objeto do tipo ComboBox no topo do Object Inspector) mostra o nome e o tipo de todos os componentes do formulrio corrente (inclusive o prprio). Voc pode usar o seletor de objetos para localizar facilmente qualquer objeto no formulrio. Ferramentas do tipo do Object Insector so comuns em muitos ambientes de desenvolvimento visual e so de muito fcil compreenso. O Object Inspector pode ser completamente personalizado pelo usurio. A personalizao envolve desde a sua aparncia at o ocultamento/exibio de algumas propriedades dos objetos. O uso desta ferramenta uma constante na maioria dos projetos, podendo ser acessada, por padro, atravs da tecla F11.
O Object Inspector exibindo a pgina de propriedades de um objeto.
O Object Inspector exibindo a pgina de eventos de um objeto.
24
O Object Treeview Esta ferramenta permite uma visualizao hierrquico dos objetos em um formulrio a partir da pespectiva da vinculao entre eles. Ou seja, existe um formulrio e dentro deles diversos componentes; dentro de cada um destes componentes podem haver outros a eles vinculados e assim por diante. No confunda isto com a representao hierrquica de descendncia dos objetos instalados na IDE. O Object Treeview pode ser usado para selecionar qualquer objeto que, por qualquer razo, estiver escondido ou oculto atrs de outros objetos. Esta seleo equivale seleo direta que voc faz com o cursor mouse.
Figura X: O Object TreeView exibindo os objetos em um container (Form1).
25
A Palheta de Componentes Componentes so alguns dos objetos que voc usar para trabalhar em suas aplicaes. Os componentes so acessados atravs de vrias pginas da Palheta de Componentes. L voc poder encontrar caixas de dilogos, controles de edio, datasets, botes e muito mais. Por padro, os objetos da palheta so alocados em diferentes pginas, segundo as suas prprias funcionalidades. Por exemplo, os objetos que representam as janelas tradicionais do Windows (tais como fontes, palheta de cores, ...) foram colocados na pgina Dialogs da palheta.
Figura Um viso cortada da Palheta de Componentes.
Voc poder criar seus prprios objetos, assim como tambm instalar outros j prontos. Uma das principais vantagens da OOP que existe no mercado, lieralmente falando, uma infinidade de pacotes de objetos prontos para serem integrados aos sistemas, o que facilita ainda mais o desenvolvimento e a manuteno dos mesmos. Voc pode personalizar por completo a palheta de componentes, mudando a organizao dos componentes e os nomes das pginas. Para isto, basta acessar a janela Pallete Properties usando o menu de contexto em cima da Palheta de Componentes e selecionando o item Properties. Nesta janela, possvel criar novas pginas, deletar as existentes e mover componentes de uma pgina para outra.
Figura A janela Pallete Propertiespermite que voc opere uma todal personalizao da Palheta de Componentes. Atravs dos botes, voc cria uma nova pgina na Palheta ou renomeis, move ou elimina uma existente. Voc pode mover os componentes de uma pgina a outra simplesmente arrastando-os para a pgina listada esquerda.
Ao trabalhar no desenho de telas em um aplicativo a Palheta de Componentes vastamente usada. Uma caracterstica implantada a partir do Delphi 6.0 ocultamento dos cones dos controles quando
26
voc est trabalhando em um mdulo de dados (ou um de seus descendentes). Isto lgico, pois impossvel colocar um controle em mdulos de dados.
O Object Repository O Repositrio de Objetos (Object Repository) do Delphi armazena e gerencia os objetos da aplicao: Formulrios, Data Modules, geradores experts, e DLL (Dinamic Linked Library - Bibliotecas de acesso dinmico). Na essncia, ele centraliza as localizaes dos objetos envolvidos agrupado-os. A proliferao dos objetos no repositrio incrementa as seguintes vantagens: Suporte a equipe de desenvolvimento para referncia aos objetos da rede. Uma customizao de todo o desenvolvimento em grupos lgicos de objetos, facilitando o re-uso dos mesmos.
Figurax Uma viso do Object Repository. Como esta ferramenta customizl, voc pode encontrar uma viso muito diferente desta ferramenta em uma instalao do Delphi.
O Delphi possui diversas caractersticas quanto a sua utilizao. Tem os Tutors e Experts que so as ferramentas responsveis para guiar-nos atravs de tcnicas, tais como, manipulao de componentes e criao de simples aplicaes. Alm disso o Delphi oferece uma coleo de modelos para formulrios, janelas de dilogo e at mesmo aplicaes completas na ferramenta New Items. A janela do New Items sempre chamada automaticamente quando a opo File | New | Items do menu principal executada. possvel para voc criar novas janelas, ou projetos, automticos no Delphi. Para definir o projeto padro que o New Items executar no incio de cada projeto, clique com o boto direito acima da janela e escolha a opo Properties aparecer as listas Pages e Objects, defina quaisquer dos objetos como New Form ou Main Form. Observe que a segunda folha da janela New Items (ter o nome do seu arquivo com a extenso .DPR) o seu projeto corrente, ou seja, uma nova janela poder ser derivada, por caracterstica de herana, de uma outra janela j existente. Muitos assistentes so inicializados a partir desta ferramentas 27
O Project Manager O Gerenciador de Projetos contm uma lista de formulrios ou unidades utilizados pela aplicao, e serve para controlar estes formulrios ou unidades, adicionando-os ou removendo-os do projeto, organizando as opes do projeto, entre outros. Isto significa que voc pode gerenciar de forma centralizada diversas aplicaes em um s local. Projetos maiores, envolvendo alguns aplicativos so excelentemente gerenciados atravs desta ferramenta. Voc poder pular de um projeto para outro sem fechar qualquer um deles e, quando quiser, retornar ao projeto inicialmente aberto. O Project Manager a maneira usada pela IDE do Delphi de voc trabalhar com mais de um projeto ao mesmo tempo. Veja abaixo um exemplo do uso do Projetc Manager em um projeto mltiplo.
FiguraX O Project Manager permite uma manipulao rpida e simples de projetos que contenham diversos aplicativos, bibliotecas etc.
28
Organizao do programa
No Object Pascal os aplicativos so comumente divididos em mdulos de cdigo-fonte chamados unidades (units). Cada programa comea com um cabealho que especifica o nome do programa. Este cabealho seguido por uma opcional clusula uses e o bloco de declaraes e procedimentos. Na clusula uses encontra-se uma lista de unidades que esto ligadas ao programa, que podem ser distrtibudas ou usadas por deferentes programas. Isto instruir o compilador com informaies sobre dependncias entre os diversos mdulos. As unidades podem estar ligadas a formulrios (TForm) ou conter procedimentos e funes ou cdigos de objetos ou todas estas coisas. Devido ao fato de as informaes estarem armazenadas diretamente nas unidades, programas desenvolvidos em Object Pascal no necessitam de makefiles, arquivos de cabealho ou diretivas include de pr-processador.
Arquivos fontes pascal O compilador espera encontrar cdigo Pascal em arquivos de trs tipos: Arquivos-fontes de unidades (terminam com a extenso .pas) Arquivos de projetos (terminam com a extenso .dpr) Arquivos-fontes de Pacotes (terminam com a extenso .dpk) Muito comumente, arquivos de unidades contm a maior parte do cdigo de uma aplicao. Cada aplicao possui um nico arquivo de projeto (.dpr) e muios arquivos de unidades (.pas). O Delphi automaticamente mantm um arquivo de projeto para cada aplicao. Se voc estiver compilando um programa a partir de linhas de comando, possvel colocar todo o cdigo em arquivos de unidades. Contudo, se estiver usando a IDE do Delphi para faz-lo, dever incluir um arquivo de projeto. Arquivos de pacotes so similares aos de projeto, mas so usados para construir bibliotecas dinmicas (dlls) especiais cahamadas packages (pacotes).
Outros arquivos de aplicaes Em adio aos mdulos de cdigo-fonte, so usados muitos aarquivos que no possuem cdigo Pascal no desenvolvimento de sua aplicao. Estes arquivos so mantidos automaticamente e incluem: Arquivos de formulrios, que possuem a extenso .dfm (Delphi) or .xfm(Kylix). Arquivos de recursos, que possuem a extenso . res Arquivos de opes de projeto, com extenso .dof (Delphi) ou .kof (Kylix).
Um arquivo de formulrio simultneamente um arquivo texto e um arquivo compilado que possui bitmaps, strings e outros recursos. Cada arquivo representa um nico formulrio em sua aplicao. A IDE do Delphi permite voc salvar estes arquivos como texto ou binrio. Freqentemente, cada aplicao possui ao menos um formulrio (principal), e cada formulrio possui um arquivo .pas associado a ele que, por padro, tem o mesmo nome do formulrio associado a ele. Cada projeto usa tamb um arquivo de recurso (.res) que armazena bitmaps, cones, cursores e qualquer outro tipo de dado binrio. Os arquivos de opes de projetos contm diretivas de compilao, informaes de diretrios de pesquisa, informaes de verses etc. Por padro, estes arquivos tm o mesmo nome do aruivo de projeto (.dpr).
29
Vrias ferramentas na IDE do Delphi armazenam dados em arquivos de outros tipos, como arquivos de desktop (.dsk), que contm informaes sobre as posies das janelas e outras opes de configurao. Estes arquivos no possuem qualquer efeito direto na compilao.
Arquivos gerados pelo compilador A primeira vez que voc compilar uma aplicao ou dll, o compilador produz um arquivo de unidade compilada .dcu (Windows) .dcu/.dpu (Linux) para o seu projeto. Assim, quando voc recompilar a sua aplicao ou biblioteca, as unidades .pas no sero novamente compiladas, exceto se voc as alterou ou see o compilador no pode encontr-las. possvel tambm instruir o compilador para forosamente gerar novamente os arquivos compilados.
Uma simples aplicao console O exemplo seguinte ilustra alguns recursos bsicos da programao em Object Pascal. Trata-se de uma simples aplicao console que no pode ser compilada a partir da IDE, mas sim a partir da linha de comando. program Greeting; {$APPTYPE CONSOLE} var MyMessage:string ; begin MyMessage :='Hello world!'; Writeln(MyMessage); end .
A primeira linha declara um programa chamado Greeting. A diretiva {$APPTYPE CONSOLE} informa o compilador que se trata se uma aplicao console. A prxima linha declara uma varivel do tipo string, chamada MyMessage. O programa ento atribui a esta varivel a string Hello world! e envia o contedo da varivel para o output padro usando a procedure Writeln, que definida na unidade System, que includa automaticamente pelo compilador em toda aplicao. Voc pode escrever este programa em uma arquivo chamado Greeting.pas e compil-lo digitando On Delphi:DCC32 Greeting On Kylix:dcc Greeting na linha de comando. Apesar de o Delphi/Kylix serem ambientes de desenvolvimento muito voltados para a criao de aplicativos com aspectos grficos (e com certeza muito mais complexos), voc pode criar livremente aplicaes de linha de comando que no possuem qualquer interface com o usurio. Estas ferramentas oferecem completo suporte ao desenvolvimento de aplicaes do tipo console.
Alguns recursos importantes da IDE
30
A IDE do Delphi e do Kylix oferece muitos recursos interessantes. A finalidade deles facilitar o processo do desenvolvimento dos seus aplicativos. Neste tpico vamos destacar alguns deles. Lembrese que, to logo voc os conhea e utilize, jamais deixar de utiliz-los em todas as suas aplicaes.
Encaixe de janelas (Dock) O Delphi e o Kylix usam o modelo de interface SDI (single document interface), o que siginifica que muitas janelas podem ser abertas separamente uma das outras e ao mesmo tempo. Se voc um desenvolvedor que utiliza ferramentas como C++ ou Visual Basic, j deve Ter reparado que este modelo constantemente usado rm quase todas as ferramentas de desenvolvimento de aplicativos. Contudo, pode ocorrer que, aps abrir umas 30 janelas, a sua rea de trabalho fique confusa. Para solucionar este problema, o Delphi e o Kylix oferecem o recurso de encaixe de janelas. Este recurso resume-se ao encaixe de muitas janelas em uma nica janela, tal como se fossem painis. Quando voc arrasta uma janela em cima de outra o Delphi a encaixar automaticamente, mas se voc no desejar que o encaixe seja feito, arraste-a novamente para fora da regio de encaixe. Se voc est arrastando uma janela (como quando vai organizar a posio das janelas), mas no deseja que a IDE encaixe-a, aperte a tecla Ctrl enquanto executa o arrasto. Voc pode identificar que existem janelas encaixadas atravs da barra horizontal que as separa. Para desfazer o encaixe, basta arrastar uma janela para fora da superfcie da outra onde est encaixada. A imagem abaixo mostra algumas janelas da IDE do Delphi encaixadas:
Este o Object TreeView
Este o Object Inspector
FiguraX O Object Inspector encaixado na janela do ObjectTreeView.
Preenchimento de classes O preenchimento de classes um recurso que tem o objetivo de poupar digitao do programador. Freqentemente ns sabemos exatamente qual cdigo escrever, mas somos obrigados a digitar uma grande quantidade de cdigo. O preenchimento de classes tenta resolver este problema atravs da seguinte estratgia:
31
Voc digita uma declarao (como em um procedimento e funo) e aperta as teclas Ctrl+Shift+C a fim de que a IDE possa escrever uma estrutura de cdigo que voc teria de escrever manualmente, caso no existivesse o prrenchimento de classes. Por exemplo, voc cria um procedimento chamado Teste, que requer uma parmetro inteiro chamado simplesmente I. Algo como:
procedure Teste(I: integer)
Ao apertar a combinao de teclas que citamos acima, a IDE escrever a implementao deste procedimento para voc, que algo como:
procedure Teste(I: integer); begin end;
Lembre-se deste recurso ao declarar novos procedimentos e funes, pois ele poupar muito do seu tempo de trabalho, alm de minimizar as possibilidade de erros.
Navegao entre sees de interface e implemntation Outro recurso interessante da IDE se refere navegao entre as declaraes e implementaes dos procedimentos e funes em uma unidade. Se voc est na implementao de um procedimento, aperte as teclas Ctrl+Shift+ seta para cima para ir para o local do cdigo onde a declarao do procedimento foi feita. O caminho inverso feito atravs das teclas Ctrl+Shift+ seta para baixo. Voc ficar feliz ao usar este recurso em unidades cdigo muito extensas.
AppBrowser Ao escrever uma aplicao, muitas vezes voc se deparar com uma linha de cdigo que se refere a um mtodo no escrito por voc. Se desejar ver o cdigo deste mtodo, aperte a tecla Ctrl enquanto passa o cursor do mouse em cima do nome do mtodo, e clique neste nome. Imediatamente a IDE localizar a unidade onde o mtodo implementado, e a abrir na linha onde o mtodo implementado. Voc pode usar este recurso da mesma forma que faz com um navegador de internet, clicando em links para se mover a um determinado lugar. H tambm uma lista dos lugares visitados, de forma que voc pode retornar ou avanar na navegao por esta lista.
32
TO-DO List O recurso TO-DO List da IDE uma ferramenta de gerenciamento de tarefas a serem realizadas durante o desenvolvimento de um aplicativo. Consiste basicamente em um cadastro de tarefas que ainda precisam ser feitas por um determinado usurio. TO DO List completamente integrado na IDE, de forma que voc poder incluir uma nova tarefa a partir de qualquer unidade de cdigo de sua aplicao. Por exemplo, em qualquer ponto do ser cdigo, acesse o menu de contexto e selecione o item Add To-Do Item. Isto far com que a janela de gerenciamento de tarefas aparea, a fim de que voc insira uma nova tarefa a ser feita naquele ponto do cdigo. Voc pode, igualmente, criar novas tarefas que no esto vinculadas a nenhum cdigo especfico, como Inserir logotipo da empresa no programa, e muitos outros recursos. A imagem abaixo mostra o gerenciados de tarefas da IDE com algumas tarefas concludas e outras no.
Code Insight O code insight simplesmente um recurso que poupa-lhe o trabalho excessivo de digitao durante o desenvolvimento de seus programas. Basta voc digitar o nome de um identificador, seguido de um ponto, para o code insight exibir em uma lista fllutuante todas as propriedades, eventos, mtodos etc cabveis ao identificador. Agora, basta selecionar o que voc deseja para a IDE escrever o cdigo correspondente para voc e, em seguida, fechar a janela com a lista. Se, por alguma razo, a janela se for fechada antes de voc escolher um item, aperte as teclas Ctrl+ barra de espao para exib-la novamente.
33
CAPTULO 3 CONHECENDO
OBJECT PASCAL
Este captulo introduzir um primeiro conhecimento do que a linguagem Object Pascal. Voc perceber que o Object Pascal uma linguagem completamente orientada a objetos e, conseqentemente, qualquer desenvolvimento que puder ser feito nesta linguagem deve sempre Ter em mente este fato. Embora muitos conceitos errneos possam surgir a respeito do que seja uma linguagem orientada a objetos, podemos afirmar que todo o suporte que uma linguagem orientada a objetos pode oferecer aos desenvolvedores, em ltima instncia, encerra-se no processo de criao de novas classes e objetos. Poderia-se dizer: a linguagem se desenvolve medida que o conjunto de objetos disponvel cresce. Apesar da simplificao natural a este raciocnio, voc compreender que vlido para as linguagens orientadas a objetos. Voc tambm conhecer a estrutura fundamental de uma unidade de cdigo do Object Pascal. Qualquer programa construdo a partir destas unidades de cdigo-fonte, que chamamos units, que so ligadas e compiladas so para gerar uma aplicao. As unidades permitem: Dividir grandes programas em mdulos que podem ser editados separadamente. Criar bibliotecas que voc pode compartilhar entre diversos programas. Distribuir bibliotecas para outros desenvolvedores sem tornar o cdigo-fonte disponvel.
34
Programao orientada a objetos

Para compreendermos melhor o ambiente de desenvolvimento Delphi necessrio que voc aprenda e tenha em mente os conceitos de OOP (Programao Orientada a Objetos). No confunda os conceitos introduzidos programao orientada a objetos com a EOP (Programao Orientada a Eventos), muito difundida a partir do Access 2.0 (um ambiente baseado em Objetos). Ao longo deste tpico voc vai notar as sensveis diferenas que existem entre esses dois conceitos. A OOP e a EOP so s vezes confundidas, mas lembre-se: a OOP contm a EOP, mas a EOP no contm a OOP. Ou seja, um objeto pode existir, mesmo que no exista nenhum evento associado a ele, mas um evento no pode existir se no houver um objeto a ele associado. Outros conceitos que podem causar confuso so o de Ambientes Orientados a Objetos e o de Ambientes Baseados em Objetos. Em ambientes orientados a objetos, consegue-se criar e manipular objetos, mas, naqueles ambientes que so apenas baseado em objetos, no possivel a criao de objetos, apenas a sua manipulao. O Microsoft Visual Basic (VB) um dos exemplos mais tpicos de ambientes baseados em objetos. Quando a Microsoft lana uma nova verso do VB, os programadores podem verificar que novos objetos foram adicionados, mas nenhum daqueles pode faz-lo por conta prpria no VB; esta adio feita, em muitos casos, criando-se bibliotecas dinmicas em outras ferramentas. Outro exemplo de fcil compreenso: muitas ferramentas de desenvolvimento implementam alguns aspectos de orientao a objetos, como propriedades e eventos, mas isto no significa que so orientadas a objetos. O fato de possuirem elementos de programao denominados objetos e algo como propriedades e eventos de objetos, por si s, no compem sequer o centro daquilo que chamado programao orientada a objetos. Na verdade, uma linguagem no orientada a objetos no poder jamais chegar a possui esta caracterstica, a no ser que sofram uma transformao to profunda que poderamos, neste caso, dizer que uma nova linguagem foi criada. O que possvel fazer, ento, torn-la cada vez mais baseada em objetos. Originalmente, a OOP um conceito desenvolvido para promover uma programao estruturada e facilitar a reutilizao de cdificaes. Por exemplo, quando voc adiciona um componente na sua aplicao, o que est fazendo reaproveitamento de codificao. Sendo a Borland, uma das primeiras empresas a promover o estudo e a aplicao deste novo conceito, natural que tenha desenvolvido as principais linguagens de programao (tais como Object Pascal e C++), totalmente orientadas a objetos. Com o tempo, a OOP atraiu muitos adeptos, atrados principalmente pela grande reutilizao de cdigo e as facilidades de crescimento de uma estrutura de dados (como uma hierarquia de objetos, por exemplo) que ela proporcionava. Entre estes programadores, por exemplo, pode-se citar aqueles que desenvolviam em Clipper87 , ferramenta muito utilizada no final da dcada de 90 e incio da dcada de 90. Este tpico introduzir alguns conceitos fundamentais da programao orientada a objetos, que a base fundamental do desenvolvimento na linguagem Object Pascal.
Orientao a objeto Como se v programao orientada a objetos uma extenso da programao estruturada que enfatiza a reutilizao de cdigo e o encapsulamento de dados com funcionalidade. Desde que voc tenha criado um objeto (ou, mais formalmente, um classe), voc e outros programadores podem us-lo em diferentes aplicaes, reduzindo o tempo de desenvolvimento e aumentando a produtividade Antes de comearmos a falar realmente de linguagem orientada a objetos e necessrio que voc possua os conceitos bsicos da orientao a objetos, so eles: Objeto - qualquer estrutura modular que faz parte de um produto. Uma janela por exemplo, um objeto de uma casa, de um carro ou de um software com interface grfica para o usurio.
35
Atributos - So as caractersticas do objeto, como cor e tamanho, a janela, por exemplo, tem atributos como o modelo, tamanho, abertura simples ou dupla, entre outros. Encapsulamento - um mecanismo interno do objeto escondido do usurio. Uma pessoa pode abrir uma janela girando a tranca sem precisar saber o que h dentro dela. Ao - a operao efetuada pelo objeto. Todas as janelas, por exemplo, controlam a iluminao e temperatura ambiente, dependendo do seu design. Herana - um objeto novo nem sempre criado do zero. Ele pode herdar atributos e aes de outros j existentes. Um basculante herda atributos das janelas e das persianas. Polimorfismo - a capacidade de objetos diferentes reagirem segundo a sua funo a uma ordem padro. O comando abre, por exemplo, faz um objeto entrar em ao, seja ele uma janela, uma porta ou uma tampa de garrafa. Ligao - quando um objeto conecta a sua ao a outro. Um sensor de claridade, por exemplo, ativa o acendimento automtico da iluminao de rua. Embutimento - Permite a um objeto incorporar funes de outros, como um liqidificador que mi carne com a mudana do tipo da lmina.
O Object Pascal
O Object Pascal uma linguagem completamente orientada a objetos. Na prtica, isto significa que o desenvolvimento em Object Pascal feito sempre com peas de construo de aplicativos, que so chamados genericamente de objetos. Para os programadores que j conhecem tcnicas de estruturas de programao, com o C, Basic, Pascal ou xBASE, entre outras linguagens, o Object Pascal providencia uma migrao de forma natural, mas oferecendo um produto de maior complexibilidade. Uma das conseqncias da orientao a objetos do Object Pascal, que voc forado a executar passos lgicos durante o desenvolvimento, tornando mais fcil o desenvolvimento de aplicativos de todos os tipos. Alm disso possibilita a criao e reutilizao (vantagem de reuso to sonhado com a Orientao a Objetos) de objetos e bibliotecas dinmicas (Dynamic Link Libraries - DLL). O Object Pascal contm todo o conceito da orientao a objetos, incluindo aspectos mais sensveis, como encapsulamento, herana e polimorfismo. Algumas extenses foram includas para facilitar o uso tais como conceitos de propriedades particulares e pblicas, e tipos de informaes em modo runtime, manipulao de excees, e referncias de classes. O resultado de toda esta juno faz com que Object Pascal consiga suportar as facilidades de um baixo nvel de programao, tais como: Controle e acesso das subclasses do Windows (API); Passar por cima das mensagens de loop do Windows; Mensagens semelhantes s do Windows; Uso direto da linguagem Assembler.
Ao mesmo tempo, o Object Pascal se revela como uma linguagem de alto nvel, isto , que encapsula as funcionalidades e recursos de programao em uma soluo de fcil implementao. Isto torna o Object Pascal uma linguagem extensa, com a qual se pode desenvolver tudo. Para no parecer um exagero, durante os prximos captulos voc poder observar que, literalmente falando, no existe nada, no mundo Windows, que voc no possa fazer usando o Objetc Pascal.
36
Evidentemente, uma linguagem orientada a objetos no precisa, necessariamente, ser uma linguagem com recursos visuais. Isso fica fcil de se entender quando observamos que um objeto uma estrutura de dados, que pode ou no possuir caractersticas relacionadas visibilidade e aparncia (como cor, altura, largura etc). Bem observado, a maioria dos objetos implementados no Object Pascal no possuem caracacterstica alguma relacionada visibilidade.
O que um objeto? Um objeto ou classe um tipo de dado que encapsula dados e operaes sobre dados em uma nica unidade. Antes da programao da programao orientada a objetos dados e operaes (funes) eram tratados como elementos separados. Voc pode comear a entender objetos se entender records. Records so estruturas de campos que contm dados onde cada campo tem o seu prprio tipo. Objetos so tambm colees de elementos de dados, mas diferentemente de records contm procedimentos e funes que operam nos seus dados. Tais procedimentos e funes so chamados mtodos. Um objeto tambm acessado atraves das suas propriedades. A combinao da dados e funcionalidade em uma nica unidade chamada emcapsulamento. Adicionalmente, a programao orientada a objetos caracterizada por herana e polimorfismo. A herana indica que os objetos derivam suas funcionalidades de outros objetos (chamados ancestrais), mas o objeto atual pode modificar suas caractersticas herdadas. O polimorfismo significa que diferentes objetos herdados do mesmo ancestral suportam as mesmas propriedades e mtodos que, podem ser chamados intercambiveis. Quando voc declara uma classe, possvel especificar seu ancestral imediato. Por exemplo:
Type TSomeControl = class (TControl);
Isto a classe declarada TsomeControl descende de Tcontrol, desta forma herdando todas as caractersticas de Tcontrol e seus ancestrais. A classe TObject, declarada na unidade system, o ancestral ltimo de todas as outras classes. Nesta classe podemos encontrar todos os mtodos bsicos de criao e destruio de objetos, que sero usados ou modificados pelos descendentes de TObject.
Classes, objetos e componentes Este tpico apresenta uma viso geral das bibliotecas de componentes e introduz alguns dos componentes que voc pode usar no desenvolvimento de suas aplicaes. Delphi inclui ambas a Visual Component Library (VCL) e a Borland Component Library for Cross-Platform (CLX). A VCL apenas para desenvolvimento de aplicaes Windows, enquanto a CLX usada para desenvolvimento de aplicaes Windows ou Linux. So duas diferentes bibliotecas, porm possuem grandes similaridades. A VCL e a CLX so bibliotecas de classe e objetos, alguns dos quais so tambm componentes ou controles que voc usa no desenvolvimento de suas aplicaes. Alguns objetos na VCL implementam recursos que esto disponveis apenas na plataforma Windows. Tais objetos aparecem nas palhetas ADO, BDE, QREPORT, COM +, WebServices e Servers. Virtualmente todos os objetos da CLX esto disponveis para as plataformas Linux e Windows. Um subconjunto de objetos so os componentes. Voc pode coloca-los em um formulrio ou mdulo de dados e manipul-los em tempo de desenvolvimento; tambm possvel especificar suas propriedades sem escrever cdigo. Todos os componentes da VCL ou CLX descendem do objeto Tcomponent.
37
Os componentes so objetos no verdadeiro sentido da programao orientada a objetos (OOP) porqu: Encapsulam um conjunto de dados e funes de acesso a dados; Herdam dados e caractersticas dos objetos dos quais so derivados; Operam intercambiavelmente com outros objetos derivados de um ancestral comum, caracterstica chamada polimorfismo.
Diferentemente de muitos componentes, objetos no aparecem na palheta de componentes. Uma varivel padro declarada na unidade do objeto ou voc tem que declar-la. Controles so tipos especiais de componentes que so visveis para o usurio em tempo de execuo. Todos os controles tem propriedades que especificam seus atributos visuais, tais como altura, largura ou cor. As propriedades, mtodos e eventos que todos os controles tem em comum so herdados de Tcontrol.
Programao estruturada e syntax

Um programa contm: Um cabealho Uma clusula uses (opcional) Um bloco de declaraes e procedimentos
O cabealho do programa especifica um nome para o programa. A clusula uses lista as unidades usadas pelo programa. O bloco contm as declaraes e procedimentos que so executados quando o programa roda. A IDE espera encontrar estes trs elementos em um nico arquivo .dpr. O exemplo abaixo mostra o cdigo de um programa chamado Editor
1 program Editor; 2 3 uses 4 Forms,{change to QForms in Linux} 5 REAbout in 'REAbout.pas'{AboutBox}, 6 REMain in 'REMain.pas'{MainForm}; 7 8 {$R *.res} 9 10 begin 11 Application.Title :='Text Editor'; 12 Application.CreateForm(TMainForm,MainForm); 13 Application.Run; 14 end .
A linha 1 contm o cabealho. A clusula uses vai da linha 3 6. A linha 8 uma diretiva de compilao que liga o programa a um arquivo de recurso. Das linhas 10 14 vemos o bloco de procedimentos. Esta uma tpica unidade de projeto, geralmente bem pequenas e totalmente mantidas pela IDE.
Unidades estruturadas e syntax
38
A unidade consiste de tipos (incluindo classes), constantes, variveis, e rotinas (funes e procedimentos). Cada unidade definida no seu prprio arquivo .pas. Aps o cabealho e a clusula uses seguem-se as sees interface, initialization e finalization. As sees initialization e finalization so opcionais. O esqueleto de uma unidade parece-se com o que segue:
unit Unit1; interface uses {List of units goes here }
{Interface section goes here }

implementation uses {List of units goes here }
{Implementation section goes here }

initialization
{Initialization section goes here }

finalization
{Finalization section goes here } end . Nota: A unidade deve conter a palavra end seguida de um ponto. Os nomes de unidades devem ser nicos dentro de um mesmo projeto.
A seo Interface A seo interface se inicia com a palavra interface e continua at o incio da implementao da seo implementation. Ela declara constantes, tipos, variveis, procedimentos e funces que esto disponveis para clientes, isto , para outras unidades ou programas que usam a unidade na qual declarada. Estas entidades so chamadas pblicas porque um clienmte pode acess-las como se fossem declaradas no prprio cliente. A declarao de interface de um procedimento ou funo inclui apenas o cabealho das rotinas. Tambm todos os membros de todas as classes usadas na unidades so declaradas a, como tipicamente ocorre em uma unidade vinculada a um formulrio.
A seo Implementation A seo implementation comea com a palavra-reservada implementation e continua at o incio da seo initialization ou, caso esta ltima no exista, at o fim da unidade. A seo implementation define procedimentos e funes declaradas na seo interface, que podem ser colocadas em qualquer ordem. Nesta seo voc pode tambm declarar constantes, tipos (inclusive classes), variveis etc que so privadas a esta unidade, isto , inacessveis a clientes, alm de sua prpria clusula uses. Neste ltimo caso, a clusula deve aparecer imediatamente aps a palavra-reservada implementation.
A seo Initialization
39
Como dissemos, a seo initialization opcional. Comea com a palavra-reservada initialization e termina at o incio da seo finalization ou, se esta no existir, at o final da unidade. A seo initialization contem rotinas que so executadas, na ordem em que aparecem, na inicializao do aplicativo. Por exemplo, se voc definiu estruturas de dados que precisam ser inicializadas, voc pode fazer isto nesta seo. A seo initialization de unidades usadas por um cliente so executadas na ordem que as unidades aparecem na clusula uses.
A seo Finalization A seo finalization tambm opcional e pode aparecer apenas em unidades que tm uma seo initialization. Ela comea com a palavra-reservada finalization e termina no final da unidade. A so colocadas rotinas que so executas quando o aplicativo encerrado. A liberao de memria e recursos que devem estar disponveis ao longo de toda uma execuo de um aplicativo pode ser feita nesta seo. Sees finalization so executas em ordem oposta s initialization. Por exemplo: se seu aplicativo inicializou as unidades A, B e C nesta ordem -, elas sero finalizadas na ordem C, B e A. Desde que uma seo initialization de uma unidade de cdigo inicia sua execuo, automaticamente garante-se a execuo da respectiva seo finalization quando o aplicativo for encerrado. Nota: O cdigo de uma seo finalization deve ser escrito de forma a suportar possveis falhas que ocorram na seo initialization como, por exemplo, na execuo incompleta de uma rotina alocadora de memria.
Referncias circulares Entende-se pela expresso referncia circular o fato de uma determinada unidade de cdigo (.pas) fazer referncia a outra unidade em sua clusula uses que, por sua vez, tambm se refira a esta unidade. O exempla abaixo ilustra esta situao. unit unit1; interface Uses windows, sysutils, unit2; ... . . e, por sua vez a segunda unidade:
unit unit2; interface uses windows, sysutils, unit1; //A unidade unit1 j faz referncia a esta! ...
Este tipo de prtica no desencadeia um erro de compilao, mas freqentemente indica um erro no desenvolvimento lgico (engenharia) do aplicativo. Por que a primeira unidade faria referncia
40
Segunda e esta, por sua vez, primeira? Com certeza, so bem poucas as situaes onde esta prtica necessria.
Identificadores, diretivas, palavras-chaves

Identificadores denotam constantes, variveis, campos, tipos, propriedades, funes, programas, unidades, bibliotecas e pacotes. Um identificador pode ser de qualquer comprimento, mas apenas os primeiros 255 caracteres so significativos. Um identificador deve comear com uma letra ou traabaico (underscore) e no podem conter espaos; letras, dgitos e traos-baixos so permitidos aps o primeiro caracter. Palavras reservadas no podem ser usadas como identificadores. Uma vez que o Object Pascal uma linguagem insensitiva, um identificador como CalculateValue poderia ser escrito de qualquer uma destas maneiras: CalculateValue calculateValue calculatevalue CALCULATEVALUE Nota: No Kylix, os nicos identificadores que so case-sensitive so os nomes de unidades. Desde que o nome de algum identificador corresponda ao do nome do arquivo pascal, inconsistncias podem, s vezes, afetar a compilao. As seguintes palavras reservadas no podem ser usadas como identificadores: and down to in or string array else inherited out then as shr end initialization packed thread var asm except In line procedure begin exports interface xor program try case file is property type class finalization label raise unit const of library record until constructor for mod repeat uses destructor function nil resourcestring var dispinterface goto not set while div if object shl with do implementation finally
Adicionalmente, as palavras private, protected, public, published e automated agem como palavras reservadas dentro de declaraes de tipos de objetos, mas, do contrrio, no so tratadas como diretivas. As palavras on e at tambm tm significado especial.
Diretivas Diretivas so palavras que so senditivas a locais especficos dentro do cdigo-fonte. Elas ocorrem apenas em locais onde identificadores definidos pelo usurio no podem existir. Conseqentemesnte
41
apesar de no recomendvel voc pode definir identifadores com usando palavras que so diretivas em outros locais. Abaixo so fornecidas as lista de palavras que agem como diretivas. absolute dynamic message private resident abstract export name protected safecall assembler external near public stdcall automated far nodefault default published stored cdecl forward overload read varargs contains implements override readonly virtual package register write deprecated library pascal reintroduce writeonly dispid local platform requires index
42
CAPTULO 4 - TIPOS
DE DADOS E ESTRUTURAS
Um tipo (type) essencialmente um nome para um tipo de dado. Quando voc declara uma varvel voce deve especificar seu tipo, que determina o conjunto de valores que a varivel pode armazenar. Muitas funes e procedimentos requerem parmetros de diversos tipos. O Object Pascal uma linguagem fortemente tipada, o que quer dizer que ela distinge uma variedade de tipos de dados e nem sempre permite a substituio de umtipo por outro. Normalmente isto benfico porque permite ao compilador tratar os dados inteligentemente e validar seu cdigo de maneira mais rgida, previnindo error de tempo de execuo que so dificilmente diagnosticados. Quando voc precisa de maior flexibilidade, existem mecanismos para sobrescrever a forte tipagem. Tais mecanismos incluem converso de tipos (typecastting), ponteiros (pointers), variants, variants parts em records e endereamento absoluto de variveis (absolute addressing). Contudo, entenda que a forte tipagem um recurso altamente benfico, e s em casos muito especficos voc abrandaria esta caracterstica do compilador.
43
Classificao
Simplificadamente, os tipos podem ser classificados como simples, estruturado, ponteiro, procedural ou variant.
Simples Tipos simples, que inclue, tipos ordinais e reais, definem um ordenado conjunto de valores. Os tipod ordinais incluem integer, character, boolean, enumerated e subrange. A tabela abaixo define os tipos inteiros mais importantes com suas respectivas faixas de valores:
Tipo Integer Cardinal Shortint Smallint Longint Byte Word Longword Int64 Faixa 2147483648..2147483647 0..4294967295 128..127 32768..32767 2147483648..2147483647 0..255 0..65535 0..4294967295 2 63 ..2 63 1 Formato signed 32-bit unsigned 32-bit signed 8-bit signed 16-bit signed 32-bit unsigned 8-bit unsigned 16-bit unsigned 32-bit signed 64-bit
Tipos subrange Tipos subrange representam um subconjunto de valores em um outro tipo ordinal (chamado tipo base). Por exemplo, se voc declara o tipo enumerado:
type TColors =(Red,Blue,Green,Yellow,Orange,Purple,White,Black);
Voc pode ento definir um tipo subrange como:

type TMyColors =Green..White;
Aqui, TmyColors inclui os valoress Green, Yellow, Orange, Purple, e White.
Tipos real Um tipo real define um conjunto de nmeros que podem ser fracionrios. A tabela abaixo descreve os tipos real mais importantes.
Tipo Real48 Single Double Extended Comp Currency Faixa 2.9 x 1039 .. 1.7 x 1038 1.5 x 1045 .. 3.4 x 1038 5.0 x 10324 .. 1.7 x 10308 3.6 x 104951 .. 1.1 x 104932 263 +1 .. 263 1 922337203685477.5808.. 922337203685477.5807 Formato 6 4 8 10 8 8
44
Nota: O tipo real genrico idntico ao tipo double.
Tipos string Uma string representa uma seqncia de caracteres. A tabela abaixo fornece as informaes mais importantes quanto a estes tipos.
Tipo ShortString AnsiString WideString Comprimento 255 caracteres ~231 caracteres ~230 caracteres
O tipo padro a AnsiString. O tipo WideString usado para servidores de tecnologia COM e desenvolvimento de bibliotecas de tipos (type library), uma vez que compatvel o tipo BSTR da COM do Win32. H ainda o tipo Pchar, que uma string terminada em nulo (#0). Este tipo muito usado em chamadas de funes da API do Win32, uma vez que strings terminadas em nulo so usadas de forma padro nesta plataforma. O operador + pode ser usado para concatenar strings e voc pode usar uma varivel do tipo string como uma lista de caracteres. Por exemplo: ... procedure CancatenaTexto; var s: string; begin s := Delphi. ; s := s + Ol pessoal; // Delphi. Ol pessoal end;
Tipo Boolean Os tipos Boolean so muito simples e conhecidos de muitos programadores de outras linguagens. Referem-se a dados que so verdadeiros (true) ou falsos (false). Estes tipos so usados massivamente ao longo de um aplicativo.
Tipos estruturados Os tipos estruturados incluem conjuntos (sets), arrays, records e files. As instncias de tipo estruturado armazenam mais do que um valor. Por padro, os valores de um tipo estruturado esto alinhados em uma face ou dupla face para um acesso mais rpido e, quando voc define um destes tipos poder usar a palavra reservada packed para emplementar armazenagem comprimida de dados. O uso de compresso reduz o desempenho de acesso aos dados, no caso de um array de caracteres afeta a compatibilidade de tipos. Um exemplo de um tipo enumerado empacotado o que segue: Type Tnumbers = packed array[1..100] of Real;
45
Conjuntos (sets) Um conjunto uma coleo de valores de um mesmo tipo ordinal. A faixa de um tipo set um tipo ordinal especfico chamado de base type; isto , os valores possveis de um tipo set so todos o sub sets de um base type, inclusive um conjunto vazio. O base type no pode Ter mais do que 256 valores possveis, e suas ordinariedade deve estar entre 0 e 255. Devido limitao de tamanho, tipos set so usualmente definidos com subfaixas (subrange), como no exemplo abaixo:
Type TsomeInts = 1.. 250; TintSet = set of TsomeInts;
Arrays Um array representa uma coleo indexada de elemetos de um mesmo tipo (tambm chamada base Type). Como cada elemento tem um ndice nico, os arrays, diferentemente dos tipos set, podem conter um mesmo valor mais de uma vez. Os arrays podem ser alocados de forma esttica ou dinmica. Arrays estticos so definidos na sua forma de construo Array [indtype1, ..., indtypeN] of baseType
Onde cada indtype um tipo ordinal cuja faixa no excede 2 GB. Uma vez que indType indexa o array, o nmero de elementos em em array pode ser limitado pelo produto dos tamanhos de indType. Na prtica, indType so usualmente subconjuntos inteiros. Em um caso mais simples de um array unidimencional a apenas um nico ndice. Por exemplo, var MyArray: array[1..100] of Char; declara uma varivel chamada MyArray que armazena um array com valores de 100 caracteres. Dada esta declarao, MyArray[3] indica o terceiro caracter neste array. Se voc cria um array esttico mas no assinala valores para todos os seus elementos, os elementos no preenchidos ainda assim so alocados e contm valores randmicos. Um array multidimencional um array de arrays, como no exemplo: Type Tmatrix = Que equivalente a: Type Tmatrix = Array[1..10, 1..50] of Real; O array Tmatrix representa um array de 500 valores do tipo Real. array[1..10] of array[1..50] of Real;
46
Arrays dinmicos Arrays dinamicos no tm um tamanho ou comprimento fixos. Ao contrrio, a memoria para eles realocada quando voc assinala um valor para o array ou o passa para o procedimento SetLength. Tipo de arrays dinmicos so indicados pelas seguintes construes: Array of buseType Por exemplo, var MyFlexibleArray: array of Real;
Declara um array dinmico unidimencional de valores do tipo Real. A delcarao no aloca memria para este array; para faz-lo chame o procedimento setLength como abaixo, SetLength(MyFlexibleArray, 20); Aloca um array de 20 elementos do tipo Real, indexados de 0 a 19.
Records Um registro (record) representa um conjunto de elementos heterogneos, onde cada elemento chamado um campo (field). A declarao de um tipo record especifica o nome e tipo para cada campo, como abaixo, Type recordTypeName = record FieldList1: type1; . . . fieldListn: typen; end
Por exemplo a seguinte declarao cria um tipo record chamado TdateRec. Type TDateRec = record Year: Integer; Month: (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec); Day: 1..31; End;
Cada TdateRec contem 3 campos: um valor inteiro chamado Year, um valor de tipo enumerado chamado Month, e outro campo inteiro com valores entre 1 e 31 chamado day. Os identificadores Year, Month, Day, so os designadores de campos para TdateRec, e eles se parecem muito com variveis. Contudo, a declarao do tipo TdateRec no aloca memoria para seus campos, o que somente ocorrer quando voc inicializar o Record, como abaixo: var Record1, Record2: TdateRec; Voc pode ler os campos de um Record acessando-os atravs de seus nomes: Record1.Year := 1904; Record1.Month := Jun; 47
Record1.Day := 16; Agora possvel tambm copiar os valores dos campos de Record1 para Record2: Record2 := Record1;
Tipos Record so comumente usados para guardar-se dados em arquivos com formato proprietrio; isto , voc define os campos de um Record, grava-os conforme descrito acima e, finalmente, pode criar um tipo file que se referencie a este tipo de Record. Seguindo o exemplo acima, temos: Calendario = file of Record1;
Isto indica o uso de um tipo file que guarda dados obtidos a partir de um Record. Existem diversos mtodos na VCL e CLX para salvar estes dados em disco.
Tipos variant Algumas vezes necessrio manipular dados cujos tipos variam ou no podem ser determinados em tempo de compilao. Nestes casos, uma opo usar variveis e parametros do tipo variant, que representa valores que podem mudar de tipo em tempo de execuo. Os tipos variant oferecem maior flexibilidade mas consomem mais memria do que os tipos regulares, e operaes sobre eles so mais lentas do que sobre os tipos regulares. Alm disto operaes ilcitas sobre tipos variant durante a execuo de um aplicativo frequentemente resultam em erros, quando situaes similares poderiam ser identificadas em tempo de compilao quando usamos tipos regulares. Por padro, tipos variants podem armazenar valores de qualquer tipo, exceto record, set, array esttico, file, class, referncias de classes e ponteiros. Voc pode definir um tipo variant customizado a fim de extender as capacidades do tipo original. Tipos variant so definidos cirando-se desendentes da classe TcustomVariantType.
Tipo OleVariant OleVariant um tipo de dado muito semelhante ao tipo Variant, mas s pode conter dados compateis com OLE Automation. Isto significa que voc pode passar dados entre programas ou em uma rede sem se preocupar se os aplicativos sabero manipu-los. Quando voc assinala um tipo Variant que contem dados personalizados (tal como uma string pascal) para um OleVariant, ocorrer uma converso automtica para um dos tipos pades reconhecidamente aceitos para um tipo OleVariant. Por exemplo, um tipo variant contendo um AnsiString, qunado assinalado para um OleVariant, vem a ser convertido em um tipo WideSting. O exemplo abaixo ilustra o uso de tipos variant e OleVariant que sofrem converses implcitas:
function RetornaVariant: OleVariant; var V: variant; begin V := 0; V := Delphi; V := 32.45; 48
Result := V; end; Como se v acima, a varivel V recebe valores de tipos diversos e retorna (em uma OleVariant) o resultado da funo. O estudo detalhado dos tipos variant, Olevariant e semelhantes fundamental para a compreenso de tecnololgias derivadas da COM, como DCOM, COM+, ASP, MTS e ainda outras.
Converses de tipos
Em diversos momentos do desenvolvimento de um aplicativo, voc ter a necessidade de converter um tipo de dado para outro. O Object Pascal oferece muitas rotinas de coverso de fcil uso e automaticamente protegidas contra falhas. Isso quer dizer que seu aplicativo no gerar um exceo durante a execuo que forar seu encerramento ou o travamento de algum recurso do Kernel do sistema operacional. A tabela abaixo descreve as principais funes de converso disponibilizadas com o Object Pascal:
Funo/Mtodo StrToInt IntToStr FloatToStr FloatToStrF StrToFloat PChar StrToCurr CurrToSTr DateToStr DateTimeToSTr TimeToStr StrToDateTime StrToDate StrToTime VarToStr StrToVar StrToInt64 StingToGUID BinToHex BoolToStr StrToBool CompToCurrency CompToDouble HexToBin StrToInt64Def StrToIntDef Inc Dec Descrio Se possvel, converte um string para um inteiro. Converte um inteiro para um string. Converte um tipo Float para um string. Converte um float para um string usando um formato especfico, preciso e dgitos. Se possvel, converte um string para um Float. Converte um string pascal para um string char. Se possvel, converte um string para um tipo Currency. Converte um Currency para um string. Converte um TDate para um string. Converte um TDateTime para um string. Converte um TTime para um string. Se possvel, converte um string para um TDateTime. Se possvel, converte um string para um TDate. Se possvel, converte um string para um TTime. Converte um variant para um string. Converte um string para um variant. Se possvel, converte um string para um inteiro longo. Se possvel, converte um string para um TGUID. Se possvel, converte um binrio para um hexadecimal. Converte um boolean para um string. Se possvel, converte um string para um boolean. Converte um Comp para um currency. Converte um comp para um double. Se possvel, converte um hexadecimal para um binrio. Se possvel, converte um string que representa um inteiro (decimal ou hexadecimal) para um nmero. Se possvel, converte um string que representa um inteiro (decimal ou hexadecimal) para um nmero. Converts a string that represents an integer (decimal or hex notation) to a number. Incrementa um nmero em um determinado valor. Decrementa um nmero em um determinado valor.
O Delphi instala um aplicativo de demonstrao, denominado ConvertIt que um conversor de diversos tipos de unidades. Ele pode converter, por exemplo, quilmetros para metros, sculos para
49
semanas ou segundos, nanogramas para quilos etc, etc. Voc pode estudar este aplicativo para entender como muitas converses so feitas. Veja a seguir alguns fragmentos de cdigo que ilustram o uso de algumas destas funes de converso:
var S: string; begin S := DateTimeToSTr(NOW); ShowMessage(Este momento : + S); end;
Converses implcitas e explcitas Converses explcitas so aquelas executadas explicitamente atravs de uma das diversas rotinas de converso disponveis no Object Pascal. Por exemplo, quando voc chama a funo de converso IntToStr em qualquer ponto de seu cdigo, isto significa que voc est executando uma converso explcita. Contudo, o Object Pascal aceita alguns tipos de converses implcitas, isto , aquelas que no so feitas atravs de funes de converso, mas sim atravs de um operador. Veja um exemplo.
function Soma: integer; begin Result := 3 + 1; end;
O compilador entende 3 como um nmero, mas 1 simplesmente uma string. Como o operador de soma + indica uma operao matemtica de soma, o compilador ir tentar converter 1 para um nmero, a fim de conseguir som-lo com o valor 3. Se o compilador conseguir fazer isto, uma converso implcita ter ocorrido. Nota: voc no deveria usar converses implcitas, exceto em situaes muito peculiares. O Object Pascal oferece um enorme conjunto de mtodos de converso de tipos de dados, e voc sempre encontrar um que atenada s suas necessidades.
Trabalhando com strings

Strings so tipos de dados muito simples e comuns. Em Objetc Pascal, voc sempre usa algum tipo de string em seus programas. Na verdade, ns a usamos massivamente. Com o passar dos anos, o Object Pascal foi disponibilizando diversos tipos de strings para atender necessidades especficas, como, por exemplo, o acesso aos tipos char de muitas funes da API do Windows ou o uso de WideString para o desenvolvimento de aplicativos que implementam qualquer tecnologia COM ou dela derivada. 50
Neste tpico, estudaremos alguns tipos de strings disponibilizadas pelo Object Pascal, bem como muitos mtodos de trabalho com elas. Concatenando strings Chamamos concatenao de strings o ato de unirem-se duas ou mais strings em uma s. No Object Pascal, voc concatena strings seguindo a mesma estratgia usada na soma de nmeros. Por exemplo, se voc escreve algo como
Soma :=
3 + 1;
entende-se que a varivel Soma assumiu o valor da adio matemtica destes dois nmeros. Mas, em um outro contexto, o compilador tambm entender cdigo
Frase := Oi pessoal! + O Delphi uma boa ferramenta!; //Agora, a varivel frase : Oi pessoal! O Delphi uma boa ferramenta!
ou ainda
Frase := Bom dia pessoal! + Agora so + TimeToSTr(Time) + horas!; //A varivel Frase o resultado da concatenao de trs strings.
Como voc pode observer, o compilador simplesmente monta uma nova string ajuntando duas ou mais strings. O interessante de tudo que voc usa o mesmo operador + para somas matemticas e concatenaes de strings. Um recurso de concatenao menos conhecido a funo Concat. Esta funo concatena um nmero arbitrrio de strings. Ela possui um parmetro, que um array de strings a serem concatenadas. O valor de retorno de Concat uma string com as substrings concatenadas. Veja o exemplo abaixo:
var S: string; begin S := Concat('Oi ', ' amigos!'); end;
{ 'Oi amigos!' }
Uma vez concatenadas, no possvel desfazer a operao automaticamente. Nota: a funo Concat mais lenta do que o uso do operador +.
51
Manipulando strings Existem muitas funes destinada leitura e manipulao de uma string. Na verdade, voc pode existem funes para voc fazer o que quiser com uma string. A tabela abaixo sumariza algumas destas funes:
Procedimento/Fu no Length Pos Delete Insert UpperCase LowerCase Val Trim TrimLeft TrimRight StuffString Str CompareStr DupeString QuotedStr ReverseString SetString WrapeText Descrio Retorna o comprimento de uma determinada string (nmero de caracteres). Retorna o ndice do primeiro caracter em uma substring especificada que existe em uma dada string. Deleta uma substring de uma determinada string. Insere uma substring em uma determinada posio de uma string. Altera todos os caracteres de uma string para caracteres maisculos. Altera todos os caracteres de uma string para caracteres minsculos. Converte uma string para uma representao numrica. Elimina todos os espaos em branco de uma string. Elimina todos os espaos em branco de uma string. Elimina todos os espaos em branco de uma string. Insere uma substring em uma posio especificada de uma string, substituindo os caracteres existentes. Formata qualquer nmero para uma string usando uma varivel. Compara duas strings para verificar se so idnticas. Retorna a auto-concatenao de uma string um determinado nmero de vezes. Retorna um string com o sinail inseridos em seu incio e fim. Retorna uma string invertida. Determina o contedo e comprimento de uma dada string. Retorna uma determinada string quebrada em mltiplas linhas.
Vamos ver agora alguns exemplos do uso destas rotinas.
Copiando strings A funo Copy retorna uma string que uma cpia de um trecho de outra string. Este trecho chamado substring, e definido por dois parmetros da funo Copy: Index. a posio do caracter de onde a cpia deve iniciar; Count. o nmero de caracteres a serem copiados.
Por exemplo, considere a string Delphi is rad!. Uma cpia que partisse do primeiro caracter e copiasse 6 caracteres resultaria a string Delphi. Como em
var S: string; begin S := Copy(Delphi is rad!,0,6); // s agora Delphi end;
Ou, em um outro exemplo
S := Copy(Delphi is rad!,8,7); / s agora is rad!
Como voc percebeu, o primeiro caracter de uma string possui sempre o ndice 0.
52
Inserindo strings O procedimento Insert adiciona uma substring em uma string. Seu funcionamento difere das rotinas de concatenao de strings, pois, ao contrrio destas, Insert capaz de inserir a substring em qualquer ponto da string original. Por exemplo, voc pode inserir uma substring qualquer aps o quarto caracter da strings original. Insert exige 3 parmetros: Source. a substring que se deseja inserir; S. a string na qual uma substring ser inserida Index. a posio na qual se insere S.
Veja um exemplo
Insert(Delphi is a tool!, rad , 10); //Delphi is a rad tool!
Existem apenas algumas observaes a serem feitas: Se Index for menor do que 1, ser convertido para 1. Se Source for uma string vazia, nada ser feito. Caso no seja possvel alocar memria suficiente para armazenar a nova string, uma exceo do tipo EoutOfMemory ser disparada.
Deletando strings O mtodo Delete pode deletar uma substring determinada de uma outra string. Delete requer 3 parmetros. S. a string da qual ser deletada uma substring (um trecho de string). Index. Marca a posio a partir da qual sero deletados os caracteres. Count. Determina a posio final de demarcao da string a ser deletada. Considere o seguinte exemplo
Delete(Delphi is a rad tool!, 13, 4); //Delphi is a tool!
Se Index for maior do que o comprimento de S ou menor do que 1, nada ser feito. Se Count especifica mais caracteres do que os restantes na string S, todo o resto da string deletado. Se Count menor do que 0, nenhum caracter deletado.
Formatando strings
53
O Object Pascal fornece muitas rotinas destinadas formataes de strings. Formatar uma string a ao de, a partir de uma string com indicadores de formatao, retornar uma string com os valores reais em substituio aos indicadores. Por exemplo, considere a funo Format. Esta funo retorna uma string no formatada a partir de parmentros de formatao fornecidos por voc. Veja um exemplo. var S: string; begin S := Format(Delphi is a rad %s!,[tool]); //Delphi is a rad tool! ShowMessage(S); end;
Format requer um conjunto de parmetros composto da string formatada e dos valores a serem usados na formatao. Mas a funo Format muito mais valiosa do que possvel perceber atravs do exemplo acima. Format capaz de lidar com diversos tipos de dados, no apenas strings. No exemplo acima %s um indicador de formatao de strings (s), mas voc poderia escrever algo assim.
var S: string; begin S := Format(Delphi %d is a %s!,[6,tool]); //Delphi 6 is a rad tool! ShowMessage(S); end;
Neste caso o indicador %d (decimal) substituda por um nmero decimal. Format pode formatar argumentos de muitos tipos, e possui uma estrutura flexvel. Voc pode formatar dados inteiros, decimais, monetrios, hexadecimais etc. Para uma referncia completa, consulte a ajuda on-line do Delphi.
Mais sobre strings... Um fantico por estudar e brincar com strings poderia escrever livros sobre este assunto. Atualmente, so tantos os tipos de strings suportados pelo Object Pascal, que existe uma tonelada de informaes sobre estes tipos. Existem informaes incrveis sobre strings na ajuda do Delphi. Consulte a seo strings handling routines, por exemplo, para ver uma lista completa das funes e procedimentos de manipulao de strings. Lembre-se sempre: strings so tipos de dados que voc sempre usar. Desenvolvendo um grande site de internet ou um joguinho muito pequeno, voc sempre precisar das strings.
Trabalhando com datas

A coisa mais importante que voc deve ter em mente quando escrever aplicativos que trabalham intensamente com datas o fato de as datas serem expressas de forma muitos diferentes ao longo das diversas regies culturais. Voc nunca deve considerar certo, por exemplo, que a formatao de horas
54
e datas em um determinada computador seja de um tipo. Os sistemas operacionais permitem uma completa customizao destes items, uma vez que precisam atender s mais diversas situaes culturais. Pode parecer tolo mas, caso um aplicativo desconsidere estas observaes, em determinadas condies ele pode se tornar inopervel. Suponha, por exemplo, uma instalao do sistema operacional Windows para a linguagem japosesa, rabe ou hebraica. Nestes contextos culturais, os calendrios so expressos de forma muito diferentes das mais conhecidas em um contexto cultural ocidental. Voc no pode considerar previamente que o ano possua 12 meses ou mesmo que o dia possua 24 horas. justamente pensando nestas questes que as APIs dos sistemas operacionais oferecem uma grande quantidade de rotinas que permitem-lhe entender como tratar datas e horas em um computador. Felizmente, o Object Pascal encapsula estas rotinas em interfaces de unidade de cdigo de fcil manipulao, bem como tratam grande parte dos problemas de converses e adaptaes de maneira automtica. Neste tpico voc conhecer o suporte ao trabalho com datas e horas oferecido pelo Object Pascal.
Dias, meses, anos... O Object Pascal oferece muitos mtodos de trabalho com dados que contm datas. A classe fundamental para o trabalho om datas TDateTime que, alm da data, armazena tambm horas, minutos e segundos. Contudo, existem classes especficas para manipulao de horas e datas separadamente. A classe TTime manipulada dados referente a horas, enquanto TDate trabalha exclusivamente com datas. Existem ainda muitas funes e procedimentos que permitem-lhe fazer praticamente qualquer coisa razovel com datas e horas. A tabela abaixo lista algumas destas rotinas e o seu significado.
Rotina CompareDate CompareDateTime CompareTime CurrentYear Date Time Now DateOf DateTimeToFileDate DateTimeToSystemTime DateTimeToTimeStamp DayOfTheMonth DayOfTheWeek DayOfTheYear DayOfWeek DaysBetween DaysInAMonth DaysInAYear DaySpan DecodeDate DecodeDateDay DecodeDateFully DecodeDateMonthWeek DecodeDateTime DecodeDateWeek DecodeDayOfWeekInMonth DecodeTime EncodeDate Descrio Indica a relao entre 2 pores de 2 valores TDateTime. Indica a relao entre 2 valores TDateTime Indica a relao entre 2 pores de hora de 2 valores TDateTime. Retorna o ano corrente no calendrio Gregoriano. O valor retornado um nmero de quatro dgitos. Retorna a data atual. Retorna a hora atual. Retorna a data e hora atuais. Retorna a data de um TDateTime. Converte um TDateTime para um tipo TimeStamp do sistema operacional. Converte um TDateTime em um TSystemTime da API do Win32. Converte um TDateTime em um TTimeSTamp. Retorna o nmero de dias de um determinado ms. Retorna o nmero de dias de uma semana. Retorna o nmero de dias de um determinado ano. Retorna o nmero de dias da semana de uma data especificada. Retorna o nmero de dias entre duas datas especificadas. Retorna o nmerode meses de um determinado ano. Retorna o nmero de dias de um determinado ano. Retorna o nmero de dias entre 2 datas, incluindo fraes de dias. Retorna o ano, ms e dia de uma data. Retorna o ano e dia de uma data. Retorna o ano, ms, dia e dias da semana de uma data. Retorna o ano, ms, semana do ms e dia da semana de uma data. Retorna ano, ms, dia, hora, minuto, segundo e milisegundos de uma data. Retorna o ano, semana do ano e dia a semana de uma data. Para uma determinada data, retorna o ano, ms, dia da semana e o dia do ms. Quebra um TDateTime em horas, minutos, segundos e milisegundos. Retorna um TDateTime que representa um determinado ano, ms e dia.
55
EncodeDateDay EncodeDateMonthWeek EncodeDateTime EndOfADay EndOfAmonth EndOfAWeek EndOfAYear FormatDateTime HoursBetween HourSpan IncAMonth IncDay IncHour IncMiliSecond IncMinute IncSecond IsValidDateTime IsValidDateWeek IsValidTime IsLeapYear
Retorna um TDateTime que representa um determinado dia do ano para um determinado ano. Retorna um TDateTime que representa um dia de uma semana em um ms e anos especficos. Retorna um TDateTime que representa um ano, ms, dia, hora, minuto, segundo e milisegundo. Retorna um TDateTime que representa o ltimo milisegundo de um determinado dia. Retorna um TDateTime que representa o ltimo milisegundo do ltimo dia de um ms. Retorna um TDateTime que representa o ltimo milisegundo de dia de uma semana. Retorna um TDateTime que representa o ltimo milisegundo de um determinado ano. Formata um TDateTime. Retorna o nmero de horas entre 2 TDateTime. Retorna o nmero de horas (incluindo horas fracionrias) entre 2 TDateTime. Incrementa a data em um ms. Incrementa a data em um dia. Incrementa a data em uma hora. Incrementa a data em um milisegundo. Incrementa a data em um minuto. Incrementa a data em um segundo. Indica se os valores para ano, ms e dia especificam uma data vlida. Indica se um determinado ano, ms e dia da semana especificam uma data vlida. Indica se uma determinada hora, minuto, segundo e milisegundo especificam uma data vlida. Indica se um ano especificado um ano bissexto.
Embora a lista acima possa parecer muito extensa, ela apenas uma amostra das rotinas disponveis para trabalho com datas. Voc pode obter uma lista completa consultando a ajuda do Delphi.
Interpretando horas Vamos mostrar alguns exemplos do uso de algumas das rotinas mencionadas na tabela acima. Normalmente, voc no precisa se preocupar com os detalhes mais profundos do trabalho com datas, a no ser que sua aplicao trabalhe massivamente com clculos de datas e coisas semelhantes. O procedimento DecodeDate pode ser usado quando voc precisa saber qual o dia, ms ou ano de uma data. Por exemplo.
var DT: TDateTime; Dia, mes, ano: word; S: string; Begin Dt := Date;//Assinala a data de hoje para a varivel Dt DecodeDate(Dt, Ano, Ms, Dia); Case 1: s 2: s 3: s 4: s 5: s 6: s 7: s 8: s 9: s Ms of := Janeiro; := Fevereiro; := Maro; := Abril; := Maio; := Junho; := Julho; := Agosto; := Setembro;
56
10: s := Outubro; 11: s := Novembro; 12: s := Dezembro; end; ShowMessage(Ns estamos em + S + !); end;
A funo FormatDateTime retorna uma string contendo a formatao de datas usada no computador atual.
ShowMessage(FormatDateTime('"The meeting is on " dddd, mmmm d, yyyy, " at " hh:mm AM/PM', Now + 0.125);
O exemplo acima exibir uma caixa de mensagem exibindo uma mesnagem com a data especificada no formato indicado na string dddd, mmmm, yyyy, onde d = dia, m = ms e y = ano. Existem muitos outros formatos vlidos. Para uma listagem completa, consulte a ajuda do Delphi.
57
CAPTULO 5 - PROCEDIMENTOS
E FUNES
Este captulo introduzir a idia de procedimentos e funes de aplicativos. Em Delphi, praticamente todo o cdigo que voc escreve em seus aplicativos so inseridos no escopo de procedimentos ou funes. Voc perceber que o domnio das tcnicas de criao destes recursos fundamental para o desenvolvimento de aplicaes, tanto no Windows quanto no Linux. Procedimentos e funes tambm esto diretamente associados ao controle de fluxo de seus aplicativos, o que significa que podem, no meio de seu escopo, desviar a execuo do aplicativo para outro ponto de seu cdigo. Talvez a principal vantagem do uso de procedimentos e funes que eles trabalham de forma a modularizar as aplicaes. De fato, cada procedimento ou funo pode implementar uma funcionalidade completa em um aplicativo. Voc conhecer tambm algumas tcnicas de trabalho com procedimentos e funes, bem como a diferena essencial entre eles.
58
Procedimentos e funes
Proecedimentos e funes podem ser definidos como rotinas executadas por um aplicativo. Esta definio genrica pode parecer insuficiente, mas aproxima-nos da idia real do seu significado. O Object Pascal trabalha com um procedimentos como uma rotina de execuo definida dentro de uma unidade de cdigo. Um procedimento possui um escopo, isto , um corpo de cdigo-fonte no quial voc escreve seu cdigo. O incio deste escopo definido pela palavra reservada begin, e encerrada por um end;.Tudo o que estiver dentro destes dois delimitadores est dentro do escopo do procedimento. No caso de funes, todas estas afirmaes continuam vlidas, mas existem diferenas reais entre procedimentos e funes.
Diferenciando procedimentos e funes A maior diferena existente entre procedimentos e funes se refere utilidade de ambos. Enquanto um procedimento uma rotina encerrada em s mesma, uma funo sempre dever retornar um valor. No Object Pascal, este valor pode ser qualquer tipo de dado aceito, bem como uma classe ou objeto. O diagrama abaixo exibe o esquema de comportamento bsico dos procedimentos e funes: O dado retornado por uma funo pode tambm ser nil, isto , nada foi retornado. Os mtodos das
Procedure
Function
Dado
classes no Object Pascal so constitudos de procedimentos e funes implementados pelos objetos.
Conhecendo procedimentos e funes

Como vimos, procedimentos (procedure) e funes (functions) so referidas coletivamente como rotinas e esto contidas em blocos que podem ser chamados em diferentes lugares em um programa. Uma funtion uma rotina que retorna um valor quando executada; uma procedure no retorna resultados. Como as funes retornam um valor, podem ser usadas em expresses de assinalamento e operaes tais como: I := SomeFunction; Chamadas de procedimentos podem ser usadas como rotinas completas; por exemplo:
59
DoSomething; Os procedimentos e funes podem se chamar recursivamente.
Declaraes de procedimentos A declarao de um procedimento tem a seguinte forma:
procedure procedureName parameterList ;directives localDeclarations begin
statements
end;
Onde procedureName qualquer identificador vlido; statements uma sequncia de rotinas que so executadas quando o procedimento chamado e (parameterList), directives; e localDeclarations; so opcionais. Aqui est um exemplo de uma declarao de procedimento:
procedure NumString(N:Integer;var S:string ); var
V:Integer;
begin
V :=Abs(N); S :='';
repeat
S :=Chr(V mod 10 +Ord('0'))+S; V :=V div 10; until V =0; if N <0 then S :='-'+S; end ; Dada esta declarao voc pode chamar o procedimento NunString.
Declaraes de funes A declarao de uma funo parecida com a de um procedimento, exceto que ela especifica um tipo de retorno e o seu valor. Elas tm a seguinte forma:
function functionName parameterList :returnType directives localDeclarations
begin statements
end;
60
Onde functionName qualquer identificador vlido, returnType qualquer tipo de dado, statements uma sequncia de rotinas que so executadas quando a funo chamada, e (parameterList), directives; , e locaDeclarations; so opcionais. O bloco de rotina das funes governado pelas mesmas regras que se aplicam aos procedimentos; em um desses blocos voc pode declarar variveis e outros identificadores. Adicionalmente o nome da funo age como uma varivel especial que armazena seu valor de retorno, como em uma varivel pr-definida Result. Por exemplo,
function WF:Integer; begin
WF :=17; end ; Defini uma funo chamada WF, que no tem parmetros e sempre retorna o valor inteiro 17. Esta declarao equivalente a:
function WF:Integer; begin
Result :=17; end ; Nota: voc pode assinalar um valor para result ou para o nome da funo repetidamente dentro de um bloco. Embora possa ser dado qualquer nome (identificador) a um procedimento ou funo, muitas vezes existem padronizaes interessantes de nomenclatura. As funes , devido ao fato de retornarem valores, muitas vezes comeam com a expresso get (como em getColor). Os procedimentos tm nomes que explicam as suas funcionalidades. Se agem de forma a gravar dados ou alter-los de alguma forma, s vezes tm o nome precedido pelas expresses set ou do (como em setColor ou doColor).
Overloading
de procedimentos e funes
Voc pode declarar mais de uma rotina com o mesmo nome dentro de um mesmo escopo. Isto chamado overloading, o que significa uma indicao para o compilador da existncia de outras rotinas com o mesmo nome. Isto s possvel se as rotinas com o mesmo nome tiverem uma lista de parametros diferentes. Considere as seguintes declaraes:
function Divide(X,Y:Real):Real;overload ; begin
Result :=X/Y; end ; function Divide(X,Y:Integer):Integer;overload ;

begin
Result :=X div Y; end ; As duas declaraes acima tm o nome Divide, mas exigem parametros de diferentes tipos. Ao chamar Divide o compilador determina qual funo evocar, examinando a lista de parametros passados. O recurso de Overloading exige a distino pelo nmero de parametros ou os tipos de parametros. 61
Assim os seguintes pares de declaraes causam um erro de complilao:
function Cap(S:string ):string ;overload ;
procedure Cap(va Str:string );overload ;
Mas as declaraes seguintes so legais. function Func(X:Real;Y:Integer):Real;overload ;
function Func(X:Integer;Y:Real):Real;overload ;
Valor padro de parmetros Voc pode expecificar valores padres para parmetros em procedimentos ou funes. Valores padres so permitidos apenas para tipos ordinais, e podem ser providos apenas como ltimo parmetro na declarao dos procedimentos ou funes. Por exemplo:
procedure FillArray(A:array of Integer;Value:Integer =0);
Onde o parametro Value j previamente assinalado para 0. As seguintes chamadas para o procedimento acima so equivalentes: FillArray(MyArray); FillArray(MyArray,0); Nota: no possvel declarar multiplos parmetros com valor padro.
62
CAPTULO 6 - OBJETOS
E CLASSES
Este captulo nos introduzir em conceitos importantes do Objetc Pascal e da programao orientada a objetos, como classes, objetos, propriedades e ponteiros. Como o Object Pascal uma linguagem estritamente orientada a objetos o conhecimento destes pontos fundamental para o desenvolvimento de aplicativos. Voc conhecer tambm alguns mtodos e recursos de herana e polimorfismo que esto presentes ao longo de toda a hierarquia de classes e objetos disponvel com o Delphi.
63
Tipo de Classe (class type )

Uma classe (class), ou class type, define uma estrutura composta de campos (fields), mtodos (methods) e propriedades (properties). Instncias de um class type so chamados objetos. Os campos, mtodos e properiedades de uma classe so chamados seus componentes ou membros.
Campos de tipos Um campo essencialmente uma varivel que parte de um objeto. Como os campos de um record, os campos de uma classe representam dados que existem em cada instncia da classe. Um mtodo um procedimento ou funo associado com uma classe. Muitos mtodos operam sobre objetos, isto , instncias de uma classe. Alguns mtodos (chamados mtodos de classes) operam sobre os tipos de classes mesmo. Uma propriedade uma interface para um dado associado com um objeto (freqentemente armazenado em um campo). As propriedades tm especificadores de acesso, que determinam como seus dados so lidos e modificados. De outras partes de um programa fora do objeto em s uma propriedade aparece em muitos casos como um campo. Os objetos so dinamicamente alocados blocos de memria cuja estrutura determinada por seus tipos de classe (class type). Cada objeto tem uma nica cpia de todos campos definidos na classe, mas todas as instncias de um classe compartilham os mesmos mtodos. Os objetos so criados e destrudos por mtodos especiais chamados contrutores (constructors) e destruidores (destructors). Uma varivel de um tipo de classe atualmente um ponteiro que referencia um objeto. Assim, mais de uma varivel podem referenciar o mesmo objeto. Como outros ponteiros, variveis de class type podem conter o valor nil. Mas voc no precisa explicitamente desreferenciar uma varivel de tipo de classe para acessar o objeto para o qual aponta. Por exemplo: SomeObject.Size := 100 Assinala o valor 100 para a propriedade size do objeto referenciado po SomeObject.
Um tipo de classe deve ser declarado e recebido um nome antes que ele possa ser instanciado. Declare classes apenas em sees de escopo global de um programa ou unidade, no em declaraes de procedimentos e funes. Uma declarao de um tipo de classe tem a seguinte forma:
type className = class (ancestorClass)
memberList
end;
onde className qualquer identificador vlido, ascestorClass opcional e se refere classe da qual ClassName derivada e memberList declara membros, isto , campos, mtodos e propriedades da classe. Se voc omitir AncestorClass, a nova classe herda diretamente da classe Tobjetc. Se voc inclui AncestorClass e memberList est vazio, voc pode omitir o end. Uma declarao de tipo de classe pode tambm incluir uma lista de interfaces implementadas pela classe. Os mtodos aparecem na declarao da classe como cabealhos de funes e procedimentos sem qualquer corpo. Por exemplo, veja a declarao da classe TmemoryStream, encontrada na unidade Classes.pas.
type TMemoryStream = class(TCustomMemoryStream) private 64
FCapacity: Longint; procedure SetCapacity(NewCapacity: Longint); protected function Realloc(var NewCapacity: Longint): Pointer; virtual; property Capacity: Longint read FCapacity write SetCapacity; public destructor Destroy; override; procedure Clear; procedure LoadFromStream(Stream: TStream); procedure LoadFromFile(const FileName: string); procedure SetSize(NewSize: Longint); override; function Write(const Buffer; Count: Longint): Longint; override; end;
TmemorySTream descende de Tstream, herdando muitos de seus membros. Mas ele define (ou redefine) muitos mtodos e propriedades, incluindo seu mtodo destruidor Destroy. Seu mtodo construtor, Create, herdado, sem alteraes, de Tobject e, assim, no redeclarado. Dada esta declarao, voc pode criar uma instncia de TmemorySTream da seguinte forma: var
stream: TMemoryStream; stream := TMemoryStream.Create;
Herana e escopo Quando voc declara uma classe, posvl especificar seu ancestral imediato. Por exemplo:
type TSomeControl = class(TControl);
declara uma classe chamada TSomeControl que descende de TControl. Um tipo de classe automaticamente herda todos os membros de seu ancestral imediato. Cada classe pode declarar novos membros e pode redefinir outros herdados, mas uma classe no pode remover membros definidos em seu ancestral. O escopo de um identificador de um membro inicia no ponto onde o membro declarado e continua at o final da declarao da classe.
TObject e TClass
A classe Tobject, declarada na unidade System.pas, o ltimo ancestral de todas as outras classes. Tobject denine apenas alguns mtodos, incluindo contrutores e destruidores bsicos. Adicionalmente a Tobjetc, podemos encontrar declarado na mesma unidade a classe Tclass
TClass: TClass = class of TObject; Para mais nformaes sobre Tobject, consulte a ajuda on-line.
65
Compatibilidade de tipos de classes Um tipo de classe compatvel em termos de atribuio com seu ancestral. Isto significa que uma varivel de um tipo de classe pode referenciar uma instncia de qualquer tipo descendente. Por exemplo, dadas as seguintes declaraes: type
TFigure = class(TObject); TRectangle = class(TFigure); TSquare = class(TRectangle);
var
Fig: TFigure;
A varivel Fig pode ser atribuda valores dos tipos Tfigure, Trectangle e Tsquare.
Tipos de objetos ( Object Type ) Como uma laternativa para tipos de classes, voc pode declarar tipos de objetos usando a sintax: type objectTypeName = object (ancestorObjectType) memberList end; onde ObjectTypeName qualquer identificador vlido, ancestorObjectType opcional e MemberList declara campos, mtodos e propriedades. Se ancestorObjectType omitido, ento o novo tipo no tem qualquer ancestral. Object Types no podem ter membros publicados. Uma vez que Object Types no descendem de Tobject, eles no providenciam qualquer mecanismo construtor, destruidor ou mtodos, o que lhe obriga a criar e destruir instncias de um objetc type usando o procedimento New e Dipose, respectivamente. Nota: Objetc Types so suportados apenas por compatibilidade com cdigos pascal antigos. Seu uso no recomendado no ambiente Delphi atual.
Visibilidade de membros de classes

Todo membro de uma classe tem um atributo chamado visibilidade, que indicado por uma das palavras reservadas private, protected, public, published ou automated. Por exemplo: published property Color: TColor read GetColor write SetColor;
declara uma propriedade publicada chamada Color. A visibilidade determina onde e como um membro pode ser acessado, com private representando o menor acessibilidade, protected representando um nvel intermedirio de acessibilidade e public, published e automated representando a maior acessibilidade. Se uma declarao de membro aparece sem seu prprio especificador de visibilidade, ter a mesma visibilidade do membro que o precede. Membros declarados no incio da declarao de classe tm especificador de visibilidade published como padro.
66
Para facilitar a leitura do cdigo, melhor organizar a declarao de visibilidade colocando todos os membros aps os seus respectivos especificadores de visibilidade. Assim, uma declarao de classe tpica deveria parecer-se com o cdigo abaixo: type
TMyClass = class(TControl)
private
{ private declarations here}
protected
{ protected declarations here }
public
{ public declarations here }
published
{ published declarations here }
end;
Voc pode aumentar a visibilidade de um membro em uma classe descendente ao redeclar-lo, mas no pode diminuir sua visibilidade. Por exemplo, uma propriedade definida como protected pode ser feita public em um descendente, mas no private. No obstante, membros definidos como published podem se tornar public em uma classe descendente.
Membros private , protected e public Um membro definido como private invisvel fora da unidade ou programa onde sua classe declarada. Em outras palavras, um mtodo private no pode ser chamado de outro mdulo e um campo ou propriedade private no podem ser lidos ou escritos a partir de outro mdulo. Um membro definido como protected visvel em qualquer lugar do mdulo onde a classe declarada e tambm para classes descendentes. EM outras palavras, um mtodo protected pode ser chamado ou propriedades e campos lidos ou escritos, a partir da definio de qualquer mtodo ao longo da classe que descende daquela para a qual o membro protected declarado. Membros declarados apenas para uso na implementao de classes derivadas so usualmente declarados como protected. Um membro definido como public visvel onde quer que sua classe seja referenciada.
Membros published Membros declarados como published tm a mesma visibilidade que aqueles declarados como public. A diferena entre eles que a Runtime Type Information (RTTI) gerada para membros definidos como published. A RTTI usada para acessar valores e propriedades de um objeto aosalvar ou carregar arquivos de formulrios, exibir propriedades no Object Inspector e outras funes. Todos os mtodos so publicveis, mas uma classe no pode publicar dois ou mais mtodos sobrescritos (overloading) com o mesmo nome. Os campos s podem ser publicados se forem de uma classe ou tipo interface. Voc define um membro como published quando deseja que o desenvolvedor o manipule diretamente na IDE do Delphi, assim como em tempo de execuo.
67
Membros automated 1 Membros definidos como automated tm a mesma visibilidade que os definidos como public. A diferena que a Automation type information (requerida para servidores Automation) gerada para os membros automated. Membros automated tipicamente aparecem apenas em classes exclusivas da programao para Windows, e no so recomendados para a programao Linux. As seguintes restries se aplicam a mtodos e propriedades declaradas como automated: Os tipos de todas as propriedades, parmetros de array, parmetros de mtodo e resultado de funes devem ser compatveis com os tipos de dados suportados por Automation. Estes tipos so: Byte, Currency, Real, Double, Longint, Integer, Single, Smallint, AnsiString, WideString, TdateTime, Variant, OleVariant, WordBool e todos os tipos interface. Declaraes de mtodos devem usar a conveno padro de chamada Register. Elas podem ser virtuais, mas no dinmicas. A declarao de propriedades podem incluir especificadores de acesso (read e write) mas outros especificadors (index, stored, default, nodefault) no so permitidos. Os especificadores de acesso devem listar um identificador de mtodo que use a conveno de chamada register. Identificadores de campos no so permitidos. As declaraes de propriedades devem especificar um tipo. Override de propriedades no permitido.
A declarao de um mtodo ou propriedade automated pode incluir uma diretiva dispid. No Windows, esta diretiva deve ser seguida de uma constante inteira que especifica um identificador (ID) de despacho Automation para o membro. Do contrrion o compilador automaticamente assinala o ID de um mebro como um maior do que o maior ID usado por qualquer mtodo ou propriedade na classe ou seus ancestrais.
Campos
Um campo como uma varivel de um objeto. Os campos podem ser de qualquer tipo, incluindo tipos de classes; isto , campos podem armazenar referncias a outros objetos. comum definir campos como private. Para definir um campo de uma classe, simplesmente declare o campo como voc faria com uma varivel. Todas as declaraes de campos devem ocorres antes de qualquer declarao de propriedade ou mtodo. Por exemplo, a seguinte declarao cria uma classe chamada TNumber cujo nico membro um campo inteiro chamado Int: type TNumber = class Int: Integer; end;
Mtodos
Um mtodo um procedimento (procedure) ou funo (function) associado a uma classe. Uma chamada a um mtodo especifica o objeto ou, se for um mtodo de uma classe, uma classe. Por exemplo
SomeObject.Free
1 O estudo da tenologia COM e Automation ser feita no segundo curso.
68
Chama o mtodo Free em SomeObject.
Declaraes e implementaes de mtodos Dentro de uma declarao de classe, os mtodos aparecem como cabealhos de procedimentos e funes que trabalham como declaraes forward. Em algum lugar aps a declarao da classe, mas dentro do mesmo mdulo, cada mtodo implementado ao definir a sua declarao. Por exemplo, suponha que a declarao de TmyClass inclua um mtodo cahamado DoSomething: type
TMyClass = class(TObject)
procedure DoSomething; end; //A defining declaration for DoSomething must occur later in the module: procedure TMyClass.DoSomething; begin
//
end; Enquanto uma classe pode ser declarado em ambas sees interface ou implementation de uma unidade, a definio da declarao para um mtodo de uma classe deve estar na seo implementation. As declaraes de mtodos podem incluir diretivas especiais que no so usados com outras funes e procedimentos. As diretivas devem aparecer apenas na declarao da classe, no na definio da declarao. Entre estas diretivas podemos citar: overload; asbtract; virtual; dynamic; override; stdcall.
Inherited
A palavra reservada inherited implementa uma regra especial relacionada a um contexto de polimorfismo. Ela pode ocorrer em definies de mtodos, com ou sem identificadores aps ele. Se Inherited seguida de um nome de um membro, representa uma chamada comum de um mtodo ou um referncia a uma propriedade ou campo. Como no exemplo: inherited Create(...); Quando aps inherited no segie qualquer identificador, el e se refere ao mtodo herdade xom o mesmo nome do mtodo definido.
O uso de Inherited e suas capacidades ocorre freqentemente na implementao de mtodos contrutores, que chamam inherited com os mesmos parmetros que forma passados ao descendente.
Self
Dentro da implementao de um mtodo, o identificador Self referencia o objeto no qual o mtodo chamado. Por exemplo, segue abaixo a implementao do mtodo Add de Tcollection.
69
function TCollection.Add: TCollectionItem; begin Result := FItemClass.Create(Self); end; O mtodo Add chama o mtodo Create na classe referenciado pelo campo FitemClass, que sempre um descendente de TcollectionItem. Self til por uma srie de razes. Por exemplo, um identificador de um membro declarado em um tipo de classe poderia ser redeclarado no bloco de um dos mtodos da classe. Neste caso, possvel acessar o identificador do membro original como Self.Identifier
Tipos de mtodos Os mtodos podem ser estticos (static, o padro), virtuais (virtual) ou dinmicos (dynamic). Mtodos virtuais e dinmicos podem ser sobrescritos e eles podem ser abstratos (abstract). Estas designaes so utilizadas quando uma varivel de um tipo de classe armazena um valor de um tipo de classe descendente. Elas determinam que implementao ativada quando o mtodo chamado.
Mtodos estticos Os mtodos so, por padro, estticos. Quando um mtodo esttivo chamado, o tipo declarado de uma classe ou varivel de objeto usada na chamada do mtodo determina que implementao ativada. No exemplo seguinte, os mtodos Draw so estticos:
type TFigure = class procedure Draw; end; TRectangle = class(TFigure) procedure Draw; end;
Dadas estas declaraes, o cdigo abaixo ilustra o efeito da chamada de um mtodo esttico. Na segunda cahamada para Figure.Draw, a varivel Figure referencia um objeto da classe TRectangle, mas a chamada invoca a implementao de Draw em TFigure, pois o tipo declarado de Figure TFigure.
var Figure: TFigure; Rectangle: TRectangle; begin Figure := TFigure.Create; Figure.Draw; // calls TFigure.Draw Figure.Destroy; Figure := TRectangle.Create; Figure.Draw; // calls TFigure.Draw 70
TRectangle(Figure).Draw; // calls TRectangle.Draw Figure.Destroy; Rectangle := TRectangle.Create; Rectangle.Draw; // calls TRectangle.Draw Rectangle.Destroy; end;
Mtodos virtuais Mtodos virtuais so chamados da mesma forma que os mtodos estticos, mas, como os mtodos virtuais podem ser modificados, o compilador no sabe o endereo de uma funo virtual em articular quando voc a chama em seu cdigo. Por isso, o compilador constri uma Virtua Method Table (VMT), que fornece um meio para pesquisar endereos de funes em tempo de execuo. A VMT de um objeto contm todos os mtodos virtuais de seus ancestrais, bem como os que ele mesmo declara; por esta razo, os mtodos virtuais usam mais memria do que os dinmicos, embora sejam executados com mais rapidez. Veja abaixo um exemplo de declarao de um mtodo virtual:
procedure MetodoVirtual; virtual;
Mtodos dinmicos Os mtodos dinmicos so, basicamente, mtodos virtuais com um sistema de despacho diferente. O compilador atribui um nmero exclusivo a cada mtodo dinmico e usa estes nmeros, juntamente com o endereo de memria do mtodo, para construir uma Dynamic Method Table (DMT). Ao contrrio da VMT, a DMT de um objeto contm apenas os mtodos dinmicos que declara. Por isso, os mtodos dinmicos fazem uso menos intensivo de memria do que os mtodos virtuais, mas eles so mais demorados de se chamar, pois voc pode Ter que propagar atravs de vrias DMTs ancestrais antes de encontrar o endereo de um mtodo dinmico em particular. Tanto os mtodos virtuais como os dinmicos so usados para oferecer suporte s tecnologias COM e OLE da Microsoft. Procedimentos de objetos COM (como os de um controle ActiveX, por exemplo) fazem uso comum de variants e mtodos dinmicos como mecanismo de linking remoto de um aplicativo cliente com algum recurso oferecido por um aplicativo servidor que no conhecido durante o processo de compilao de seu aplicativo.
71
CAPTULO 7 - CONHECENDO
VCL
E A
CLX
Tradicionalmente, o Delphi vem colocando disposio dos programadores uma grande quantidade de classes e componentes presentes em bibliotecas de componentes, particularmente a Visual Component Library (VCL) que acompanha o Delphi desde sua primeira verso. Ao longo dos anos a VCL foi imensamente incrementada no s pelos novos componentes e classes inseridos pela Borland em novas verses do Delphi mas, principalmente, pela gigantesca produo de componentes e bibliotecas inteiras desenvolvidos por diversos desenvolvedores em todo o mundo. Com o lanamento do Delphi 6, a Borland colocou disposio dos desenvolvedores uma nova biblioteca de componentes denominada Component Library for Cross-Platform (CLX), cuja caracterstica principal a portabilidade entre plataformas. Ou seja, um aplicativo desenvolvido sob a base CLX possui cdigo-fonte compatvel com as plataformas Windows e Linux. Neste captulo estudaremos a estrutura da VCL e da CLX, assim como seus componentes centrais, e como voc pode gerar aplicativos completamente portveis do mundo Windows para o Linux ou deste para o mundo Windows.
72
Bibliotecas de classes no Delphi 6

Tradicionalmente, o Delphi vem colocando disposio dos programadores uma biblioteca de componentes conhecida como Visual Component Library (VCL), onde se pode encontrar todos os objetos e classes disponveis para manipulao e construo dos mais diversos tipos de aplicativos. Embora o nome da VCL indique o contrrio, a maioria dos objetos e classes contidos na VCL no so propriamente visuais, mas existe tambm uma grande quantidade deles que o so. Toda a VCL constituda sob a base de herana de TObjetc, o que quer dizer que no existem classes que no derivem de alguma forma de TObjetc. Para entender bem o que seja a VCL preciso que compreendamos os seguintes pontos: A VCL uma biblioteca hierrquica de componentes e classes, o que quer dizer que todos os seus elementos esto dispostos dentro de uma estrutura de herana e derivao estritamente orientado a objetos. A VCL possui uma estrutura altamente expansvel, ou seja, qualquer programador Delphi pode criar novos objetos ou mesmo bibliotecas inteiras de objetos que so inseridos no contexto geral da VCL. Uma vez isto feito, estes novos objetos esto j disponveis para servirem de classes ascendentes de novos objetos que forem criadas. A VCL uma biblioteca intrinsecamente ligada plataforma Windows, encapsulando muitos dos objetos comuns disponveis em dlls como CommCtrl.dll e OleAut32.dll.
O Delphi 6 tornou disponvel aos programadores uma inteiramente nova biblioteca de componentes conhecida como CLX. Como o prprio nome indica, a caracterstica mais marcante da biblioteca CLX a portabilidade entre as plataformas Windows e Linux. Esta novidade trouxe muitas mudanas e novas perspectivas para os programadores Delphi que viram, assim, um novo conjunto de possibilidades no desenvolvimento de aplicativos.
Conhecendo a VCL
A Visual Component Library (VCL) deve ser usada toda vez que voc desejar criar uma aplicativo Win32. Grande parte dos objetos presentes na VCL so construdos atravs de chamadas a rotinas da API do Win32, como o caso de TToolBar, TCoolBar, TToolButton, TButton, TRadioButton etc. Isto possibilita uma grande compatibilidade entre seus sistemas e novas verses do sistema operacional. Uma vez que alteraes nas rotinas da API (como, por exemplo, novos comportamentos de menus e botes no Windows XP) so automaticamente aceitas pelos componentes de seu aplicativo. Contudo, voc precisa estar consciente de que a VCL no oferece qualquer portabilidade para a plataforma Linux, ainda que grande parte do cdigo de seu aplicativo VCL possa ser aproveitado sem alteraes em uma aplicativo que trabalhe com a CLX. A VCL foi projetada com a finalidade especfica de proporcionar o trabalho dentro de um ambiente visual. Em vez de criar uma janela e adicionar seu comportamento no cdigo, voc pode modificar as caractersticas comportamentais e visuais dos componentes medida que elabora o programa visialmente. No Delphi 6 voc inicia um novo aplicativo VCL ao selecionar File | New | Application, e muitos recursos disponveis no Object Repository so exclusivo de aplicaes VCL. Isto se explica pelo fato de no haver suporte no Linux a diversas tecnologias como objetos COM, Automation, MTS, COM+, CoolBars etc. Estas tecnologias so aplicveis apenas ao mundo Linux. Devido ao fato de a VCL ser uma biblioteca completa e extensa, voc pode estar certo de que no h nada na plataforma Windows que no possa ser feito com a manipulao de suas classes. Usando a VCL e o compilador Delphi voc pode fazer coisas que vo de Fontes True Type a grandes sistemas de bancos de dados remotos e, para citar novas tecnologias, objetos COM+, MTS e aplicativos .NET. Esta abrangncia fez com que a prpria Microsoft reconhecesse o Delphi como ferramenta preferencial no desenvolvimento de solues Windows, assinando acordos de troca de tecnologias (principalmente para aplicaes WEB) com a Borland.
73
Quando voc cria um novo componente ou classe voc est, na verdade, adicionando-os VCL atravs dos mtodos de derivao de classes e herana de um dos objetos da hierarquia da VCL. A VCL permite tambm que voc altere as caractersticas de um componente ou classe j existente (desde que voc possua o cdigo-fonte deles), o que trar automaticamente as mesmas mudanas em todas outras classes que utilizem de alguma forma a classe alterada.
Classes razes da VCL A VCL possui algumas classes que so centrais em toda a hierarquia. Isto significa que estas classes implementam tipos de objetos bastante diferentes dos seus ascendentes e serve muitas vezes de ponto de partida para criao de muitos tipos de classes e componentes. Para esclarecer este aspecto, preciso compreender alguns tipos de objetos existentes ao longo da VCL. Em termos gerais, podemos dizer que na VCL existem: Classes . So objetos no visuais que no podem ser considerados componentes e, portanto, no so instalados na Component Pallete. Exemplos de classes so TSTrings, TSTream, TRegistry e muitos outros. Componentes . So, no sentido exato da expresso, objetos no visuais que so instalados, mas no fazem parte da interface com o usurio de um aplicativo. Os exemplos mais tpicos so classes que manipulam dados em um banco de dados, como TTable, TIBQuery ou TADOCommand. Controles . So componentes visuais que so usados na construo da interface com o usurio. Existem controles grficos e controles com manipulador de janelas (Handle). Os primeiros so usados como elementos importantes no desenho de uma janela, e os outos como elementos da interface que possibilitam entrada (input) de dados do usurio via teclado, mouse ou outro dispositivo.
Esta classificao indica-nos que componentes, na verdade, so os descendentes da classe TComponent em diante (componentes e controles), ainda que se use este termos de forma bastante generalizada. Veja abaixo um diagrama extremamente simplificado da estrutura central da VCL.
TObject A classe TObject o descendente ltimo de todas as outras classes e componentes presentes na VCL. Isto significa que impossvel voc criar uma classe que no descenda (em ltima instncia) de TObject. Conseqentemente todas as outras classes e componentes herdam as propriedades e mtodos definidos para TObject que so:
Propriedades Name Tag Descrio Fornece o nome da instncia da classe ou objeto Valor inteiro para uso geral
Mtodos Create Free
Descrio Fornece mecanismos gerais de instanciao do objeto Implementa um mecanismo geral de destruio do objeto instanciado.
74
TPersistent Como se pode observar do diagrama acima, TPersistent descende diretamente de TObject. A caracterstica principal de TPersistent que esta classe implementa controle sobre leitura e escrita de suas propriedades em e para um fluxo. Como todos os componentes so descendentes de TPersistent, suas propriedades se beneficiam desta caracterstica. TPersistent define tambm alguns mtodos principalmente para criadores de componentes. A tabela abaixo relaciona alguns destes mtodos:
Mtodo Assign AssignTo Funcionalidade Permite que um componente atribua a si mesmo os dados associados a outro componente. Este mtodo protegido onde os descendentes de TPersistent devem implementar a definio da VCL para AssignTo. TPersistent, por si s, produz uma exceo quando este mtodo chamado. AssignTo onde um componente pode atribuir seus valores de dados para outra classe ou instmcia o oposto de Assign. Permite aos criadores de componentes definir o modo como um componente armazena suas propriedades extras ou no-publicadas. geralmente usado para fornecer um meio para um componente armazenar dados que no sejam de um tipo simples como, por exemplo, dados binrios.
DefineProperties
TComponent Esta classe descende diretamente de TPersistent. TComponente implementa recursos especiais que permitem a manipulao de um objeto de uma classe que descenda dele em tempo de projeto, a partir do Object Inspector. Ou seja, os descendentes de TComponent podem ser manipulados durante a fase de projeto assim como podem ser instalados na palheta de componentes. TComponent define muitos novos mtodos e propriedades. Entre eles, citamos:
Propriedade Owner ComponentCount ComponentIndex Components Funcionalidade Indica o propriedtrio do componente. Armazena o nmero de componentes que o componente possui. Indica a posio do componente na lista de componentes que o componente possui. Um array contendo os componentes possudos pelo componente.
Mtodo FindComponent GetParentComponent HasParent
Funcionalidade Usado para encontrar (fazer referncia) a um componente pelo seu nome. Retorna a instncia do componente que possui o componente atual. Se no houver nenhum, retorna nil. Indica de o componente possudo por algum outro componente.
No fragmento de cdigo que segue, ilustramos o uso de alguns destes recursos:
var Check: TcheckBox; begin Check := FindComponent(CheckFinaliza); if Check <> nil then begin If Check.HasParent then Check.Checked := True; If Check.Checked then Application.Terminate;
75
End; End;
A varvel Check (do tipo TCheckBox) atribuda a um componente chamado CheckFinaliza. Se este componente encontrado (<> nil), processa-se o seguinte: Se ele for contido por outro componente (HasParent), atribui True sua propriedade Checked; Se a propriedade Checked for True, finaliza o aplicativo (Application.Terminate). Este cdigo apenas uma ilustrao, e pode parecer no possuir muito sentido prtico, mas, de qualquer forma, exibe o uso de alguns mtodos implementados em TComponent.
TControl A classe TControl implementa muitos recursos responsveis por tornar um componente visual. Por exemplo, TControl introduz a capacidade do componente exibir a si mesmo, propriedades de posicionamento como Left, Top, propriedades que definem o seu tamanho como Heigth e Width e muitas outras propriedades. TControl tambm introduz propriedades relacionados visibilidade, disponibilidade e aparncia como Visible, Enabled e Color ou insero de texto o controle como Caption e Text. Outros recursos marcantes implementados com Tcontrol a capacidade dos componentes derivados desta classe responderem a interaes como o mouse, atravs dos eventos OnMouseMove, OnMouseEnter, OnMouseUp, OnMouseDown, OnClick; OnDblClick etc. A maioria dos controles descende de um dos dois descendentes diretos de TControl: TGraphicControl e TWinControl.
TWinControl Os controles padro do Windows descendem de TWinControl. Estes controles padro so objetos que voc pode ver na maioria das aplicaes do Windows, tais como caixas de edio, botes, caixas de combinao, caixas de listagem etc. O Delphi encapsula o comportamento destes controles do Windows em objetos, e no manipula-os diretamente atravs de chamadas da API do Windows. Os descendentes de TWinControl possuem algumas caractersticas que os distingue de outros componentes: Possuem uma ala (um handle) de janela na memria; Podem receber foco de entrada atravs do mouse, teclado ou outro dispositivo; Podem ser pais (conter) de outros componentes.
TWinControl implementa diversas funcionalidades referentes a manipulao de alas de janelas (como em muitas chamadas API do Windows), entrada e sada de foco de input, bem como aparncia do controle. Como programador de aplicaes, voc usar largamente os descendentes de TWinControl em seus aplicativos.
TGraphicCotrol Os descendentes de TGraphicControl so controles visuais, porm possuem diferenas marcantes se comparados aos descendentes de TWinControl: 76
No possuem um a ala de janela do Windows; No podem receber o foco de entrada; No podem conter outros componentes
Descendentes de TGraphicControl devem ser usados sempre que voc deseja exibir algo ao usurio que no exija um comportamento de entrada de dados. Um exemplo comum so imagens ou controles que forneam bordas diferenciadas em uma janela. Como descendentes de TGraphicControl no possuem manipuladores de ala de janela, eles consomem menos recursos do que os controles que possuem esta caracterstica. Alm do mais, o processo de pintura do controle bem mais rpido do que o de outro descendente de TWinControl. Finalmente, os descendentes de TGraphicControl podem responder a mensagens de dispositivo de mouse.
Classes de manipulao de excees

A VCL tambm introduz um conjunto de classes especiais destinadas exclusivamente manipulao de excees em aplicativos. Exception um descendente direto de TObject e implementa os recursos mais gerais de interceptao de excees. Voc no deveria usar a classe Exception em seus aplicativos, mas sim as classes que dele descendem, uma vez que possuem caractersticas mais especficas para manipular tipos particulares de excees. Por exemplo. A exceo gerada pela falta de memria para executar um procedimento diferente daquela causada pela referncia a um ndice inexistente em uma lista de strings. Conseqentemente, certo que precisaramos manipular cada uma destas excees de forma diferenciada. Para isto, a VCL desenvolveu uma grande quantidade de classes de excees, alm de permitir que voc mesmo defina suas prprias classes de excees. Na grade abaixo so listadas algumas das mais importantes classes de excees e suas respectivas funcionalidades.
Classe EAcessViolation EOutOfResources EOutOfMemory EExternal EMathError EIntError EPrivilege EControlC EConvertError EConversionError EDatabaseError EDateTimeError EDBClient EDBEngineError EDivByZero ERangeError EDOMParseError EFCreateError EFOpenError EInvalidGraphic EInvalidGraphicOperation EInvalidGridOperation EInvalidPointer EListError EMCIDeviceError EMenuError Descrio Classe de exceo para erros de acesso invlido de memria. Classe de exceo para alocaes de alas de janelas mal-sucedidas Classe de exceo para acesso a memria mal-sucedido. Classe que captura excees em registros (records) do Windows. Classe-base para manipulao de erros matemticos com nmeros de ponto flutuante. Classe-base para erros com nmeros inteiros. Classe de exceo para manipulao de violao de privilgios do Windows Classe usada para manipular falhas no trmino de aplicativos console ao pressionar-se as teclas Ctrl+C. Classe de manipulao de excees em converses de strings e objetos. Classe de manipulao de excees em erros de converso de medidas. Classe de exceo para erros em bancos de dados. Classe de exceo para entradas invlidas de datas/hora. Classe de exceo para erros em client datasets. Classe de exceo para erros do Borland Database Engine (BDE). Classe de exceo para erros de diviso de inteiros por zero. Classe de exceo para valores inteiros que so muito grandes para o tipo declarado ao qual so atribudos. Classe de exceo de erros que ocorrem quando uma implementao DOM vinculada a um documentos XML. Classe de exceo para erros na criao de arquivos de stream. Classe de exceo para erros que ocorrem quando um arquivo de stream aberto. Classe de exceo para tipos de arquivos grficos no-conhecidos. Classe de exceo para operaes invlidas com objetos grficos. Classe de exceo para operaes invlidas com grades. Classe de excees para operaes invlidas com ponteiros. Classe de exceo para erros em listas e strings. Classe de exceo para dispositivos que provem um driver de MCI (Media Control Interface). Classe de exceo envolvendo items de menus.
77
EOleCtrlError EOleError EOleSysError EOleRegistrationError EOSError EPrinter EReconcileError EUpdateError EWebBrokerException EAbstractError EADOError EIBErrror ESocketConnectionError EXMLDocError EDBEditError
Classe de exceo para erros em controles ActiveX. Clase de exceo para manipulao de erros OLE de baixo nvel. Classe de exceo para erros especficos de uma interface OLE Idispatch. Classe de exceo para erros que ocorrem durante o registro de um objeto OLE. Classe para manipulao de erros do sistema operacional. Classe de exceco para erros de impresso. Classe de exceo para erros de atualizao de client datasets. Classe de exceo para erros de atualizao de um dataset provider. Classe de exceo disparadas por objetos WebBroker. Classe de exceo para erros de chamadas a mtodos abstratos. Classe de exceo para erros de banco de dados gerados por fontes de dados ADO. Classe de exceo para erros em bancos de dados Interbase Classe de exceo para erros que surgem quando do envoi ou recebimento de mensagens usando TSocketConnection. Classe de exceo para erros de edio ou parsing em um documento XML. Classe de exceo para erros de dados que so incompatveis com uma determinada mscara.
Esta lista, apesar de ser um pouco extensa, est muito longe de ser completa. Para uma referncia completa, consulte a ajuda on-line e o mapa de classes da VCL distribudos com o Delphi 6.
Conhecendo a CLX
A Component Library for Cross-Platform (CLX) uma biblioteca hierrquica de componentes desenvolvida para uso no Delphi 6 e no Kylix. Analisando sob uma perspectiva genrica, a CLX possui uma estrutura muito similar VCL, sendo contruda igualmente sob o fundamento de TObject e as classes razes presentes na VCl. Neste tpico estudaremos as principais caractersticas da CLX e como voc poder usa-la para desenvolver aplicativos automaticamente portveis entre a plataforma Win32 e Linux.
Obtendo compatibilidade entre Delphi e Kylix A biblioteca CLX o elemento essencial que promove a total compatibilidade entre o Delphi 6 e o Kylix. Esta compatibilidade existe em trs nveis distintos: A linguagem Object Pascal usada nos dois ambientes; A biblioteca de componentes CLX; A IDE dos 2 ambientes de desenvolvimento.
A linguagem Object Pascal usada pelo Delphi exatamente a mesma que o ambiente Kylix utiliza. Isto torna os programadores Delphi automaticamente aptos para a programao para a plataforma Linux com o Kylix. As diferenas existentes no Object Pascal disponvel no Delphi e no Kylix se referem unicamente aos recursos implementados na VCL que so exclusivos para a programao Windows. Veremos adiante os detalhes desta diferena. A CLX realmente o grande cimento que une a programao visual do Delphi e do Kylix. Se voc desenvolver no Delphi um aplicativo CLX, ele ser 100% compatvel (o que quer dizer tambm compilvel) com o ambiente Kylix. O mesmo cdigo CLX poder ser compilado sem quaisquer alteraes tanto no Delphi (gerando aplicativos Windows) como tambm no Kylix (gerando aplicativos Linux). Disto se pode concluir que o seu cdigo-fonte totalmente compatvel com as 2 plataformas, mas os diversos tipos de executveis e/ou servios que voc desenvolver estaro vinculados ao sistema
78
Windows se forem resultado de uma compilao no Delphi ou, pelo contrrio, estaro prontos para o Linux se os compilar no Kylix.
Amplo suporte ao desenvolvimento WEB e banco de dados Uma das caractersticas mais fortes da CLX (que segue o exemplo da VCL) o forte suporte ao desenvolvimento WEB que apresenta. De fato, ao lado dos mais diversos tipos de executveis comuns que o ambiente Linux suporta, a CLX oferece suporte ao desenvolvimento de qualquer tipo de aplicaes e servios WEB disponveis na plataforma Linux. E voc pode ainda estar certo de obter compatibilidade com o ambiente Windows tambm no desenvolvimento WEB. A CLX tambm segue a tradio da VCL ao oferecer o mais amplo suporte a tecnologias e fontes variadas de dados de bancos de dados. De fato, o Delphi desde j h muitos anos se destaca neste ponto quando comparado com as diversas ferramentas de desenvolvimento disponveis no mercado. Ao longo dos anos, este destaque se tornou cada vez mais evidente e reconhecido pelos mais diversos fornecedores de tecnologia de banco de dados, como comprovam as consecutivas vitrias obtidas pelo produto em testes, concursos etc promovidos por inmeras empresas em todo o mundo. A CLX oferece atualmente suporte a qualquer tipo de banco de dados disponvel no mundo Linux e usa 2 tecnologias bsicas de acesso: a DBExpress e o Acesso nativo. Veremos com muitos detalhes em que consiste este suporte e um dos fundamentos maiores fundamentos da superioridade Delphi/Kylix no acesso a banco de dados: a arquitetura expansvel de TDataset.
Diferenas tecnolgicas bsicas entre a VCL e a CLX

Todas as diferenas fundamentais existentes entre as bibliotecas CLX e VCL dizem respeito ausncia de suporte para algumas tecnologias Windows na CLX. Como a CLX foi desenvolvida para oferecer completa compatibilidade Delphi/Kylix, alguns recursos do mundo Windows que inexistem na plataforma Linux no encontram suporte na CLX, mas podem ser encontrados na VCL. Entre as diferenas bsicas que podemos perceber ao analisar a estrutura e suporte da CLX comparada com a VCL, podemos enumerar: Inexistncia de suporte a tecnologias especificamente Windows como a Registry, tecnologia COM, ActiveX e seus muitos derivados. Inexistncia de suporte para bancos de dados indisponveis na plataforma Linux, como MSAcess, MSSQL Server e Visual FoxPro. Inexistncia de suporte a tecnologias proprietrias Microsoft de acesso a banco de dados que usam COM, como ODBC, DAO, OLEDB e ADO. Inexistncia de suporte a tecnolgias Microsoft de servios WEB baseadas no COM, como ASP. Inexistncia de componentes e controles construdos fortemente sob a arquitetura Win32. Inexistncia de suporte ao Borland Database Engine (BDE).
Como visvel na anlise destes items, percebemos que todo o invejvel suporte s mais diversas tecnologias COM, existentes na VCL, simplesmente inexiste na CLX. E, at onde podemos entender, sempre ser assim, uma vez que estas so tecnologias unicamente aplicveis ao mundo Windows. Podemos ver tambm (e sempre devido s mesmas razes) que componentes construdos baseados em tecnologias Win32 no podem ser encontrados na CLX. Entre estes componentes, citamos aqui toda a srie de controles e componentes para gerao de relatrios conhecidos comumente como QuickReport. Para esclarecer ainda mais este ponto, suponha que voc tenha criado um componente para controle de acessos de usurios em uma rede de servidor de domnio Windows NT. Como seu 79
componente certamente faz chamadas API do NT, lgico que ele no poder ser incorporado CLX. Ou ainda se voc construiu uma biblioteca de componentes para acesso nativo API do MS SQL server; claro que no adianta tentar incorpora-los CLX, pois seus componentes no encontraro em um ambiente Linux o conjunto de dlls que fornecem a interface API para o gerenciador de banco de dados relacional da Microsoft. Quanto BDE, ela foi completamente suplantada pela nova tecnologia DBExpress.
80
CAPTULO 8 - TAREFAS
COMUNS DE PROGRAMAO
Este captulo discute o fundamental sobre algumas das tarefas mais comuns na programao em Object Pascal. Trabalhar com strings, listas de strings, tipos numricos e arquivos so tarefas to comuns, que em praticamente qualquer aplicativo que fizer ter de exercitar esta prtica. Da mesma forma, voc conhecer de que forma pode construir um aplicativo grfico tpico, com menus e barras de ferramentas. O Delphi oferece grande suporte ao desenvolvimento visual e, na verdade, voc pode executar cada uma destas tarefas de maneiras bastante diferentes. Por exemplo, se desejar criar um menu principal em uma aplicao, ter de pensar inicialmente no objeto a ser usado na construo de um menu; perceber, ento, que o Delphi lhe oferece mais de uma opo. Ou, em outro exemplo, ter de decidir que tipo de barra de ferramenta ir usar em sua aplicao etc. Finalamente, voc desenvolver dois aplicativos funcionais que ilustram as tarefas mais comuns na criao de um aplicativo GUI, tanto para a plataforma Windows, quanto para a Linux.
81
Trabalhando com listas de strings

As aplicaes freqentemente precisam manipular listas de caracters (strings). Entre os exemplos de uso deste recurso podem citar o trabalho com grades, arquivos texto, informaes internas do programa, listas armazenadas em controles e muitas outras situaes. O Object Pascal oferece uma grande variedade de procedimentos e funes para trabalhar com estas listas, alm de classes especficas que armazenam listas de strings.
As classes Tstrings e TStringList Tstrings e TStringList so classes fundamentais para o trabalho com listas de strings. Tstrings implementa uma srie de mtodos abstratos para leitura, insero, deleo etc de strings em uma lista indexada baseada em 0. Oferece tambm a capacidade para salvar esta lista em um arquivo texto, bem como abrir um arquivo com este mesmo formato. Voc usa sempre TStrings quando utiliza controles como TcomboBox, TMemo ou TlistBox em suas aplicaes. Os desenvolvedores de aplicaes WEB tambm precisam manipular com freq:uencia instncias de Tstrings. Alguns descendentes de TSTrings so capazes de armazenar uma lista extensa de caracteres em vrias linhas. TstringList herda todas as caractersticas de TSTrings, introduzindo novos mtodos para ordenao de listas e controle de mudanas no contedo da lista. Voc deve sempre criar a lista de strings antes de poder utiliz-la e, ao final do seu uso, destru-la da memria. Isto extremamente simples. Veja o exemplo abaixo:
var StringList: TStrings; begin StringList := TStringList.Create;//cria a lista try with StringList do begin Add('linha 1'); Add('linha 2'); end; finally StringList.free;//destri a lista de strings end; end;
Usando listas de strings com arquivos Para carregar um arquivo texto em uma lista de strings, voc pode usar os mtodos LoadFromFile, passando como parmetro o endereo do arquivo, a fim de que possa edit-lo ou simplesmente ler o seu contedo. Se desejar salvar as alteraes feitas, use o mtodo SaveToFile, passando tambm o endereo do arquivo no seu disco. Carrega a um arquivo na lista / Salva a lista em um arquivo Ex: procedure TForm1.FormCreate(Sender: TObject);
82
var List: TStringList; begin List := TStringList.Create; Try List.LoadFromFile(c:\windows\Readme.txt); List.Add('Estou escrevendo mais uma linha'); List.Add('E agora ainda outra linha'); ListBox1.SaveToFile(c:\windows\Novo arquivo.txt);//salva em arquivo end; finally List.Free; end; end; Entre outras operaes comumente feitas como lista de strings temos: Contagem de strings da lista Acesso a uma string em particular Encontrar e posionar uma string na lista Adicionando uma string lista Movendo strings dentro da lista Deletando strings da lista Copiando uma lista completa de strings
Contando strings na lista A propriedade somente leitura Count retorna o nmeo de strings de uma lista. Uma vez que listas de strings usam ndices baseados em 0, Count um mais o ndice da ltima string.
Acessando uma string em particular A propriedade do tipo array chamada strings contm as strings da lista, referenciadas por um ndice baseado em 0. Como esta a propriedade padro em listas de strings voc pode omitir o identificador strings quando for acessar a lista. Veja abaixo: StringList1.Strings[0] := 'primeira string.'; quivalente a StringList1[0] := ' primeira string.';
Movendo uma string dentro da lista Para mover uma sting dentro de uma lista, chame o mtodo Move, passando 2 parmetros: o ndice corrente da string e o ndice para o qual voc quer assinal-la. Por exemplo:
83
Move(2, 4) move a terceira string para a quinta posio na lista.
Deletando uma string da lista Para deletar uma string da lista chame o mtodo Delete, passando o ndice da string a ser eliminada da lista. Se voc no sabe o ndice da string, use o mtod IndexOf para localaiz-la. Se voc quiser deletar todas as strings da lista, chame o mtodo Clear O exemplo abaixo usa IndexOf e Delete para encontrar e deletar a string:
with ListBox1.Items do begin BIndex := IndexOf('bureaucracy'); if BIndex > -1 then
Delete(BIndex); end;
Copiando uma lista completa de strings Voc pode usar o mtod Assign para copiar strings de uma outra lista de strings, sobrescrevendo o contedo da lista que chamou o mtodo. Para sinserir novas strings no final da lista, chame o mtodo AppendSTrings. Por exemplo,
Memo1.Lines.Assign(ComboBox1.Items); Copia a lista de um ComboBox para um objeto Memo (sobrescrevendo seu contedo); mas Memo1.Lines.AddStrings(ComboBox1.Items); { appends strings to end } Adiciona as linhas de umComboBox para o memo.
Manipulando Excees
O Delphi prov um mecanismo para assegurar que as aplicaes sejam robustas, isto , manipulem os erros de uma maneira consistente. A manipulao de excees permite a um aplicativo recuperar-se de erros sempre que possvel, encerrando-os se necessrio for, sem que ocorra perda de dados ou recursos. As condies de erros so chamadas Exceptions (excees) que so classes derivadas de Exception, um objeto diretamente descendente de TObject.
Excees e o controle de fluxo O Object Pascal torna fcil a incorporao de manipuladores de excees em seu aplicativo porque as excees no exigem grandes alteraes no controle de fluxo. Com efeito os manipuladores so
84
inseridos na forma de blocos de cdigo protegidos que voc define para assegurar o funcionamento correto de uma determinada operao. O cdigo seguinte inclui um bloco protegido que, caso ocorra uma exceo dispara o sinal de beep da CPU.
try
AssignFile(F, FileName); Reset(F);
except on Exception do Beep; end; { A execuo encerra aqui. }
Try ... Finally As palavra reservada Try indica o incio de um bloco de cdigo protegido. O cdigo dentro do bloco executado e, finalmente, executa o cdigo aps a palavra reservada Finally. A execuo do bloco iniciando em Finally sempre ocorrer, caso haja uma exceo ou no. Veja os exemplos abaixo var S: string; Lista: TstringList; begin Try Lista := TstringList.Create; Lista.Add(linha ndice 0); S := Lista.Strings[22]; //Aqui ocorrer uma exceo Finally if Assigned(Lista) then Lista.Free; end; end;
Neste caso tudo correu bem e o Lista foi devidamente destruda da memria aps Finally.
var S: string; Lista: TstringList; begin Try Lista := TstringList.Create; Lista.Add(linha ndice 0); S := Lista.Strings[22]; //Aqui ocorrer uma exceo Finally if Assigned(Lista) then Lista.Free; end; end;
85
Neste outro exemplo a execuo sofrer interrupo devido ao erro ao tentar acessar-se uma string inexistente na lista. Contudo, o bloco protegido garantir a destruio de Lista na memria. Sem este recurso o aplicativo poderia estar deixando lixo na memria. Voc deve usar a estrutura Try ... Finally quando desejar tratar excees simples de forma silenciosa (sem emitir avisos ao usurio) , mas bastante segura.
Try ... Exception possvel tambm escrever blocos protegidos usando uma estratgia mais explcita de tratamento de excees. Em algumas situaes ser preciso interceptar e identificar o tipo de exceo, se ela for gerada. O bloco protegido Try ... Except garante que, se alguma exceo ocorrer, o cdigo escrito aps a palavra reservada Except seja executado. A voc deve realizar operaes especficas como desalocar recursos alocados e identificar a origem da exceo. Observe que o trecho de cdigo escrito aps a palavra reservada Exception s ser executado se uma exceo ocorrer. Veja o exemplo abaixo:
var S: string; Lista: TstringList; begin Try Lista := TstringList.Create; Lista.LoadFromFile(c:\Windows\Readme.txt); Lista.Add(linha ndice 0); Lista.Free; Lista.SaveToFile((c:\Windows\Readme.txt); //Aqui ocorrer uma exceo! Lista //foi j foi destruda Except if Assigned(Lista) then Lista.Free; MessageDLg(Uma exceo ocorreu! Seu programa est errado.,mtError,[mbOk],0); end; end;
Ao tentar acessar Lista aps a sua destruio, certamente ocorrer um erro. O cdigo escrito aps Except ser executado, desalocando recursos se necessrio e emitindo um aviso de erro ao usurio. Na verdade, o recurso de blocos protegidos extremamente poderoso, e voc vivenciar situaes bem mais complexas quando ele lhe prestar grande auxlio.
Que tipo de recursos proteger? Sob circunstncias normais, voc pode assegurar-se que uma aplicao ir liberar recursos alocatodos ao incluir blocos protegidos durante a alocao, garantindo assim a desalocao. Quando uma exceo ocorre, contudo, voc precisa estar certo de que a aplicao ainda executa os recursos alocados. Alguns recursos comuns que voc deveria sempre se assegurar de liber-los so os seguintes: Arquivos 86
Memria Recursos do Windows Objetos
Por exemplo, o seguinte manipulador de eventos aloca memria e, em seguida, gera um erro, de forma que ele nunca poder liberar a memria alocada.
procedure TForm1.Button1Click(Sender: TComponent); var
APointer: Pointer; AnInteger, ADividend: Integer;

begin
ADividend := 0; GetMem(APointer, 1024);{ aloca 1K de memria} AnInteger := 10 div ADividend;{ Isto gera um error... } FreeMem(APointer, 1024);{ mas o aplicativo nunca chegar aqui } end; Embora muitos erros no so bvios, o exemplo ilustra um ponto importante: quandoa diviso por zero ocorre, o aplicativo no capaz de liberar a memria antes alocada. Este cdigo deveria ser escrito usando blocos protegidos, da forma como segue:
procedure TForm1.Button1Click(Sender: TComponent); var
APointer: Pointer; AnInteger, ADividend: Integer;

begin
ADividend := 0; Try GetMem(APointer, 1024);{ aloca 1K de memria} AnInteger := 10 div ADividend;{ Isto gera um error... } Finally FreeMem(APointer, 1024);{ mas o aplicativo nunca chegar aqui } end;
Manipulando classes de excees

Devido ao fato de os objetos de excees serem parte de uma hierarquia, voc pode especificar manipuladores para uma parte inteira da hierarquia ao prover um manipulador para uma classe de exceo a partir do qual a parte da hieraquia desejada descende. O seguinte bloco mostra um exemplo especfico de manipulao de todas excees matemticas relacionadas a nmeros inteiros: Try .../Ocorre uma operao Except On EintError do //Manipula erros relacionados a nmeros inteiros end;
87
possvel ainda especificar manipulkadores para excees ainda mais especficas, mas voc precisa colocar estes manipuladores antes do manipulador genrico, pois a aplicao os procura na ordem em que so inseridos. Por exemplo, este bloco prov manipulao de erros especficas para erros de faixa (range) e outra para mnipular todos os erros matemticos relacionados a nmeros inteiros:
Try .../Ocorre uma operao Except On ErangeError do //faz alguma coisa neste caso On EIntError do //Manipula erros relacionados a nmeros inteiros end;
Para uma referncia completa sobre as classes de manipulao de erros existentes, consulte a ajuda on-line do Delphi ou anlise o mapa de hierarquia de classes que vem com o produto.
Definindo suas prprias excees
Adicionalmente ao recurso de manipulao de erros com as classes existentes, voc poder tambm, em condies especficas, usar o mesmo mecanismo usando classes de excees definidas por voc mesmo. Para isto, necessrio: Declarar um objeto de exceo; Disparar a exceo.
Como excees so objetos, definir um novo tipo de exceo to simples quanto declarar um novo tipo de objeto. sempre uma boa idia derivar qualquer novo tipo de exceo a partir de Texception ou uma das outras excees padro. Isto porque se voc disparar sua exceo em um bloco de cdigo que no est protegido por um manipulador de exceo especfico para aquela exceo, o manipulador padro ser certamente chamado. Por exemplo, considere a declarao seguinte:
Type EmyException = class(TException);
Se voc dispara EmyException mas no prov um manipulador especfico para esta classe, um manipulador para Exception (ou o manipulador padro) ainda assim ir manipular a exceo. Isto pode tambm ser compreendido com a seguinte explicao: se voc cria sua exceo derivando-a de EIBInterbaseError (um manipulador mais especfico para algumas excees de acesso ao banco de dados Interbase), algumas excees mais genricas ou no relacionadas ao objeto ascendentes talvez no pudessem ser manipuladas corretamente. Finalmente, voc poder tambm usar blocos de proteo conjugados, para prover a segurana em algumas situaes mais complexas. Veja o exemplo abaixo:
Try
88
//bloco protegido Try Except //manipulador de exceo local End; Except //manipulador de exceo global End;
O uso de excees um dos mecanismos mais poderosos para tornar a sua aplicao segura e robusta. Ao mesmo tempo, seu uso e extenso uma tarefa simples e de fcil entendimento.
Guardando informaes na Registry e em arquivos .ini

A Registry um banco de dados hierrquico usado para armazenamento de configuraes e informaes gerais de aplicativos. O conhecimento da estrutura da Registry importante para programadores de qualquer tipo, pois certamente seus aplicativos precisaro guardar as mais variadas configuraes. Como a Registry um recurso exclusivo da plataforma Windows, no h suporte a ela nos objetos da biblioteca CLX (multiplataforma). A VCL, contudo, oferece um vasto suporte para o trabalho com este banco de dados. Finalmente, voc precisa considerar que nem sempre poder gravar ou ler dados na Registry. Nos sistemas Windows Server (como Windows NT e 2000), um determinado usurio ou grupo de usurios pode no possuir tal direito. Isto significa que, se um usurio autenticado que no possui tais direitos tentar acessar um programa que usa a Registry para guardar informaes, possivelmente este programa no se comportar de modo adequado ou mesmo no funcionar.
A classe TRegistry A classe Tregistry prov inmeros mtodos que permitem acessos de leitura/escrita na Registry com grande facilidade. Os programadores certamente devem se inteirar dos padres adotados pela Microsoft para o trabalho com esta ferramenta, que podem ser resumidos em: Uso hierrquico de dados e informaes; Destinao especfica das razes principais da Registry; Tipos de dados aceitos.
Existem atualmente as seguintes razes na Registry: HKEY_CLASSES_ROOT HKEY_CURRENT_USER HKEY_LOCAL_MACHINE HKEY_USERS HKEY_CURRENT_CONFIG HKEY_DYN_DATA
89
Na maioria das situaes voc deve as chaves HKEY_LOCAL_MACHINE/Software/Minha Empresa/Meu Programa para gravar dados especficos de sua aplicao. Tregistry precisa de trbalhar em um root, que uma das razes acima descrita. O root padro, caso voc no especifique outro, HKEY_CURRENT_USER.Tambm pode ler, criar ou alterar qualquer chave ou dados nesta estrutura atravs dos seguintes mtodos: CreateKey Cria uma nova chave no caminho especificado, com em Reg.CreateKey(software\Borland\Delphi\Dados); OpenKey Abre uma chave. Se ela no existir, pode cri-la. Observe: Reg.OpenKey(software\Borland\Delphi\Dados); Isto ir cri-la se no existir, mas Reg.OpenKey(software\Borland\Delphi\Dados, false); Impede a sua criao. CloseKey Fecha uma chave DeleteKey Deleta uma chave com todos os seus valores, veja: Reg.DeleteKey(nome da chave a deletar. Cuidado!!!); KeyExists Retorna um valor boolean que diz se a chave existe ou no. A pesquisa feita nas chaves abaixo da atualmente aberta. If not Reg.KeyExists(Dados) then Reg.CreateKey(Dados); ValueExists( ) Verifica se um determinado valor existe dentro da chave ReadString( ) Retorna o contedo de um valor de texto em uma chave. ReadInteger( ) Retorna o contedo de um valor inteiro em uma chave. ReadBool( ) Retorna o contedo de um valor boolean em uma chave. ReadFloat( ) Retorna o contedo de um valor de nmero decima em uma chave. possvel tambm escrever um valor em uma chave com mtodos similares aos de leitura. WriteString ( ) WriteInteger ( ) WriteBool ( ) WriteFloat ( ) Na verdade, existem mtodos para leitura e escrita de dados em muitos outros formatos como binrio, data, DateTime, currency etc. Para uma referncia completa, consulte a ajuda on-line do Delphi. Veja um exemplo completo de um procedimento que salva configuraes de um aplicativo e outro que os l:
Procedure Tform1.LerConfiguracoes; Var Reg := Tregistry;
90
Begin Reg := Tregistry.Create; Reg.RootKey := HKEY_LOCAL_MACHINE; Reg.OpenKey(software\Cooperi\Notepad\Dados); Form1.Height := Reg.ReadInteger(Altura); //Altera a altura do formulrio Form1.Width := Reg.ReadInteger(Largura); //Altera a largura do formulrio Form1.Caption := Reg.ReadString(Titulo); //Altera o caption da janela Form1 Reg.CloseKey; Reg.Free; End;
Agora, o procedimento que escreve os valores escolhidos pelo usurio, depois de redimensionar o formulrio e alterar caption do mesmo atravs de um TEdit:
Procedure TForm1.GravaConfiguracoes; var Reg := Tregistry; Begin Reg := Tregistry.Create; Reg.RootKey := HKEY_LOCAL_MACHINE; Reg.OpenKey(software\Cooperi\Notepad\Dados); Reg.WriteInteger(Altura,Form1.Height);//Grava a altura do formulrio Reg.WriteInteger(Largura,Form1.Width);//Grava a altura do formulrio Reg.WriteSTring(Titulo, Edit1.Text); // Grava o caption da janela Form1 Reg.CloseKey; Reg.Free; end;
A classe TIniFile Esta classe est presente por compatibilidade com os sistemas Windows 3.x, que grava informaes e arquivos de inicializao (.ini). Desde o advento da Registry, este mtodo de gravar informaes tem sido abandonado, uma vez que a Registry oferece infinitamente mais recursos do que simples arquivos texto de inicializao. No use esta classe, a no ser que voc tenha boas razes para fazer isto. Como a classe TiniFile est baseada na leitura e escrita de strings em arquivos texto, voc no poder salvar diversos tipos de dados em arquivos deste tipo. Ainda que seja possvel guardar representaes de binrios em arquivos texto, existem dados mais complexos que certamente lhe traro aborrecimentos se insistir no uso de arquivos de inicializao. Os arquivos de inicializao esto divididos em sees, dentro das quais encontram-se os valores. Use os mtodos: ReadSection Coloca nomes das chaves em um TStrings ReadSections Coloca todas as sees em um TSTrings ReadSectionValues Coloca os valores de uma determinada chave em um TSTrings ReadString Retorna a string de um valor de um valor em uma seo WriteString Escreve uma string em um valor de uma seo
91
Existem ainda outros mtodos relacionados classe TiniFile. Consulde a ajuda do Delphi para uma referncia completa. Nota: Ao contrrio das classes que lidam com a Registry, a classe TiniFile est disponvel na CLX. A seguir veja um exemplo de utilizao de TregIniFile:
procedure TForm1.FormActivate(Sender: TObject); var MyIniFile: TIniFile; begin MyIniFile := TIniFile.Create('myapp.ini'); with MyIniFile do begin if ReadBool('AutoLoad', 'FormProperties', False) = True then begin Visible := ReadBool('FormOptions', 'Visible', True); Color := TColor(ReadInteger('FormOptions', 'Color', clWindow)); Caption := ReadString('FormOptions', 'Caption', 'Main'); end; MyIniFile.Free; end;
A classe TRegistryIniFile TregistryIniFile tem propriedades e mtodos similares a TiniFile, mas l e escreve na Registry do Windows. Usando uma varivel do tipo TcustomIniFile (o ancestral comum de TiniFile, TmemIniFile e TregIniFile), voc pode escrever um cdigo genrico que acessa a Registry ou um arquivo de inicializao, dependendo de onde ele chamado. TRegistryIniFile apresenta um interface simples para acessar a Registry e dispensa anecessidade de conhecer a estrutura da Registry, pois TRegistryIniFile possibilita a manipulao da registry como se ela fosse um arquivo de inicializao.
Estudando o objeto TForm

Todo o suporte oferecido pelo Delphi (atravs da VCL ou CLX) para aplicaes grficas est baseado na classe Tform e seus descendentes. Esta seo ir explicar como funciona um formulrio (Tform) e como um programador Windows e Linux pode trabalhar na construo de aplicaes grficas requintadas.
Janelas e formulrios no Win32 Um formulrio o fundamento mais importante para a construo de aplicativos grficos. Um formulrio tambm uma janela de um programa, embora muitas vezes possa estar oculto. O Delphi implementa o suporte a formulrios de desenho atravs do objeto TForm. Abaixo, voc pode ver um Tform vazio em tempo de desenvolvimento:
92
Em um formulrio voc coloca controles que vo constituir a aparncia de seu aplicativo para o usrio, a fim de que ele possa interagir com o programa atravs do teclado, mouse ou outro perifrico. Um formulrio um container, quer dizer um objeto que possui outros objetos dentro dele, como um boto, uma caixa de edio ou uma imagem. Componentes no-visuais tambm podem estar contidos em um formulrio. Ainda que no possam ser vistos pelo usurio, eles esto instanciado em um handle pai, que o formulrio. Devido ao fato de serem controles especiais, novos formulrios no so inseridos atravs da palheta de componentes, mas sim atravs da barra de ferramentas do Delphi. Uma aplicao usualmente contm mltiplos formulrios: a formulrio principal, que aquele que forma a interface com o usurio mais importante, e outros formulrios como caixas de dilogo, janelas secundrias e assim por diante. Voc pode comear o seu formulrio a partir dos inmeros modelos existente do Object Repository, e tambm pode salvar um de seus formulrios como modelo nesta mesma ferramenta.
Figura X: um formulrio Delphi em tempo de projeto.
Mtodos de acesso e destruio Por padro, o Delphi cria automaticamente o formulrio principal de uma aplicao na memria. Contudo, muito comum que a criao de outros formulrios seja feita de maneira explcita pelo programador, como atravs do seguinte fragmento de cdigo:
Application.CreateForm(TForm1, Form1);
Criamos com isto uma varivel global com o mesmo nome do formulrio. Assim, todo formulrio em uma aplicao tem uma varivel global a ele associada. Esta varivel um ponteiro (pointer) para uma instncia da classe do formulrio, e usada para referenciar o formulrio durante a execuo do aplicativo. Qualquer unidade que inclua a unidade do formulrio em sua clusula uses pode acessar o formulrio via esta varivel. Existem muitas outras maneiras de voc escrer um cdigo que funcione exatamente como o mencionado acima, como por exemplo:
Form1 := Tform1.Create(self)
93
ou
Form1 := Tform1.Create(Application);
No primeiro exemplo, voc cria a varivel Form1, dizendo que ser um ponteiro para a classe TForm1 (que talvez descenda de TForm), e chama o mtodo create da prpria classe TForm1. No segundo caso, ocorre o mesmo, mas voc chama o mtodo Create de TApplication). A varivel global Application est presente em todos os aplicativos Delphi e a qualquer ponto do seu cdigo-fonte. O mtodo Create, contudo, apenas cria uma intncia de TForm1 na memria, mas no o exibe para o usurio. Para voc mostrar um formulrio na tela, necessrio chamar o mtodo Show ou ShowModal. O mtodo ShowModal exibe o formulrio de maneira modal, quer dizer, exclusiva. Voc precisar fechar o formulrio aberto por ShowModal para poder acessar qualquer outra janela de seu aplicativo. Uma janela de Login de usurio um exemplo tpico de chamada a este mtodo. O mtodo Show exibir a janela de maneira normal, sem impedir o foco em outra.
Voc pode criar vrias instncias de Tform1 em seu programa, o que significa que ter vrias cpias da mesma janela na tela. Embora existam diversas situaes onde este comportamente desejvel, em muitos casos preferiramos evitar novas cpias de Tform1. Voc pode fazer isto de forma muito simples, usando a funo Assigned para verificar se j existe alguma cpia de Tform1 em uso. Veja o exemplo abaixo:
procedure Tform1.Butao1Click(Sender: Tobject) begin if not Assigned(Form2) then //testa se form2 no est na memria Form2 := Tform2.Create(self); //se no estiver cria uma instncia Form2.Show;//exibe forms End;
Existem muitas formas de destruir um formulrio na memria. Esta ateno, alis, de grande importncia. Lembre-se sempre : o que no precisar manter em memria, deve ser liberado! Uma maneira muito comum atravs do mtodo Free. Este mtodo liberar a instncia de TFomr2 na memria. Tamb existe uma bordagem muito recomendada, que consiste na utilizao do manipulador de eventos OnClose da classe TForm. Este manipulador sempre ser chamado quando a janela form fechada por uma ao explcita do usurio ou programaticamente. Veja um exemplo:
procedure TForm2.OnClose(Sender: Tobject; var Action: TCloseAction) begin Action := caFree; //destri Form2 da memria Form2 := nil; //anula o ponteiro da instncia end;
Em outro exemplo de aplicativo chato que sempre reconfirma se o aplicativo deve ser encerrado:
procedure TForm1.OnClose(Sender: Tobject; var Action: TCloseAction) begin //obs: Form1 o formulario principal da aplicao 94
if MessageDlg('Deseja realmente fechar a aplicao?', mtConfirmation, [mbYes, mbNo], 0) = mrYes then Action := caFree else Action := caNone; end;
Tipos de formulrios O Windows suporta muitos tipos diferentes de formulrios, que possuem finalidade e aparncia diversas. A classe Tform oferece suporte a todos os tipos, entre eles os mais novos estilos lanados com o Windows XP. Entre os estilos destacamos: Formulrios normais (so o tipo mais comum); Formulrios MDI (do suporte introduo de interfaces MDI, como as dos aplicativos do MSOffice; MDI Child (formulrios filhos de um formulrio MDI); StayOnTop (formulrios sempre visveis).
Alm disto temos: bsdialog (janela no redimensionvel, comum para caixas de dilogo bsSingle (janelas no redimensionvel, com bordas simples) bsNone (janela no redimensionvel e sem borda); bsSizeable (janela redimensionvel e com bordas) bsToolWindow (janela no redimensionvel com borda simples e barra de ttulo pequena) bsSizeToolWin (janela redimensionvel, com bordas e barra de ttulo pequena)
O objeto TFrame Um frame (TFrame), tal como um formulrio (TForm), um container para outros componentes. Um frame usa os mesmos mecanismos gerais de instanciao e destruio de componentes que esto nele contido, assim como as mesmas relaes de ligao e dependncia de propriedades (parent) com eles. Em alguns casos, contudo, um frame se parece mais como um componente customizado que inserido no formulrio. Os frames podem ser salvos e colocados na palheta de componentes para fcil reutilizao. Aps um frame ser criado e salvo, continua a funcionar como uma unidade e a herdar as mudanas feita nos componentes nele contidos, inclusive outros frames. Ou seja, quando um frame inserido em um formulrio ou em outro frame, conntinua a herdar as mudans feitas no frame do qual deriva. O uso de frames (tal como a arquitetura orientada a objetos) um dos grandes fatores de
Figura X O Frame localizar em tempo de projeto.
95
reaproveitamento de cdigo em aplicaes Delphi. Voc pode criar um frame que contenha rotinas e objetos que voc sabe que ir precisar ao longo de mutos formulrios em uma aplicao ou entre vrios projetos diferentes. Como exemplo, imagine que voc desenvolveu um frame destinado a encontrar ocorrncias de palavras em um editor de texto, que completamente funcional e encerrado em si mesmo. Todo o cdigo necessrio para fazer esta operao j est presente no prprio frame. Ento voc poder usar instncias deste frame em quantas aplicaes desejar ou em qualquer janela de uma aplicao sem inserir nem uma linha de cdigo sequer. Mais do que isto. Se alterar o frame original, por exemplo dotando- de novos recursos, todas as aplicao passam automticamente a suportar o novo recurso. Esta caractersticas tornam um frame um formulrio muito parecido com um componente qualquer. Quando conheer o poder dos frames nunca mais deixar de us-los em suas aplicaes, e poupar horas de programao.
Construindo a interface com o usurio

Uma interface grfica mais fcil de usar quando controles e informaes relacionadas so apresentadas em grupos. Existem muitos controles que so extremamente comuns no ambiente Windows, com os quais os usurios de seu aplicativo esto certamente acostumados. Entre eles incluimos Painis, barras de ferramentas, menus, barras de status e outros. Este tpico procura introduzir as tcnicas mais comuns de programao e desenho de interfaces de aplicativos usando Delphi.
Action Lists Action Lists (listas de aes) permitem a voc centralizar a resposta para os comandos do usurio (aes) em objetos tais como menus e botes. Uma definio mais tcnica diria que Actions so comandos do usurio que operam em objetos alvo. Voc cria aes no Action List Component Editor, e as conecta a controles via seus links (a propriedade Action). A seguir so descritos os diversos elemintos usados em um mecanismo envolvendo action / action List. Um action (TAction) a implementao de uma ao, tal como copiar um stexto selecionado em um objeto alvo, por exemplo um controle de edio de texto. Uma ao disparada em resposta a um comando do usurio, um click do mouse em um controle em um formulrio, por exemplo. Existem muitas classes derivadas de TAction que implementam aes especficas, como copiar/colar/recortar, abrir um documento, chamar o sistema de ajuda, alinhar o pargrafo de um texto e muitas outras aes de forma completamente automtica. Uma lista de aes (TactionList) um componente que mantm uma lista de aes (TAction). Listas de aes so usadas em tempo de projeto para trabalhar com a interface de seu programa. Um vnculo de ao (TactionLink) um objeto que mantma conexo entre as aes e os controles. Um cliente de uma ao tipicamente um tem de menu ou um boto como Tbutton, TtoolButton, TspeedButton, TcheckBox etc. Uma co instanciada por um correspondente comando no cliente; em muitos casos um click no cliente associado com o mtodo Execute de uma ao. Um alvo de uma ao , com freqncia, um controle, tal como um TrichEdit, um Tmemo ou um controle de banco de dados.
96
Voc pode adicionar uma lista de aes (TactionList) em seu formulrio ou em qualquer tipo de mdulo de dados e inserir aes (TAction) de forma coordenada e agrupada de acordo com a finalidade das aes. Veja abaixo uma lista de aes com vrios objetos TAction muito usados em editores de texto.
Figura X: Um ActionManager exibindo diversars aes.
Centralizando cdigo com listas de aes Muitos controles tm uma propriedade publicada chamada Action. Quando voc vincula um desses controles com um determinado TAction, este copia suas propriedades (tais como enabled, caption, ImageIndex e outras) para o controle vinculado. Na verdade, todas as propriedades em comum entre o TAction e o controle (exceto Name e Tag) so dinamicamente vinculadas a este. Desta forma, por exemplo, possvel centralizar o cdigo em uma ao e um objeto e evitar a duplicao de cdigo; quando voc desabilita um TAction, ele faz o mesmo com todos os controles a ele vinculado. Isto classicamente necessrio quando voc tem um aplicativo com um menu principal, botes em barras de ferramentas e menu local contendo as fornecendo funcionalidades.
Executando aes Quando um controle vinculado a um TAction clicado, o evento OnExecute ocorre para seu Taction associado. Por exemplo, o cdigo abaixo ilustra um manipulador de evento OnExecute para um TAction que alterna a visibilidade de um barra de ferramentas (TtoolBar):
procedure TForm1.Action1Execute(Sender: TObject); begin { alterna a visibilidade de Toolbar1} ToolBar1.Visible := not ToolBar1.Visible; end;
97
Atualizando aes Quando um aplicao encontra-se ociosa, o evento OnUpdate ocorre para todas as aes que esto vinculadas a um controle que est sendo exibido. Este mecanismo oferece a oportunidade para as aplicaes executarem de forma centralizada as operaes de abilitao/desabilitao,marcao e desmarcao dos controles. Por exemplo, veja como possvel escrever um cdigo que ir marcar/desmarcar um TAction (e seus controles) medida em que uma barra de ferramentas estiver visvel ou invisvel:
procedure TForm1.Action1Update(Sender: TObject); begin { Indica se ToolBar1 is visvel agora } (Sender as TAction).Checked := ToolBar1.Visible; end;
Nota: No escreva cdigos extensivos no manipulador OnUpdate de um TAction. Devido ao fato de este evento ser acionado quando a aplicao encontra-se ociosa, este evento ser acionado muitas vezes e de forma repetida, comprometendo por inteiro o desempenho do aplicativo.
Aes pr-definidas Existem muitos tipos de aes pr-definidos que so especficas para executar determinadas tarefas, como alterar a fonte/cor/tamanho de um texto, alinhar pargrafos, abrir/salvar arquivos, chamar o sistema de ajuda, navegar e editar dados em um banco de dados e muitas outras. Como aes (TAction) so objetos, voc pode criar aes que tenham um comportamento que atenda a uma necessidade especfica, por exemplo manipular mdias em unidades de CD-ROM ou disparar um browser a partir de um TLabel vinculado ao seu novo TAction. Voc pode cri-los como desejar e, uma vez criados, estaro disponveis para o reuso quando necessrio. Para uma referncia completa aos tipo pr-definidos existentes consulte a ajuda on-line do Delphi.
Desenvolvendo menus
Os menus provem um amaneira fcil para organizar os recursos de sua aplicao em grupos lgicos de items. Os usurios Windows esto to acostumados a trabalhar com este elemento nos aplicativos, que a insero de um menu em um aplicativo certamente um fator que pode auxili-los a encontrar o que querem que seu aplicativo faa. Este tpico introduz o conhecimento de como desenvolver menus em aplicativos Delphi, assim como explorar as novas capacidades de organizao introduzidas com os menus no Windows 2000.
98
O Menu Designer Voc desenha menus para sua aplicao usando o Menu Designer. Antes de poder iniciar o uso de Menu Designer, adiciona ao seu projeto um componente MainMenu (TmainMenu) ou um PopUpmenu (TpopUpMenu) no seu formulrio, encontrados na pgina Standard da palheta de componentes. Um MainMenu cria um menu que fixado logo abaixo da barra de ttulo do formulrio, enquanto um PopUpMenu acionado com o boto direito do mouse sobre um controle ao qual est vinculado. Voc desenvolve um menu exatamente da mesma maneira que acessa-os em qualquer aplicativo, exceo de que em tempo de projeto possvel selecionar e manter foco em um item de menu em particular. Veja abaixo uma viso do desenvolvimento de um menu com o Menu Designer:
Figura X O menu designer do Delphi
Usando esta ferramenta possvel selecionar cada um dos itens que compem o seu menu e usar o Objetc Inspector para configurar suas propriedades etc. Um menu pode estender-se indefinidamente tanto no sentido vertical como no horizontal, ao criar-se novos itens abaixo de um raz ou criar submenus a partir de um outro item. Como so recursos muito comuns em vrios aplicativos, voc no deve deixar de criar um menu completo em seu aplicativo, sempre quando parecer conveniente. A aparncia de um menu pode ser modificada significativamente por diversos fatores: Uso de bitmaps junto de cada item; Uso de menus com estilos diversificados; Uso de efeitos ao acess-los; Desenhando-se em cdigo a sua aparncia (OwnerDraw).
O uso de bitmaps pode enriquecer bastante o seu menu, alm de orientar o usurio em busca de um recurso, tal como fazem os botes de barras de ferramentas. O Windows tambm tem enriquecido bastante a aparncia de menus, atravs de menus complexos como o presente no Windows 2000 ou graficamente requintado como os menus do Windows XP. Apesar de todos estes recursos, voc pode ainda desenhar o seu menu como bem entender escrevendo cdigos que desenhem na superfcie dos menus a aparncia desejada.
Menus estilo Windows 2000 e XP
99
O Delphi 6 introduziu o suporte ao desenvolvimento de menus complexos e associados a um gerenciamento central de aes e barras de ferramentas que foram lanadas com o Windows 2000. O mecanismo consiste basicamente de um gerenciador centralizado de aes configurvel em tempo de execuo que controla a disponibilidade de barras de ferramentas e botes de forma automtica. Alm disto, permite que os items mais usados de um menu estejam sempre visveis, independentemente da ordem em que foram inseridos originalmente pelos programados de um aplicativo. O suporte oferecido pelo Delphi baseia-se basicamente no s objetos TactionManager, TactionMainMenuBar, TactionToolBar e, lanado como um release, TXPActionToolbar. TactionManager um objeto gerenciador da aparncia geral do conjunto menus e barras de ferramentas. Contm todas as aes definidas para o aplicativo e permite que o usurio customize quais objetos deseja ver, entre bandas e botes, e em qual ordem deseja que apaream os botes. Ainda outros recursos relacionados a tamanho de cones e exibio de texto nos botes esto disponveis atravs deste gerenciador. TactionMainMenuBar implementa um mecanismo de renderizao das aes existentes como items de menu. Trabalha juntamente com TactionManager e possui uma enorme quantidade de propriedades para customizar sua aparncia. TactionToolBar igualmente implementa um mecanismo de renderizao das aes, trabnalhandoas como botes de barras de ferramenta. Oferece muitos recursos extras s tradicionais ToolBars e uma aparncia moderna. TXPActionToolBar age da mesmaforma que TactionToolBar, porm criando dinamicamente menus e barras de ferramentas no estilo Windows XP.
Outras barras de ferramentas O Delphi tambm oferece barras de ferramentas cool, algumas com estilos importados dos mesmos objetos da API do windows que desenham as barras de ferramentas do Internet Explorer. TtoolBar implementa uma barra de ferramentas moderna e muito comum nos aplicativos atuais como o prprio Delphi e os do pacote MS Office 97. So barras de ferramentas flutuantes que se transformam em janelas quando arrastadas para fora de seu container (tipicamente um TcontrolBar). TcoolBar implemeta barra de ferramentas no estilo I. Explorer. Usa os mesmos mecanismos bsicos de TtoolBar, porm oferece uma aparnciabem diferente
As imagens abaixo mostram um navegador WEB on-line que usa TCoolBar e um corte de uma TToolBar.
Figura X Corte da barra de ferramentas do Delphi 6: um bom exemplo de uso de TToolBar
100
Figura X Exemplo de uso de barras de ferramentas com TcoolBar em um navegador WEB construdo com Delphi.
Trabalhando com arquivos

Esta tpico descreve o fundamental do trabalho com arquivos em Delphi. Voc conhecer os tipos de arquivos comuns e aprender a manipular dados em disco, assim com as funes essenciais disponveis para copiar, deletar ou mover um arquivo em seu disco.
Tipos de arquivos O Delphi oferece suporte criao e manipulao de qualquer tipo de arquivo que voc desejar. Podemos categoriz-los de acordo com o tipo de dado que guardam. Entre os tipos de dados bsicos, podemos citar: texto simples, binrios. Arquivos texto contm apenas caracteres e so muito comuns nas mais diversas plataformas; arquivos binrios guardam dados em formato binrio codificado e so com freqencia ilegveis para os aplicativos que no sabem como lidar com eles, isso decodific-los. O Delphi ainda oferece suporte amplo a armazenamento de streams em arquivos.
Usando arquivos texto Arquivos texto so aqueles que guardam caracteres comuns, sem estruturas de dados mais complexas. Voc pode usar arquivos texto para muitas coisas, como guardar configuraes, armazenar dados etc. A manipulao de arquivos texto usando o Object Pascal extremamente simples. Existem muitos mtodos de diversos objetos que so capazes de fazer qualquer tarefa em um arquivo texto.
101
Criando um editor de texto funcional Como exemplo do uso de arquivos, iremos desenvolver agora uma aplicao que abre/gera arquivos textos. Adicionalmente, voc poder entrar em contato com alguns dos principais objetos comumente usados na criao de aplicativos, como menus, botes, barras de ferramentas etc. Este aplicativo funcionar exatamente como o Notepad do Windows, porm as capacidades relacionadas a Automation presentes no Notepad s sero implementadas quando estudarmos a tecnologia COM.
Controles de edio de texto O Delphi oferece alguns controles para editar grande quantidade de texto. Resumem-se, basicamente, ao controle Tmemo (para edio de texto plano) e TrichEdit (para edio de texto formatado em RTF). Os dois controles tm capacidades e mtodos semelhantes, exceto o fato de TrichEdit ser capaz de atribuir caractersticas de pargrafo e fonte ao documento, tais como alinhamento, cor e estilos de fonte. Contudo, como uma das caractersticas mais marcantes da VCL e da CLX a grande derivao de objetos com capacidades extendidades, voc poder encontrar muitos outros controles que extenderam bastante as caractersticas originais de Tmemo ou TrichEdit. Voc poder instal-los e uslos. Iremos construir um aplicativo simples para, paulatinamente, agregar recursos novos.
O projeto MemoEdit
MemoEdit nome dado a este editor novo. Ns o construiremos usando os seguintes objetos: Menus Barras de ferramentas Barra de status Um memo (Tmemo)
Inicie um novo projeto no Delphi e salve-o com o nome MemoEdit (ou outro que desejar, afinal), salvando a unidade com o nome Main. Neste momento s temos uma janela no nosso programa, que a janela principal de MemoEdit. Posemos selecionar esta janela e alterar o seu nome para FrmMain. Pronto. O nosso editor est quase pronto. No acredita? Pois ento observe agora que todas as principais funcionalidades inerentes a um editor de texto, como abrir e salvar um documento, selecionar, copiar, recortar ou colar texto e ainda outras sero implantadas sem uma nica linha de cdigo nosso. Ento vejamos.
Inserindo um ActionManager Para testar que novo, vamos utilizar o sistema de gerenciamento de menus e barras de ferramentas lanados com o Windows 2000. No se preocupe, ele vai funcionar em todas plataformas Win32. Insira um TactionManager e um TImageList no nosso formulrio. Como voc sabe, TActionManager gerenciar todo um conjunto de aes, menus etc, enquanto TimageList ser um receptculo para as imagens compartilhadas entre menus e barras de ferramentas. Vincule o TIMageList ao TactionManager escolhendo a lista de imagens a partir da proprieda ImageList do ActionManager. Agora a mgica: d um duplo click no ActionManager do seu formulrio e, na janela que se abre, escolha o menu New Standard Actions que est lidado ao boto New Action. Escolha ento todas as 102
operaes cabveis ao nosso editor, como copiar/colar/selecionar/abrir documento etc. O resultado deve ficar parecido com a imagem ao lado. bvio que no h mgica alguma, apenas inserimos objetos derivados de TAction que sabem como fazer uma ao especfica, como manipular dados no Clipboard do Windows. Isto significa que eles nos livraram de escrever toadas estas funcionalidades.
Figura X O ActionList Editor exibindo diversas aes pr-definidas.
Desenhando as barras de ferramentas e menus Agora vamos desenhas os menus e as barras de ferramentas de MemoEdit. Para implementar os menus, no vamos usar o Menu Designer, pois nossos menus usam um mecanismo diferenciado de implantao. Insira um objeto ActionMainMenuBar no formulrio. Acesse o Object Inspector o ActionMainMenu ao nosso ActionManager. Pronto, agora ele poder criar clientes (items de menu) que se vinculam a aes do ActionManager. Fa isto assim: 1. Selecione o ActionManager e acione a sua propriedade ActionBars. Isto abrir a janela de novos items do ActionManager 2. Crie um novo item escolhendo New; 3. No Object Inspector, vincule a o nosso ActionMainMenu ao novo item criado atravs da propriedade ActionBar do item criado. 4. Para criar o menu Arquivo (topo do menu), selecione a propriedade Items da lista de barras que voc acabou de definir. 5. Clique no boto Add Item e altere a propriedade Caption deste item criado para &Arquivo Nota: O smbolo &, quando usado em menus, coloca um sunlinhado (underscore) debaixo da letra seguinte a ele, definindo assim um atalho de teclado para este menu. Pelo mesmo processo cri os menus &Editar e Aj&uda. Agora hora de criar os items derivados das razes de menu que acabamos de criar. O que podemos observar deste mecanismo que cada item de
103
menu em uma mesma lista ser exibido no mesmo nvel (horizontalmente), enquanto cada item possui sua prpria propriedade Items que cria os menus inseridos abaixo dele (verticalmente). Finalmente, vincule cada item de menu, exceto os menus do topo (raz), a uma ao atravs da propriedade Action dos items. Isto far todo o servio para voc, com alterao do caption e insero de imagens nos menus. Nota: Nunca altere propriedades como enabled, ImageIndex ou caption de um menu ou boto de barra de status ligado a uma ao. Altere estes dados sempre na ao. A criao de uma barra de ferramentas segue a mesma lgica da dos menus, porm desta vez vamos usar o controle TactionToolBar. Existem maneiras diferentes de se implementar uma barra com TactionToolBar. Observe o que vamos fazer. 1. D um duplo click no ActionManager e, na pgina Toobars, crie uma nova barra de ferramentas. Feche a janela do ActionManager. 2. Acesse a propriedade ActionBands do ActionManager e escolha a barra de ferramentas criada acima. 3. Todo o processo que segue idntico ao da criao de menus.
Exibindo informaes sobre as funcionalidades de MemoEditor Par completar os recursos de MemoEditor ligados aos menus e barras de ferramentas, implantaremos tambm uma barra de status para passar alguns tipos de informaes ao usurio. Usaremos um componente TstatusBar para isto. Ela ser posiciona na parte mais inferior do formulrio principal e exibir, basicamente, mensagens de ajuda quando o usurio acessar um boto ou menu. Estas mensagens so strings e conhecidas no Win32 como hints e so divididos e 2 partes: ShortHint e LongHint. ShortHint a mensagem que aparece em uma caixa flutuante contendo uma explicao curta da funcionalidade de um controle (tipicamente um boto de barras de ferramentas); LongHint uma mensagem maior e mais descritiva que voc pode exibir em outros controles, como uma barra de status.
ShortHint e LongHint so separados pelo caracter |. Por exemplo, imagine que voc definiu o seguinte hint para uma ao: Salvar|Salva as alteraes feitas no documento atual Temos ento: ShortHint = Salvar; LongHint = Salva as alteraes feitas no documento atual Isso muito simples. Ento insira um TstatusBar no formulrio principal de nossa aplicao e altere o seu nome simplesmente para Status. Atravs da propriedade Panels crie 3 pains na barra de status e redefina suas dimenses para que a exibio do hint no seja cortada. Os hints exibidos nos controles vm na verdade das aes a eles vinculadas. Precisamos prover agora uma mecanismo para que os hints de cada ao sejam exibidos na barra de status. Tudo o que precisamos fazer usar as capacidades do objeto Tapplication. Como j dissemos, todo aplicativo cria automaticamente uma instncia global de um objeto Tapplication, que guarda muitas das caractersticas de uma aplicao. Tapplication pode ser acessado a partir de qualquer ponto de seu cdigo e possui um evento denominado OnHint, que disparado todas as vezes que qualquer instncia
104
de qualquer objeto de um aplicativo vai exibir seu hint. Se assim est fcil, basta usarmos um pouco de polimorfismo atribuindo este evento OnHint a um procedimento que copiar o texto do hint para a barra de status. Ns criamos este procedimento, chamado ShowHint. Veja a declarao abaixo:
procedure TFrmMain.ShowHint(sender: TObject); begin Status.Panels.Items[0].Text := Application.Hint; end;
Este procedimento simples copia o hint para o primeiro painel da barra de status, onde se mandou associar o evento OnHint de Tapplication ao procedimento ShowHint ? Isto definido durante a criao do formulrio.
procedure TFrmMain.FormCreate(Sender: TObject); begin Application.OnHint := ShowHint; end;
Se voc executar MemoEditor agora, logicamente s poder ver o LongHint na barra de status, pois o Windows j sabe que os ShortHints devem ser exibidos nas janelas flutuantes e a implementao de OnHint para Tapplication resolve esta necessidade.
Editando textos Agora vamos para o controle principal de nosso editor que um tradicional TMemo. Insira um memo no formulrio principal e altere a sua propriedade Align para AlClient, a fim de que ocupe toda a rea disponvel do formulrio. Retire o texto que se encontra na propriedade Lines do memo. Uma coisa importante saber desde j. O controle memo apenas oferece um interface visual para a edio de dados (strings) que so armazenados na propriedade Lines, que um Tstrings. Ou seja, quem possui a capacidade de armazenar/salvar/carregar o texto se d atravs de um TSTrings (propriedade Lines). Mas o memo oferece muitos outros de edio visual no presente em um simples Tstrings. Pense na seguinte analogia: se desejamos nos refrescar com gua em um dia de muito calor, certamente a gua que nos proporcionar um alvio. Mas podemos lidar com gua em uma piscina ou em uma torneira do banheiro. Uma piscina um timo invlocro onde a experincia com a gua muito mais interessante. J que as aes pr-definidas j resolveram automaticamente inmeros aspectos relacionados edio do texto em um memo, podemos pensar agora em 3 tarefas fundamentais a serem implementadas: Abrir documentos de arquivos; Criar novos documentos; Salvar alteraes em arquivos.
Para nossa satisfao todas elas so de implementao fcil. MemoEditor s permite a edio de um documento por vez. Para criar novos documentos ou abrir um arquivo do disco, precisamos antes saber se o documento atual est modificado, pois, se no fizermos isto as modificaes no salvas do documento atual sero perdidas. A classe Tmemo possui uma propriedade publicada denominada Modified que um boolean que indica justamente se o documento foi alterado, mas ainda no salvo. Ficou fcil. Consultaremos modified todas as vez que o usurio tentar gerar um documento novo ou abrir um arquivo existente para advert-lo sobre dados ainda no salvos. Como o responsvel por abrir a janela para escolha do arquivo a abrir uma ao pr-definida do tipo TFileOpen, certamente a 105
que encontraremos a soluo, precisamente na criao de um manipulador de evento OnAccept da ao (no exemplo a ao leva o nome FileOpen1.
procedure TFrmMain.FileOpen1Accept(Sender: TObject); begin if Memo.Modified then if MessageDlg('Existem dados ainda no salvos no documento atual. ' + 'Deseja ainda assim abrir outro documento?',mtConfirmation, [mbYes,mbNo],0) = mrNo then Abort; Memo.Lines.LoadFromFile(FileOpen1.Dialog.FileName); {a linha acima nunca executada se o usurio apertar o boto No na caixa de mensagem} end;
MessageDlg uma funo definida na unidade Dialogs que exibe uma caixa de dilogo do tipo confirmao com 2 botes (sim e no). Se o usurio disser no a operao ser abortada pela procedure Abort; do contrrio o texto do arquivo ser aberto pelo mtodo LoadFromFile do memo. Isto faz a correta constrio no caso de tentar-se abrir um novo documento. Agora teremos de fazer coisa semelhante quando o usurio tentar criar um documento novo. A primeira coisa que nos vem mente nestes casos reaproveitar o cdigo j escrito . Por que deveramos repetir cdigo aqui e ali, mesmo se usrmos a velha tcnica de copiar / colar? Um grande recurso que as linguagens orientadas a objetos possuem justamente o polimorfismo, que permite a um objeto compartilhar ou comportarse como outros dos quais descende direta ou indiretamente. E vamos fazer isto agora com poucas mudanas no cdigo acima. A idia bsica que o TAction (ActNew) que executa a operao de gerar um novo documento use o mesmo cdigo acima. Porm, como agora no vamos carregar um arquivo, mas simplesmente iniciar um novo documento, preciso fazer uma pequena alterao no cdigo acima, para que o manipulador saiba o que vai fazer de acordo com que objeto o chamar. Veja o novo cdigo:
procedure TFrmMain.FileOpen1Accept(Sender: TObject); begin if Memo.Modified then if MessageDlg('Existem dados ainda no salvos no documento atual. ' + 'Deseja continuar ainda assim?',mtConfirmation, [mbYes,mbNo],0) = mrNo then Abort; //agora, identifica a ao que disparou o manipulador if Sender = FileOpen1 then Memo.Lines.LoadFromFile(FileOpen1.Dialog.FileName) else Memo.Lines.Clear; end;
S modificamos o final do cdigo para identicar qual objeto que disparou (Sender) o manipulador. Tambm alteramos ligeiramente o texto da mensagem. Agora s selecionar a ao ActNew e, no Objetc Inspector, vincular o evento OnAccept de FileOpen1 ao evento OnExecute de ActNew. Veja um corte do Objetc Inspector com os eventos vinculados.
106
Salvando os dados em arquivo Salvar os dados de nosso memo em um arquivo a princpio muito simples. Como a classe Tstrings j possui mtodos para isto, os desenvolvedores que criaram Tmemo unicamente encapsularam o mtodo SaveToFile de Tstrings para Tmemo. Porm a situao se torna mais complexa quando percebemos que precisamos guardar o nome do arquivo atual para evitar de sempre chamar a tela Salvar Como toda vez que o usurio desejar atualizar os dados inseridos em um arquivo ou que abrir um arquivo e edit-lo. Alm disto, vamos colocar o nome do arquivo atual na barra de ttulo da aplicao. Como precisamos salvar o nome do arquivo (inclusive o caminho) em algum lugar, uma estratgia simples declarar uma varivel privada global do tipo string em nossa unidade. Ela pode se chamar FileName. Sempre que o valor desta varivel for vazio (), podemos entender que no existe um documento selecionado atualmente ou que o usurio gerou um novo mas ainda no o salvou. Se um arquivo aberto ou um novo salvo pela primeira vez, a varivel FileName conter o seu nome. Desta forma, poderemos chamar o mtodo SaveToFile sem Ter que abrir a caixa de dilogo para o usurio escolher um nome e local para o arquivo. Uma vez comprendida a estratgia adotada, observese que o usurio pode a qualquer momento salvar o arquivo com outro nome, tornando-o o arquivo atual. A classe TfileSaveAs, como se nome indica, sempre chama uma caixa de dilogo para salavar um arquivo. Ela foi desenhada para atender situaes tais como as disponveis no nosso menu Salvar Como. Teremos ento de criar uma nova ao (TAction) personalizada. D a ela um nome tal como ActSave. O manipulador OnExecute de ActSave testar o contdo da varivel FileName, salvando os dados no arquivo do endereo exitente em FileName ou, caso FileName esteja vazia, chamar o mtodo Execute de FileSaveAs. Veja como ficou escrito:
procedure TFrmMain.ActSaveExecute(Sender: TObject); begin if Filename <> '' then Memo.Lines.SaveToFile(FileName) else FIleSaveAs1.Execute; end;
Uma alterao nestes manipuladores ainda precisa ser feita. Teremos agora de escrever na varivel FileName sempre que um arquivo for aberto ou que um arquivo for salvo pela primeira vez (criado). Tambm teremos que limpar o contedo de FileName quando um usurio gerar um documento novo no salvo. Por fim, a funo ExtractFileName (declarada na unidade SysUtils) ir escrever o nome do arquivo na barra de ttulo. Para isto alteramos os manipuladores OnAccept de FileOpen1 e FileSaveAs1. Veja abaixo como o cdigo final ficou:
procedure TFrmMain.FileOpen1Accept(Sender: TObject);
107
begin if Memo.Modified then if MessageDlg('Existem dados ainda no salvos no documento atual. Deseja ainda ' + 'assim abrir outro documento?',mtConfirmation,[mbYes,mbNo],0) = mrNo then Abort; if Sender = FileOpen1 then begin Memo.Lines.LoadFromFile(FileOpen1.Dialog.FileName); FileName := FileOpen1.Dialog.FileName; Caption := 'MemoEditor - ' + ExtractFileName(FileName); end else begin Memo.Lines.Clear; FileName := ''; end; end;
procedure TFrmMain.FileSaveAs1Accept(Sender: TObject); begin Memo.Lines.SaveToFile(FileSaveAs1.Dialog.FileName); FileName := FileSaveAs1.Dialog.FileName; Caption := 'MemoEditor - ' + ExtractFileName(FileName); end;
Inserindo uma tela de crditos (About)
Iremos acrescentar tambm uma nova ao personalizada que ir chamar uma tela About de MemoEdit que ns criaremos. Para implementar esta funcionalidade vamos criar um novo formulrio em nosso aplicativo e salvar a unidade ce o formulrio com os nomes About FrmAbout, respectivamente. No formulrio novo faa as seguintes alteraes: 1. Altere a propriedade caption para Sobre MemoEdit; 2. Altere a propriedade Position para poScreenCenter para que o formulrio aparece no centro da tela; 3. Altere a propriedade BorderStyle para bsDialog para definir o formulrio como um caixa de dilogo. 4. Reduza o tamanho do formulrio; 5. Acesse os menus Projetc | Options e retire o formulrio da lista Auto created forms Esta ltima ao ir impedir que nossa tela About seja criada quando a aplicao for executa, pois apenas desejamos cri-la quando o usurio fizer uma escolha explcita. Na tela About insira um component Timage, um Tlabel e um TButton. A finalidade de cada um deles exibir o cone da aplicao, seu nome e fornecer um boto para o usurio fechar a tela About. Ajuste estes componentes na tela a fim de obter um desenho agradvel. No Tbutton, altere a propriedade ModalResult para mrOk. Isto far com que o boto se comporte como um confirmador da caixa de dilogo, fechando-a automaticamente.
108
Inserindo o cone da aplicao na tela About O Timage que colocamos na tela About tem o objetivo de mostrar o cone da aplicao. Preferiremos inserir o cone no Timage de forma dinmica; isto , a rotina que mostrar o cone ser escrita em cdigo. Assim se voc alterar o cone desua aplicao a tela About sempre mostrar o cone correto. O melhor lugar para isto durante a criao da tela. Veja o manipulador de eventos OnCreate da nossa tela de crditos:
procedure TFrmAbout.FormCreate(Sender: TObject); begin Image1.Picture.Icon.Assign(Application.Icon); end;
Este cdigo assinala, quer dizer, copia o contedo de Application.Icon para o Timage. Agora, s precisamos escrever algum cdigo para chamar esta janela. Isto, conforme previsto, ser feito em OnExecute da ao que criamos antes. Veja o cdigo:
procedure TFrmMain.ActAboutExecute(Sender: TObject); begin FrmAbout := TFrmABout.Create(self); FrmAbout.ShowModal; end;
Tambm vamos destruir a janela About quando ela for fechada. Na verdade, ela mesma vai se destruir. O melhor local para fazer isto no evento OnClose da nossa tela de crditos. Precisamos fazer: 1. Destruir a janela para liberar a memria 2. Liberar o penteiro a ela associado na memria Veja o cdigo abaixo: procedure TFrmAbout.FormClose(Sender: TObject; var Action: TCloseAction); begin Action := caFree;//caFre destri a janela FrmAbout := nil; //Anulando o ponteiro de FrmAbout end;
Por fim, vamos associar um atalho de teclado para a ao que chama a tela About. Selecione esta ao e, no Objetc Inspector, digite F1 (ou o atalho que quiser) na propriedade ShortCut da ao. Teste esta implementao. Com isto terminamos a primeira etapa do desenvolvimento deste editor. Mais a frente adicionaremos novos recursos para torn-lo ainda mais funcional. Segue abaixo a listagem completa de seu cdigo-fonte:
109
Listagem 10 MemoEdit.dpr program MemoEdit; uses Forms, Main in 'Main.pas' {FrmMain}, About in 'About.pas' {FrmAbout}; {$R *.res} begin Application.Initialize; Application.CreateForm(TFrmMain, FrmMain); Application.Run; end.
110
Listagem 11 Main.pas
unit Main; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdActns, ExtActns, ActnList, ImgList, ActnMan, ToolWin, ActnCtrls, ActnMenus, ComCtrls, StdCtrls; type TFrmMain = class(TForm) ActionManager1: TActionManager; ImageList1: TImageList; EditCut1: TEditCut; EditCopy1: TEditCopy; EditPaste1: TEditPaste; EditSelectAll1: TEditSelectAll; EditUndo1: TEditUndo; EditDelete1: TEditDelete; FileSaveAs1: TFileSaveAs; FilePrintSetup1: TFilePrintSetup; FileRun1: TFileRun; FileExit1: TFileExit; SearchFind1: TSearchFind; SearchFindNext1: TSearchFindNext; SearchReplace1: TSearchReplace; SearchFindFirst1: TSearchFindFirst; ActionMainMenuBar1: TActionMainMenuBar; ActionToolBar1: TActionToolBar; FileOpen1: TFileOpen; ActAbout: TAction; Status: TStatusBar; Memo: TMemo; ActNew: TAction; ActSave: TAction; procedure FormCreate(Sender: TObject); procedure ActAboutExecute(Sender: TObject); procedure FileSaveAs1Accept(Sender: TObject); procedure FileOpen1Accept(Sender: TObject); procedure ActSaveExecute(Sender: TObject); private { Private declarations } FileName: string; procedure ShowHint(sender: TObject); public { Public declarations } end; var FrmMain: TFrmMain;
111
Listagem 12 Main.pas (continuao) implementation uses About; {$R *.dfm} procedure TFrmMain.FormCreate(Sender: TObject); begin Application.OnHint := ShowHint; end; procedure TFrmMain.ShowHint(sender: TObject); begin Status.Panels.Items[0].Text := Application.Hint; end; procedure TFrmMain.ActAboutExecute(Sender: TObject); begin FrmAbout := TFrmABout.Create(self); FrmAbout.SHowModal; end; procedure TFrmMain.FileSaveAs1Accept(Sender: TObject); begin Memo.Lines.SaveToFile(FileSaveAs1.Dialog.FileName); FileName := FileSaveAs1.Dialog.FileName; Caption := 'MemoEditor - ' + ExtractFileName(FileName); end; procedure TFrmMain.FileOpen1Accept(Sender: TObject); begin if Memo.Modified then if MessageDlg('Existem dados ainda no salvos no documento atual. Deseja ainda ' + 'assim abrir outro documento?',mtConfirmation,[mbYes,mbNo],0) = mrNo then Abort; if Sender = FileOpen1 then begin Memo.Lines.LoadFromFile(FileOpen1.Dialog.FileName); FileName := FileOpen1.Dialog.FileName; Caption := 'MemoEditor - ' + ExtractFileName(FileName); end else begin Memo.Lines.Clear; FileName := ''; end; end;
Listagem 13 Main.pas (continuao)
112
procedure TFrmMain.ActSaveExecute(Sender: TObject); begin if Filename <> '' then Memo.Lines.SaveToFile(FileName) else FileSaveAs1.Execute; end; end.
Listagem 14 About.pas unit About; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,Dialogs, StdCtrls, ExtCtrls; type TFrmAbout = class(TForm) Image1: TImage; Label1: TLabel; Button1: TButton; procedure FormCreate(Sender: TObject); procedure FormClose(Sender: TObject; var Action: TCloseAction); private { Private declarations } public { Public declarations } end; var FrmAbout: TFrmAbout; implementation {$R *.dfm} procedure TFrmAbout.FormCreate(Sender: TObject); begin Image1.Picture.Icon.Assign(Application.Icon); end; procedure TFrmAbout.FormClose(Sender: TObject; var Action: TCloseAction); begin Action := caFree; FrmAbout := nil; end; end.
113
Trabalhando com imagens e desenhos

O trabalho com grficos e desenhos no Win32 grandemente facilitado pela presena de uma API e um conjunto de rotinas completo que responsvel por gerar imagens na tela de um computador, conhecida como GDI (Graphic Device Interface). De fato, se pensarmos que tudo o que vemos na tela no passa de uma grande quantidade de pixels iluminados que, em conjunto, formam um desenho ou interface compreensvel a olhos humanos, podemos compreender que o trabalho com grficos um pouco semelhante a uma tela de pintura de um artista: existe uma superfcie a ser pintada e o artista usa diversos instrumentos para realizar a sua criao, tais como pincis de variados tipos. A GUI do Win32 oferece-nos no s uma superfcie a ser pintada como intrumentos (pincis) e mtodos bem desenvolvidos para criar um desenho na tela de um computador. Aplicativos fortemente grficos, como muitos jogos, fazem um uso intenso destas possibilidades oferecidas pela GDI. O Delphi oferece um amplo suporte para o desenvolvimento de aplictivos que trabalham com desenhos ou grficos de todos os tipos. Os componentes grficos da VCL encapsulam a GDI, tornando muito fcil adicionar recursos grficos ao seu aplicativo. Esta seo explicar como voc manipular os principais objetos destinados a trabalhos com grficos, e tambm criar uma aplicao de desenho grfico.
Usando TCanvas como uma superfcie de desenho Para desenhar grficos em uma aplicao Delphi, voc sempre usa uma superfcie de desenho encapsulada pelo objeto Tcanvas. Voc no desenha diretamente sob um objeto qualquer, pois Tcanvas sempre uma propriedade de um objeto, alm de ser tambm um objeto. Uma das maiores vantagens de Tcanvas que ele manipula recursos efetivamente e oferece dispositivos de contexto para desenhar na tela, na impressora ou em bitmaps e vetoriais. Objetos canvas esto disponveis apenas em tempo de execuo, de forma que voc executa todo o trabalho sobre eles atravs de cdigo. A maneira como imagens aparecem na sua aplicao depende do tipo de objeto em cuja superfcie voc desenha. Se voc estiver desenhando diretamente sob um canvas de um controle, a imagem disparada imediatamente. Contudo, se voc desenhar sob uma imagem offscreen (em memria) tal como um Tbitmap ou Tjpeg, a imagem no exibida at que voc copie a imagem para o canvas de um controle. Isto , quando estiver desenhando bitmaps e assinanalando-os para um Timage, a imagem s atualizada quando o controle tem a oportunidade de processar sua mensagem OnPaint. Quando voc est trabalhando com grficos, freqentemente encontra as expresses drawing (desenho) e painting (pintura). No sistema grfico do Windows, necessrio distinguir um de outro: Drawing a criao, em cdigo, de um um nico e especfico elemento grfico, tal como uma linha ou um quadrado. Painting a criao da inteira aparncia de um objeto. Painting usualmente envolve drawing, isto , em resposta a eventos OnPaint, um objeto geralmente desenha algum grfico. Um componente Tedit, por exemplo, pinta-se ao desenhar um retngulo e ento desenha algum texto em seu interior. Um Tshape, por outro lado, pinta-se ao desenhar um grfico simples.
Para efeito de compreenso, observe que quando voc maximiza a janela de um programa, o Windows gera mensagens WM_PAINT que a VCL encapsula atravs de eventos OnPaint. Mas, enquanto alguns sistemas operacionais cuidam automaticamente de manipular o redesenho de janelas que esto invalidadas, o Windows no o faz, pois, para o Windows, qualquer coisa desenhada na tela permanente. Quando, por exemplo, uma janela obscurecida ao comea a ser arrastada, o formulrio ou um controle devem repintar a rea obscurecida quando a operao de arrasto estiver terminada.
Tipos de objetos grficos

114
A VCL prov os objetos grficos indicados abaixo. Todos estes objetos tm mtodos para desenhar sob um canvas.
Objeto TPicture TBitmap TClipboard TIcon TMetafile Descrio Usado para armazenar qualquer imagem grfica. Quando desejar adiciona formatos de arquivos grficos adicionais, use o mtodo Register de Tpicture. Use este objeto para manipula arquivos grficos arbitrrios. Um poderoso objeto grfico usado para criar, manipular e armazenar arquivos grficos em disco. Existem muitos formatos de grficos bitmaps. Representa um container para qualquer texto/grfico etc que for copiado, cortado ou colado a aprtir de aplicaes. Oferece suporte ao formato Windows .ico. Contm um meta-arquivo que guarda as operaes requeridas para contruir uma imagem, ao invs de conter os pixels de um bitmap. Meta-arquivos so extremamente escalveis sem perder detalhes de imagens e requerem muito menos memria que bitmaps, particularmente para dispositivos de alta resoluo, como impressoras. Contudo, meta-arquivos so to rpidos quanto bitmaps no processo de pintura da imagem.
Cada um destes objetos possuem muitos mtodos de desenho, pintura, atualizao, salvamento em arquivo, carregamento de arquivo, desenho de figuras geomtricas e de texto, converso de formatos etc. Criaremos um aplicativo grfico que ilustrar o uso de alguns destes mtodos.
Conhecendo TImage Timage um controle grfico destinado exibio de imagens de todos os tipos. Timage verstil o suficiente para suportar processos de desenho e pintura to diversificados como os de uma imagem bitmap ou o de um metafile do Windows. Quando voc usa TImage, o processo de pintura e atualizao da imagem nele contido manipulado automaticamente pela VCL, de forma que TIMage capaz de conter imagens persistentes. Voc usar um objeto Timage todas as vezes que desejar acrscentar uma imagem em seu aplicativo (como em uma tela de abertura, por exemplo) ou quando construir aplicativos que exibem imagens a partir de arquivos de imagens. Como TImage encapsula um objeto Tpicture atravs da sua propriedade publicada Picture, ele poder suportar a exibio e manipulao de imagens de todos os tipos suportados por Tpicture, assim como os tipos adicionais que forem inseridos no suporte de Tpicture.
Criando um aplicativo de desenho funcional

Para ilustrar todo o trabalho com Tcanvas e alguns componentes que encapsulam grande parte das suas funcionalidades atravs de propriedades, vamos criar agora um aplicativo de desenho e trabalho com imagens. Este aplicativo tambm mostrar algumas tcnicas comuns na abordagem de interfaces MDI implementados a nvel do sistema operacional Windows.
O projeto do aplicativo
Tcnicas MDI de manipulao de documentos
115
Implementando os recursos de manipulao de arquivos
Implementando recursos de trabalho com imagens
Implementando recursos de desenho
Informaes de arquivos
Tcnicas avanadas de trabalho com grficos

O Delphi permite manipular objetos grficos de uma maneira to simples que, do ponto de vista do programador, realmente relativamente simples desenvolver recursos avanados, como tratamento de imagens, converses de tipos ou criao de formatos personalizados de arquivos grficos. Voc pode duvidar disto, pensando que, na verdade, estas so tarefas titnicas. Contudo, ver que mais fcil implementar tcnicas avanadas do que realmente imaginava. Como os objetos grficos so, evidentemente, visuais, a melhor forma de agilizar o desenvolvimento de aplicativos graficamente complexos, como jogos ou multimdias, por exemplo, utilizar componentes que j possuam caractersticas visuais bastante avanadas e adequadas ao seu projeto. E estes componentes j existem em enorme quantidade. Alm daqueles que so instalados com o Delphi, existem muitas colees de componentes exclusivamente destinados ao desenvolvimento de jogos, screen savers e multimdias. Nestas colees encontramos botes grficos de qualquer aparncia, labels com efeitos os mais variados, painis de exibio de filmes, menus altamente grficos, manipuladores de efeitos de transio e muitos outros componentes. Apenas a ttulo de exemplo, citaremos a biblioteca TMS Instrumentation Workshop, com mais de 110 componentes destinados ao desenvolvimento de multimdias diversas, apresentaes e aplicativos de preciso tcnica. Outra estratgia que pode simplesmente eliminar todo o seu esforo de desenvolvimento, utilizar bibliotecas e unidades de cdigo que possuem muitas funes e procedimentos destinados ao tratamento de imagens e s mais diversas tarefas comuns em aplicativos de trabalho com grficos complexos, como o Adobe PhotoShop, por exemplo. Estas unidades e bibliotecas existem tambm em grande quantidade, e voc vai ficar feliz ao encontrar uma rotina que implementa uma funcionalidade qual voc teria de gastar muito mais tempo para implementar sozinho. Este tpico ir mostrar algumas tcnicas de trabalho com imagens.
Espectros de cores Alguns aplicativos precisam exibir uma gama muito complexa de cores
116
Rotacionando imagens
Invertendo imagens
117
PARTE II DESENVOLVENDO APLICAES DE BANCO DE DADOS
118
CAPTULO 9 - TECNOLOGIAS
DE ACESSO A FONTES DE DADOS
Aplicaes de banco de dados permitem aos usurios interagir com informaes que so armazenadas em bancos de dados. O Delphi prov um suporte muito amplo e extensvel a tecnologias de bancos de dados, que se extende a simples arquivos texto at muito complexos sistemas de banco de dados relacionais com acesso remoto. Voc tambm pode acessar um mesmo banco de dados atravs de tecnologias de acesso diferentes como Acesso nativo, BDE, DBExpress, Client Dataset ou ADO, todas disponveis no ambiente Delphi. Caso ainda assim julgar necessrio, poder desenvolver uma nova tecnologia de acesso a partir da base flexvel de TDataset. Este captulo tem a inteno de introduzir o conhecimento das arquiteturas e tecnologias de acesso a dados providos pelo ambiente Delphi. Cada uma destas tecnologias ser analisada com muito mais profundidade nos captulos seguintes.
119
Tipos de bancos de dados e acessos

O suporte Delphi para acesso a bancos de dados extremamente vasto. Voc pode usar diferentes tecnologias de acesso a dados e diferentes bancos de dados, sempre de uma maneira bastante uniforme. Voc deve diferenciar de imediato o mecanismo de acesso a dados com o tipo do banco de dados. O mecanismo consiste na tecnologia de software que voc pode usar para acessar um determinado tipo de banco de dados. Existem mecanismos genricos (que oferecem suporte a diversos tipos de bancos de dados de uma forma semelhante, freqentemente atravs de drivers ou tecnologia semelhante) e mecanismos especficos, que acessam um tipo de banco de dados em particular, freqentemente de maneira direta, dispensando drivers de conexo. Os seguintes mecanismos esto disponveis para o Delphi 6.0 Os componentes existentes na pgina BDE da palheta de componentes oferecem suporte a acesso a diversos tipos de bancos de dados usando a tecnologia conhecida como Borland Database Engine (BDE). Os componentes existentes na pgina Interbase e Interbase Admin oferecem um conjunto de componentes para acesso direto a bancos de dados Interbase ou Firebird. Os componentes da pgina DataAcess oferece suporte ao desenvolvimento de aplicaes de bancos de dados distribudas atravs da tecnologia MIDAS. Os componentes da pgina ADO usam ActiveX Data Objets (ADO) para acessar bancos de dados atravs de um driver OLEDB. Os componentes da pgina DBExpress oferece suporte a acesso a bancos de dados atravs da tecnologia DBExpress, uma tecnologia multi-plataforma de acesso a dados.
Alm destes componentes desenhados para acessar dados atravs de tecnologias especficas, voc pode tambm desenvolver qualquer tecnologia de acesso a qualquer banco de dados usando a base universal de acesso a dados oferecida pela classe TDataset. Com efeito, existem no mercado uma quantidade muito grande de bibliotecas de componentes que usam a base oferecida por Tdatset para desenvolver mtodos especficos de acesso a muitos bancos de dados. Como exemplo, citemos as bibliotecas IBO (Interbase Objects) e FIBPlus para acesso direto API de bancos de dados Interbase/Firebird; a biblioteca de componentes NCOCI8 que oferece acesso direto a bancos Oracle atravs de chamadas sua API e ainda muitas outras. Dependendo da sua verso do Delphi, a BDE e a DBExpress incluem drivers para acessar diferentes tipos de bancos de dados. Enquanto quase todos os tipos de bancos de dados conhecem tabelas (tables) que contm informaes, alguns tipos de banco oferecem tambm: Mecanismos de segurana; Transaes; Dicionrios de dados; Integridade referencial, procedimentos armazenados e gatilhos (triggers).
Tipos de bancos de dados

Existem diferentes tipos de bancos de dados no mercado. Usando Delphi, voc provavelmente poder conectar-se a qualquer um deles; mas, caso voc esteja acessando um formato proprietrio pouco conhecido, ainda assim poder usar o Delphi usando uma das seguintes estratgias: Desenvolvendo descendentes de TDataset que saibam como acessar o seu banco;
120
Desenvolvendo drivers ODBC que saibam como acessar o seu banco. Ento, ser possvel usar normalmente os componentes de acesso a bancos via BDE ou ADO; Desenvolvendo drivers OLEDB que saibam acessar o seu banco. Desta forma, possvel usar os componentes que utilizem a tecnologia ADO. Desenvolvendo drivers DBExpress que saibam como acessar os dados de seu banco. Assim, a soluo que utilize tecnologia DBExpress estar acessvel.
A tecnologia BDE oferece acesso a diferentes bancos de dados como: arquivos texto; Paradox, Xbase; Dbase; FoxPro; Visual FoxPro; MSAcess; Informix; Oracle; Interbase; Firebird; Sybase; MS SQL Server; DB2; CSV e texto formatado. O acesso a qualquer um destes bancos pode ser via um driver BDE ou ento via ODBC. Usando ADO voc pode acessar os mesmos bancos que acessaria usando BDE, porm far isto atravs de um driver OLEDB. A DBExpress suporta atualmente os seguintes bancos: Interbase/Firebird, Oracle, Informix. Tecnicamente falando, os bancos de dados so classificados em 2 tipos bsicos:
Bancos de dados locais. So bancos de dados que possuem uma arquitetura de acesso mono-usurio e residem em um disco local ou em algum ponto de uma rede local de computadores. Freqentemente, esses bancos so dedicados a um nico sistema, e usam mecanismos de travas de registro mais ou menos restritivos porm, em todo caso, inadequados para acessos simultneos concorrentes. Por isto, tais bancos so s vezes chamados de bancos baseados em arquivos. Os bancos de dados locais podem ser mais rpidos do que bancos remotos, pois com freqncia residem no mesmo sistema que o aplicativo de manipulao dos dados. Possuem uma maior limitao no que diz respeito quantidade de dados que podem armazenar e complexidade do modelo de dados a ser implementado.
Servidores de bancos de dados remotos Servidores de bancos remotos comumente residem em uma mquina na rede. Eles usam Structured Query Language (SQL) como mecanismo de acesso, criao e manuteno de dados e metadados e, por isso, so comumente chamados de servidores SQL. Estes Sistemas Gerenciadores de Bancos de Dados Relacionais (SGBDR) so mecanismos muito mais complexos que o simples processo de insero ou edio de dados, e fazem uma grande quantidades de tarefas de manuteno e gerenciamento atravs de um motor ou Servidor SQL que deve estar sempre ativo. SGBDRs so desenhados para uma grande quantidade de acessos concorrentes sem qualquer mecanismo de travas de dados, propiciando um verdadeiro e sofisticado sistema de acesso multiusurios baseados em transaes. Tambm podem armazenar uma quantidade indefinida de dados, que no necessitam obrigatoriamente residir em um nico computador, mas podem estar distribudos em diversos servidores.
Arquiteturas de aplicaes de bancos de dados

Aplicaes de banco de dados so construdas a partir de elementos da interface com o usurio, componentes que manipulam o banco de dados e componentes que representam dados contidos em 121
tabelas do banco de dados (datasets). A arquitetura de aplicaes de bancos de dados determinada pela f orma como voc organiza estas peas. Ao isolar os componentes de acesso ao banco de dados em um mdulo de dados (TDataModule), possvel desenvolver formulrios que o acessam e providenciam uma interface bastantes consistente. O isolamento tambm permite ao desenvolvedor criar padres de arquiteturas e compartilhar mdulos de dados entre diversas aplicaes. Muitos aspectos da arquitetura de sua aplicao de banco de dados dependem do tipo de banco que voc est usando, o nmero de usurios que iro compartilhar as informaes do banco e os tipos de informaes contidas em seu banco de dados.
Pensando em escalabilidade Ao iniciar o desenvolvendo de uma aplicao de banco de dados, voc deve pensar de imediato em como poder criar aplicaes que sejam altamente escalveis. Um bom planejamento de escalabilidade para sua aplicao pode proteger um seu investimento em desenvolvimento quando, por alguma razo, o abandono do modelo de arquitetura de seu aplicativo se tornar imperativo. Muitos fatores podem exigir este abando, como: Aumento do nmero de usurios acessando seu banco de dados ou aumento de acessos ao banco; Aumento do nmero de aplicaes acessando seu banco de dados; Aumento da quantidade de informaes armazenadas em seu banco de dados. Necessidade de disponibilizar dados de seu banco para uma quantidade desconhecida de pessoas (como atravs de pginas WEB, por exemplo).
Muitas tcnicas de escalabilidade de aplicaes esto sua disposio, seja qual for a arquitetura que desejar implementar, mas aplicaes multi-camadas provem o mximo de vantagens em escalabilidade. Os componentes de acesso a dados da VCL tornam fcil desenvolver aplicaes escalveis ao abstrair os recursos de um banco de dados e dos dados armazenados. Seja qual for a arquitetura escolhida, voc pode isolar seus elementos da interface com o usurio de uma camada de acesso aos dados. A figura seguinte ilustra esta estratgia:
Figura Arquitetura genrica de acesso a dados via datasets.
O desenho de uma janela com ttulo UI (user interface) reprsenta a interface com o usurio, onde so exibidos os dados. No mdulo de dados (Data Module) esto os componentes que acessam o banco de dados. Se voc isola desta forma um mdulo de dados, torna-se fcil desenvolver outro mdulo de dados que realizar tarefas especficas em outro banco, ou mesmo ler dados em bancos de outros tipos a fim de tranafer-los para o seu banco. Uma aplicao que acessa dados de um banco de dados sempre deveria possuir um mdulo de dados.
122
Aplicaes de uma camada Quando voc desenvolver uma aplicao que usa informaes que no sero compartilhadas entre muitos usurios, voc pode desejar usar uma banco de dados local em uma arquitetura simples (single-tiered application). Este apanhado pode ter vantagens como alto desempenho (porque os dados so armazenados localmente) e no demandar a compra de um servidor de dados robusto. Contudo, esta arquitetura possui limitaes fortes quanto quantidade de informaes que o banco pode armazenar e o nmero de usurios que o banco pode suportar. Em aplicaes de 1 camada, a aplicao e o banco compartilham um mesmo sistema de arquivos. Elas usam bancos locais ou arquivos para armazenar dados em um fomato conhecido normalmente como flat-file format. As aplicaes que usam esta arquitetura simples so muitas vezes denominadas aplicaes desktop, pois compreende tanto os elementos da interface como o mecanismo que ser usado para interfacear com o banco de dados, como o BDE, DBExpress ou ADO. Veja na figura abaixo um exemplo da lgica da arquitetura de 1 camada.
FiguraX- Modelo de uma aplicao de uma camada que usa a BDE para acessar dados.
Aplicaes de duas camadas O desenvolvimento de aplicaes com duas camadas (two tiered application) prov um suporte muito maior ao acesso concorrente de muitos usurios aos seus dados e permite-lhe usar servidores de bancos de dados remotos que podem armazenar uma quantidade de informao muito grande. Em aplicaes de 2 camadas, uma aplicao cliente interage diretamente como um servidore de banco de dados remoto. Neesta arquitetura, todas as aplicaes so clientes de um servidor de dados e, por isto, tambm chamada de modelo Cliente/Servidor (Client/Server model). Um cliente requisita e envia informaes para o servidor remoto, e um servidor pode processar requisies de muitos clientes simultaneamente, coordenando o acesso e atualizao dos dados. A imagem abaixo mostra a estrutura de uma aplicao de 2 camadas que usa ADO para se comunicar com o servidor remoto.
123
FiguraX Modelo de um aplicativo de 2 camadas que acessa uma fonte de dados via ADO.
Aplicaes multi-camadas Quando as informaes de um banco de dados incluem complicados relacionamentos entre muitas tabelas, ou quando o nmero de usurios de seu banco bastante grande, voc pode optar por desenvolver seu aplicativo usando uma arquitetura mais flexvel, conhecida como arquitetura de multicamadas (multi-tiered application). Aplicaes multi-camadas incluem servidores de dados (middle tiers) que centralizam a lgica que governa as interaes com seu banco de dados, promovendo um controle centralizado sobre os relacionamentos dos dados. Isto permite que aplicaes clientes usem os mesmos dados enquanto asseguram que a lgica dos dados continua consistente. Esta arquitetura tambm que os aplicativos clientes sejam menores, mais rpidos, mais fceis de serem instalados e de se manter, pois a maior parte dos processamentos e validaes conhecidos comumente pela expresso lgica comercial est a cargo do servidor de dados. Aplicaes multi-camadas tambm possibiliatam um ganho de desempenho de seus aplicativos ao providenciar uma distribuio do processamento de dados entre vrios sistemas. Por padro, uma aplicao multi-camadas particionada em peas que residem em diferentes mquinas. Este particionamento permite uma completa distribuio de tarefas em uma equipe de desenvolvimento, uma vez que possvel estabelecer um plano de desenvolvimento dos aplicativos de forma totalmente independente para cada uma das equipes de desenvolvedores. Em um esquema mnimo, uma arquitetura multi-camadas comporta 1 aplicativo clientes, 1 aplicativo servidor de dados e 1 servidor de banco de dados remoto: O cliente prov a interface com o usurio para manipulao dos dados. Ele passa todas as requisies de dados e envia atualizaes para o servidor de dados. A aplicao servidora de dados (tambm chamada de remote data broker) comunica-se diretamente com o servidor remoto de banco de dados ou algum outro dataset ligado a um banco. O servidor remoto de banco de dados (SGDB) responsvel pelo gerenciamento de acessos, validaes dos dados etc. um servidor SQL.
Voc deve desenvolver no Delphi os 2 primeiros elementos. Embora este exemplo ilustre uma situao mnima, devemos notar que a situao mais comum existirem mais de um servidor de dados com finalidades especficas, o que prov uma distribuio de carga ainda mais customizada. As aplicaes clientes podem usar uma variedade de protocolos (TCP/IP, HTTP, DCOM, MTS ou Corba) para comunicar-se com o servidor de dados. O protocolo usado sempre depende do tipo de conexo que o cliente usa para se comunicar com a aplicao servidora e do tipo de mdulo de dados remoto que a aplicao servidora utiliza. Normalmente, muitos clientes se comunicam com uma nica aplicao servidora, mas cpias de uma mesma aplicao servidora podem ser instaladas em mais de uma mquina para que se propicie uma grande distribuio de carga entre os diversos clientes e
124
algumas aplicaes servidora rodando em computadores diferentes. A figura abaixo ilustra a lgica geral deste modelo de acesso.
A evoluo das arquiteturas de acesso

Ao longo dos anos a arquitetura de acesso a dados sofreu grandes mudanas. Podemos verificar hoje que, do esquema de acesso de um terminal burro ats os mais complexos aplicativos multi-camadas hojes existentes houve uma grande evoluo, e muitas tecnologias novas foram sendo desenvolvidas. Este tpico analisar rapidamente como esta evoluo de arquiteturas se deu, aprofundando os detalhes referentes a arquiteturas multi-camadas mais novas.
Terminais burros e aplicativos Desktop Inicialmente, a arquitetura de acesso a dados existente era muito simples. Era uma arquitetura de apenas uma camada (single tier). Esta arquitetura era dominada pela poderosa presena dos mainframes, estes dinossauros da informtica. Em essncia, a arquitetura dominada pelos mainframes determinava que todo o processo de manipulao dos dados de aplicaes ou bancos de dados estava exclusivamente a cargo de um super-computador, que era o mainframe. Este trabalho era feito de forma rpida pelo mainframe, uma vez que haviam simples telas exibindo e entrando dados, denominadas comumente terminais burros. De fato, o terminal burro no era capaz de fazer nada, enquanto o mainframe fazia todo o trabalho, o que era facilmente aceitvel, pois: 1. O mainframe usualmente um poderoso computador; 2. A quantidade de dados processados ento era pequena, se comparada s demandas de nossos dias. O diagrama abaixo ilustra o funcionamento de uma arquitetura de uma camada dominada por um mainframe.
Figura X Diagrama representando um tpico modelo de uma camada dominado por um mainframe.
Posteriormente, esta arquitetura foi adaptada para computadores com capacidade de armazenamento de dados de bancos de dados e aplicativos. Estes computadores trabalhavam isoladamente, com o armazenamento local de dados. Os PCs foram se destacando, desta forma, como opes mais viveis para informatizao de dados. 125
Figura X Diagrama representando um tpico modelo de uma camada em um PC.
Aplicativos Client/Server Quando ocorreu esta mudana do suporte da arquitetura de uma camada, com o advento do PC, percebeu-se que os dados j no eram mais compartilhveis, como, de uma forma muito diferente, o eram em um mainframe. Foi esta a necessida bsica que fez surgir o modelo cliente/servidor (client/server). Em essncia, o modelo de acesso cliente/servidor age de forma a colocar a fonte dos dados de um banco de dados em um local acessvel a todos os computadores clientes. Um dos benefcios deste modelo o fato de um computador mais potente (denominado servidor) hospedar igualmente o sistema de banco de dados, o que lhe d maior velocidade nas respostas das requisies dos clientes; mas os clientes, por sua vez, tambm estavam encarregados de algum processamento, e j no eram simplesmente terminais burros. O modelo cliente/servidor trabalha, ento, sob uma arquitetura de duas camadas, que pode ser entendida claramente atravs do diagrama que segue:
FiguraX Representao de uma arquitetura de duas camadas usando um modelo cliente/servidor.
O modelo cliente/servidor trabalhou por muitos anos (e ainda trabalha!), e foi muitas vezes considerado um soluo ideal. Os problemas comearam quando o volume de dados manipulados pelas aplicaes foi se tornando muito grande. E, por mais que novos equipamentos mais potentes fossem surgindo, o problema contonua a presistir. Ento, por que isto aconteceu? Se olharmos o funcionamento dos mainframes, vemos que eles poderiam manipular a quantidade de dados que o modelo cliente/servidor no pode manipular. Por que? A razo bvia que explica este acontecimento est relacionada s redes de trabalho dos computadores. O mainframe apenas transportava sinais de tela para os terminais burros, isto , apenas a informao necessrio na hora certa. Por sua vez, o modelo cliente/servidor lida com 126
estes dados de uma maneira muito diferente, e que exige muito mais carga de rede. Algumas tcnicas foram implementadas ento para minimizar o problema dos acessos concorrentes em rede, tais como replicaes e sincronizao de dados. Contudo, nos dias de hoje percebe-se que o modelo cliente servidor est claramente esgotado.
Aplicativos distribudos A arquitetura multi-camadas foi desenvolvida pensando em resolver os problemas da arquitetura de duas camadas do modelo cliente/servidor. A soluo encontrada baseou-se na preservao das melhores caractersticas das arquiteturas de uma e duas camadas: 1. Os clientes deveriam receber apenas os dados que eles precisariam, e somente quando for necessrio. Estes clientes forma denominados thin clients (clientes leves). 2. A camada intermediria deveria manipular os dados, valid-los e post-los no servidor. A camada intermediria centraliza a lgica que governa suas interaes com o banco de dados, de forma que haja um controle centralizado nos relacionamentos dos dados. Isto permite que diferentes clientes usem os mesmos dados, ao mesmo tempo que assegurada uma consistente lgica na manipulao dos dados. Torna possvel, tambm, o desenvolvimento de clientes muito leves e mais fceis de serem instalados e configurados. Com o advento de acessos remotos a informaes de bancos de dados, com o particionamento dos direitos de acesso a aplicativos em muitos grupos diferentes de usurios, bem como o enorme crescimento do uso de pginas html dinmicas que acessam bancos de dados, a arquitetura multicamadas foi definitivamente implantada como novo modelo de desenvolvimento. As aplicaes multicamadas so tambm denominadas aplicaes distribudas devido ao fato de a lgica geral de uma aplicao estar dividida em diversas camadas independentes. Uma outra abordagem da arquitetura multi-camadas aquela que identifica a funcionalidade de cada camada. Uma camada de dados; Uma camada de regras dos dados das aplicaes ; Uma camada de apresentao.
127
FiguraX Representao de uma arquitetura de mltiplas camadas usando um modelo de acesso remoto.
Nas aplicaes de uma camada, todos os trs aspectos so manipulados pela aplicao. Nas aplicaes de duas camadas (como um aplicativo cliente/servidor), um servidor de dados manipula os dados e uma aplicao cliente manipula as regras dos dados e a apresentao.
Por que escrever aplicaes distribudas?

A distribuio de uma aplicao no um fim em si mesmo. As aplicaes distribudas introduzem um conjunto de novos conceitos de desenvolvimento e distribuio. Algumas aplicaes so intrinsicamente distribudas: jogos multi-usurios, Chats e aplicaes de teleconferncia so exemplos deste tipo de aplicaes. Nestes casos, os benefcios de uma infraestrutura robusta de computao distribuda so bvios. Muitas outras aplicaes so tambm distribudas, no sentido de que possuem ao menos duas aplicaes sendo executadas em mquinas diferentes. Uma aplicao distribuda pode acomodar diferentes clientes com diferentes capacidades, ao rodar alguns componentes no lado cliente quando possvel ou rod-los no lado servidor quando necessrio. Aplicaes distribudas so tambm muito mais escalveis do uma outra que no o seja. Se toda a lgica de uma aplicao complexa est contida em um nico mdulo, existe apenas uma maneira de aumentar o desempenho sem se rever a aplicao: um hardware mais rpido. Em uma aplicao distribuda, esta pode ser a ltima soluo a ser adotada.
A tecnologia DataSnap
128
DataSnap uma tecnologia da Borland que permite o envio de dados (em pacotes) em um rede de computadores comum, em uma rede distribuda ou em um sistema de arequivos local. Em essncia, DataSnap responsvel pelo empacotamento, armazenamento e envio de dados em qualquer situao. Esta tecnologia usada pelos datasets clientes, em combinao ou no com outros componentes de transmisso de dados. DataSnap prov as capacidades de aplicaes multi-camadas permitirem a aplicaes clientes conectarem a provedores em uma aplicao servidora. O suporte oferecido pelo Delphi para desenvolvimento de aplicaes multi-camadas uma extenso da maneira como os datasets clientes comunicam-se com um componente provedor, usando dados em pacotes transportveis. Uma vez que voc tenha entendido como criar e manipular uma aplicao de trs camadas, voc pode criar e adicionar camadas de servios, conforme a sua necessidade.
Entendendo aplicaes que acessam providers O suporte oferecido pelo Delphi para criao de aplicaes distribudas consiste em um conjunto de componentes das pginas DataSnap e DataAcess da palheta de componentes, mais um conjunto de outros objetos criados a partir da pgina multitier do Repositrio de Objetos. Em sntese, eles esto baseados na capacidade de componentes provedores empacotarem dados em pacotes transportveis e manipular atualizaes recebidas como pacotes de dados transportveis. Os tipos de componentes necessrios criao de um aplicativo multi-camadas descrito na tabela abaixo:
Componentes Mdulos de dados remotos Componentes provedores Datasets clientes Componentes de conexo Descrio Mdulos de dados especializados que podem agir como um objeto COM Automation, servidor SOAP ou CORBA que fornecem aos clientes acesso aos provedores nesles contidos. Tais objetos so usados na aplicao servidora. Agem como um data broker que prov dados criando pacotes de dados e resolvendo atualizaes dos clientes. So usados na aplicao servidora. Datasets especializados que usam a biblioteca midas.dll para manipular dados armazenados em pacotes. Os datasets clientes so usados nas aplicaes clientes. Uma famlia de componentes que localizam o servidor, estabelecem conexes e tornam interface COM IappServer acessvel aos datasets clientes. Cada componente de conexo especializado no uso de um determinado protocolo de comunicao.
Os protocololos da DataSnap
Existem muitos tipos de componentes de conexo que posem conectar um dataset cliente a uma aplicao servidora. Todos eles so descendentes de TCustomRemoteServer, e diferem primariamente quanto ao protocolo de conexo que cada um deles usa - DCOM, CORBA, TCP/IP, HTTP, ou SOAP. O componente de conexo estabelece uma conexo para a aplicao servidora e retorna um interface IappServer que os datasets clientes podem usar para requisitar dados aos provedores. Aqui ns tocamos em um ponto importante: a primeira considerao a ser feita quando voc iniciar o desenvolvimento de uma aplicao distribuda qual ser a tecnologia que ser usada nas chamadas dos procedimentos remotos. Chamadas de procedimentos remotos (remote procedures called RPC) o termo usado para definir a tecnologia de chamada remota de procedimentos ou funes.
129
COM, DCOM e COM+ Ns podemos criar uma aplicao servidora baseada nas tecnologia COM/DCOM/COM+ usando um Remote Data Module ou um Transactionl Remote Data Module. Esta metodologia usa as tecnologias COM e COM+ do Windows para invocar chamadas em um domnio Windows NT. Voc pode tambm usar estas tecnologia sem Ter um servidor de domnios Windows NT instalado.
FiguraX A estrutura de atividade do componente de conexo TDCOMConnection.
Vantagens: o mais rpido protocolo da plataforma Windows; Pode ser usado com outras aplicaes COM da Microsoft ou de outros fornecedores; Pode ser usado como um Servidor Transacional (MTS/COM+).
Desvantagens Pode ser de difcil configurao; No compatvel com sistemas operacionais que no pertenam `a famlia Windows.; Perde algumas funcionalidades quando no estiver sendo executado em um domnio Windows NT; Baixa portabilidade.
Quando usar Houver um grande nmero de clientes previstos Houver necessidade de integrao com outros objetos COM, tais como ActiveX ou servidores ASP; Domnios NTs fechados (sem WAN ou acessos de internet); Velocidade for fundamental; Portabilidade for secundrio.
130
CORBA Ns podemos riar uma aplicao servidora baseada em CORBA usando um CORBA Data Module. A conexo a esta aplicao servidora feita atravs de um componente TCORBAConnection. A implementao DataSnap usa o VisiBroker como OSAgent, para que as aplicaes automaticamente tenham um balano de carga e uma implementao de segurana contra falhas.
FiguraX O esquema de ao do componente de conenxo TCORBAConnection
Vantagens Independncia de locao; Tratamento automtico de falhas; Fcil escalonamento do balano de carga; Fcil configurao; Portbilidade a outros sistemas operacionais; Alta escalabilidade.
Desvantagens Necessita de uma subnet TCP/IP; Custo pode ser aumentado; No conversa com aplicativos Microsoft.
Quando usar Grandes implementaes; Portabilidade importante; Escalabilidade requerida;
131
TCP/IP (Sockets) O componente TSOcketConnection usa uma implementao COM/COM+ existente atravs de um proxy conhecido como Socket Server. Esta implementao uma soluo da Borland que trabalha no sentido de prover as conexes dos clientes ao servidor de dados atravs de uma porta TCP/IP conhecida como socket. Deve ser lembrado que este protocolo foi intencionado como sendo uma ltima soluo. Esta abordagem conhece algumas limitaes, principalmente no que diz respeito degradao do trfego de rede e limite de clientes conectados. Para uma informao completa, consulte a ajuda do Delphi.
FiguraX O esquema de ao do componente de conenxo TSocketConnection
Vantagens Como usa COM, pode ser usado em uma implementao COM j existente; Fcil conexo a partir de uma conexo remota ou pela internet; Fcil configurao; Pode ser segura com o uso de um interceptador. Desvantagens Dependncia do COM; Usa entrada de ponto simples. Socket ocupado ser bloqueado; Baixo desempenho global; No trabalha com DCOM ou objetos COM remotos; Dependente de locao.
Quando usar: Acesso remoto ou discado requerido; Implementaes mais leves.
132
HTTP (WEB) O componente TWEBConnection usa uma implementao mltipla de uma conexo DCOM, um servidor WEB e um navegador WEB. Ele trabalha com o mesmo princpio de um proxy em uma conexo socket, mas no usa uma porta TCP/IP e sim um IIS Web Server. Os clientes usam um browser para transportar requisies HTTP request/response. Este componente pode fazer uso de muitos recursos de autenticao de segurana da internet. Este protocolo tambm deveria ser usado como ltima opo. , contudo, muito mais seguro e flexvel queuma conexo usando simplesmente sockets, pois os clientes no precisam discar na sua rede, mas usam qualquer conexo de internet. Isso significa que um cliente pode estar em qualquer lugar do mundo e ainda estar apto a usar a sua implementao.
FiguraX O esquema de ao do componente de conenxo TWEBConnection
Vantagens Como usa COM, pode ser usado com um objeto COM j existente; Conexo muito fcil na internet; Fcil configurao; Muito seguro (com IE para IIS SSL);
Desvantagens Dependente do COM; Usa ponto de entrada simples. Um WEB Server ocupado bloquear o acesso; Pode ser uma conexo lenta; Dependente de uma implementao WEB.
Quando usar Conexo atravs da internet requerida; Implementaes leves que usam a internet como backbone.
133
Entendendendo datasets
A unidade fundamental para acesso a dados a famlia de objetos dataset. Sua aplicao usa datasets para rodo acesso a banco de dados. Um objeto dataset representa um conjunto de registros de um banco de dados organizados em uma tabela lgica. Estes registros podem ter sua origem em uma nica tabela ou podem representar o resultado da execuo de uma consulta sql ou de uma stored procedure. Todos os datasets que voc pode usar descendem de TDataset, e eles herdam campos de dados, propriedades, eventos e mtodos implementados por esta classe. O que um TDataset? TDataset um dataset virtualizado, o que significa que muitas de suas propriedades e mtodos so definidas como virtual ou abstract. Um mtodo virtual uma declarao de funo ou procedimento cuja implementao pode ser sobrescrita nas implementaes de objetos descendentes. Um mtodo abstrato uma declarao de funo ou procedimento que no conhece uma implementao ao nvel da classe do mtodo abstrato. A declarao um prottipo que descreve o mtodo (e seus parmetros e valores de retorno se houverem) que devem ser implementados em todos os descendentes de TDataset, mas que podem ser implementados de maneira diferente em cada um dos descendentes. TDataset define muito do que comum a todos os objetos datasets. Por exemplo, TDataset define a estrutura bsica de todos os dataset: um array de campos (objetos TField) que correspondem a colunas em uma ou mais tabelas, campos lookup ou campos calculados.
Famlias de datasets TDataset possui muitos descendentes imediatos, cada um correspondendo a um diferente mecanismo de acesso a bancos de dados. Voc no trabalha diretamente com qualquer um destes descendentes diretos, pois cada um deles implementa uma grande quantidade de propriedades e mtodos que so adequados especificamente para um mecanismo de acesso a dados e cada um destes mtodos e propriedades so expostos para classes descendentes que so adapatadas para diferentes tipos de dados. Os descendentes imediatos de TDataset so: TBDEDataset , que usa o Borland Database Engine (BDE) para se comunicar com fontes de dados. Os descendentes de TBDEDataset que voc usa so TTable, TQuery, TStoredProc e TNestedTable. TCustomADODataset , que usa ActiveX Data Objects (ADO) para se comunicar com uma fonte de dados OLEDB. Os descendentes de TCustomADODataset que voc usa so TADODataset, TADOTable, TADOQuery e TADOStoredProc. TCustomSQLDataset , que usa DBExpress para se comunicar com servidores de banco de dados. Os descendentes de TCustomSQLDataset que voc usa so TSQLDataset, TSQLTable, TSQLQuery e TSQLStoredProc. TIBCustomDataset , que se comunica diretamente com um servidor de banco de dados Interbase ou Firebird. Os descendentes de TIBCustomDataset que voc usa so TIBDataset, TIBTable, TIBQuery e TIBStoredProc.
134
TCustomClientDataset , que representa os dados de um outro dataset ou dados de um arquivo em disco. Os descendentes de TCustomClientDataset que voc usa so TClientDataset (que se conecta a uma fonte externa de dados) e outros datasets especializados em um particular mecanismo de acesso.
Como a VCL prov uma grande flexibilidade na estruturao de novos descendentes de TDataset, voc pode criar seu prprio descendente de TDataset, por exemplo para recuperar dados de uma planilha eletrnica ou um dataset de memria. Existem tambm uma infinidade de descendentes de TDataset, disponveis em pacotes de componentes, e que possuem caractersticas especficas para acessar um tipo de banco de dados atravs de mecanismos diferentes. Como a programao para banco de dados um dos tipos de desenvolvimento mais comuns, existe uma enorme quantidade de datasets disponveis que voc pode instalar para testar suas funcionalidades. O diagrama de classes abaixo mostra uma viso completa da famlia de datasets usadas pelo Delphi 6.
FiguraX Diagrama de hierarquia dos objetos descendentes de TDataset.
Tipos de datasets No item acima, vimos todos os datasets classificados pelos mtodos que eles usam para acessar dados. Voc pode classific-los tambm pelos tipos de servidores de dados que eles representam. Sob este ponto de vista, existem trs classes bsicas de datasets: Table-type datasets: tables-type datasets representam uma nica tabelas do banco de dados, incluindo todas as linhas e todas as colunas. Dentro deste tipo de datasets encontramos Ttable, TADOTable, TSQLTable e TIBTable. Embora table-type datasets possam ser teis e eficientes em muitas situaes, seu uso mais recomendado quando voc precisar trabalhas com bancos de dados locais. Query-type datasets: query-type datasets representam um comando SQL, ou consulta. Consultas podem representar o resultado de um comando executado (tipicamente uma DML). Estes tipos de 135
datasets podem tambm executar comando que no retornam qualquer resultado (por exemplo, um comando INSERT ou UPDATE). Entre estes tipos de datasets encontramos Tquery, TADOQuery, TSQLQuery e TIBQuery. Estes tipos de datasets forma desenvolvido para serem usados com servidores de dados SQL, mas alguns mecanismos de acesso podem processar uma consulta SQL sobre bancos locais. Use sempre estes datasets quando trabalhar com servidores SQL, tais como Informix, Interbase ou Oracle. Stored procedure-type datasets: stored procedure-type datasets representam um procedimento armazenado (stored procedure) em um servidor SQL remoto. Entre os datasets inclusos nesta categoria esto TStoredProc, TADOStoredProc, TSQLStoredProc e TIBStoredProc.
Alm destas categorias, existem dataset que se enquadram em mais de uma categoria ao mesmo tempo: TADODataset e TSQLDataset tm uma propriedade CommandType que permite-lhe especificar se eles representam uma tabela (table), consulta(query) ou um procedimento armazenado (stored procedure). TClientDataset representa os dados de um outro dataset e, como tal, pode representar uma tabela (table), consulta(query) ou um procedimento armazenado (stored procedure). TClientDataset tambm pode conter uma consulta SQL que pode ser utilizada como qualquer consulta deste tipo. Alguns outros client datasets (TBDEClientDataset e TSQLClientDataset ) tm uma propriedade CommandType que age da mesma forma como nos datasets acima descritos. TIBDataset pode representar tanto consulta(query) como um procedimento armazenado (stored procedure). De fato, este dataset pode representar mltiplas consultas e procedimentos armazenados simultaneamente em propriedades separadas para cada um deles. Nota: para usar query-type datasets voc deve estar familizarizado com a linguagem SQL e muitas das suas subdivises como DML ou DDL.
Usando os eventos de TDataset Datasets tm eventos que habilitam uma aplicao perfazer validaes, computar totais e muitas outras tarefas. Todos os eventos tm um comportamento uniforme em todos datasets. A tabela abaixo fornece uma lista dos eventos disponveis com uma sucinta descrio:
Evento BeforeOpen / AfterOpen BeforeClose / AfterClose BeforeInsert / AfterInsert BeforeEdit / AfterEdit BeforePost / AfterPost BeforeCancel / AfterCancel BeforeDelete / AfterDelete OnNewRecord OnCalcFields Descrio Chamados antes / aps o dataset ser aberto Chamados antes / aps o dataset ser fechado Chamados antes / aps o dataset entrar em estado de insero Chamados antes / aps o dataset entrar em estado de edio Chamados antes / aps as alteraes serem gravadas Chamados antes / aps as alteraes serem canceladas Chamados antes / aps um registro ser deletado Chamado quando um novo registro inserido; use para iserir valores padro Chamado quando campos calculados so calculados
Alm destes eventos, alguns client datasets implementam eventos especficos:

Evento BeforeApplyUpdates / AfterApplyUpdates BeforeExecute / AfterExecute BeforeGetparams/ AfterGetParams BeforeRowRequest / AfterRowRequest Descrio Chamados antes / aps o dataset aplicar as atualizaes a um provider Chamados antes / aps o dataset executar um comando Chamados antes / aps o dataset receber parmetros de um provider Chamados antes / aps o dataset transferir informaes sobre o novo registro
136
OnReconcileError
Chamado quando um dataset precisa reconciliar erros ocorridos durante atuaizaes.
137
CAPTULO 10 - TRABALHANDO
COM A
BDE
A Borland Database Engine (BDE) mecanismo de acesso a dados que pode ser compartilhado por diversas aplicaes. A BDE define uma poderosa biblioteca de chamadas de API que podem criar, reestruturar, trasferir dados, atualizar e manipular tanto bancos de dados locais como servidores de banco de dados remotos. Para isto, a BDE prov uma interface uniforme de acesso a uma grande variedade de servidores de bancos de dados, usando drivers que se conectam a diferentes bancos de dados. Dependendo da sua verso do Delphi, voc pode usar drivers para bancos locais (Paradox, dBase, FoxPro e MSAcess), drivers SQL (SQL links) para servidores remotos como Interbase, Oracle, Sybase, Informix, Microsoft SQL Server e DB2, e um adaptador ODBC que lehe permite usar seu prprio driver ODBC. Quando voc distribuir aplicaes baseadas em BDE, voc deve incluir o BDE com a sua aplicao. Isto certamenta aumentar o tamanho de seu programa de instalao, assim como a complexidade da distribuio de seu aplicativo, mas a BDE pode ser compartilhada com outras aplicaes nela baseadas e prover um backgroung de suporte a aplicaes de banco de dados bastante complexo. Embora voc possa usar chamadas diretas API da BDE, os componentes da pgina BDE da Component Pallete encapsulam a maior parte das funcionalidades para voc. Este captulo mostrar os conceitos mais importantes da programao de aplicaes baseadas em BDE, bem como o significado e utilidade dos componentes que manipulam bancos de dados atravs deste mecanismo.
138
Conhecendo a BDE
A BDE consiste basicamente de um conjunto de arquivos e executveis que formam um ambiente ou framework entre uma aplicao e um banco local ou servidor de dados. A BDE responsvel por ler, escrever e acessar os dados de seu banco de maneira completamente automtica, isto , sem que voc tenha que se ocupar de implementar rotinas para fazer isto, como, por exemplo, usar chamadas de API de servidores de dados remotos. A BDE tambm providencia um mecanismo para que voc configure de maneira fcil diversos detalhes referentes a como voc ir acessar os dados, como as timeout de conexes, modos de leituras e escrita, linguagens internas de bancos a usar e muito mais. A BDE sabe como requisitar ou passar informaes ao seu banco de dados e tratar dos muitos detalhes envolvidos nestas operaes. A BDE faz isto atravs de drivers especialmente desenvolvidos para se comunicar com um determinado banco de dados. Existem drivers BDE para qualaquer tipo de banco que voc deseje usar. Veja abaixo um esquema que ilustra a arquitetura de aplicaes que usam BDE para acessar dados:
Figura Esquema geral de um aplicativo de uma camada que acessa dados usando a BDE
Drivers usados pelo BDE O BDE possui drivers para acessar tanto bancos locais como servidores de dados remotos. Estes drivers consistem em bibliotecas dinmicas (dlls) que acessam diretamente as rotinas necessrias para manipular os mais diversos tipos de bancos. Estes drivers so classificados em 2 tipos: Nativos: so drivers que colocam as interfaces presentes no BDE em acesso direto a um banco de dados. Existem drivers nativos para acesso aos bancos Paradox, Dbase, MSAcess, FoxPro, Xbase, Oracle, Interbase, Firebird, Informix, MSSQL Server, DB2 e Sybase. ODBC: so drivers que colocam o BDE em contato com outro driver ODBC instalado em seu sistema para realizar o acesso a um banco de dados.
Lembre-se apenas de que a maioria dos drivers ODBC instalados com o Windows so extremamente lentos e, com muita freqncia, pouco confiveis. Alm do mais, a tecnologia ODBC de acesso a dados est obsoleta e abandona pela prpria Microsoft, que o substituiu por tecnologias bem mais avanadas, como OLEDB e ADO. Os drivers nativos so mecanismos rpidos e bastante confiveis e tm sido tradicionalmente usados, desde a primeira verso da BDE, com sucesso.
139
O BDE Administrator O BDE Administrator uma ferramenta gerenciadora de conexes usadas pelo BDE. Com esta ferramenta voc pode criar um novo Alias (um nome para uma conexo com um banco de dados de determinado tipo), alter-lo ou destru-lo a qualquer instante. Os aplicativos que usam a BDE se comunicam com ela atravs deste Alias, e possvel examinar e alterar as configuraes de cada um dos aliases em particular. Voc pode tambm acessar as configuraes gerais dos drivers instalados acessando a pgina Configuration desta ferramenta. Mais a rente discutiremos o funcionamento deste aplicativo.
Suporte Delphi a aplicaes BDE

O suporte Delphi a aplicaes baseadas em BDE fornecido principalmente por uma grande quantiodade de componentes que acessam de forma transparente os recursos disponveis pelo middleware. Estes componentes so datasets aptos para acessar qualquer tipo de banco de muitas formas diferentes. Existem tambm ferramentas que so instaladas com o Delphi e que auxiliam muitas tarefas comuns durante o desenvolvimento de um aplicativo BDE, como a criao de tabelas, ndices etc de bancos de dados, anlise dos dados de um banco ou monitorao e anlise de acessos a servidores de dados remotos. Mais adiante estas ferramentas so citadas e detalhados os seus recursos.
Datasets baseados em BDE Aplicaes baseadas em BDE usam datasets especficos paraacessarem dados atravs desta tecnologia. Estes dadtasets herdam todas as capacidades implementadas com TDataset, sendo tambm implementados propriedades, eventos e mtodos novos que objetivam trabalhar com a BDE. Estes recursos podem ser sumarizados nos seguintes pontos: Associao de datasets como objetos de conexo com banco de dados e controle de sesso de acesso, Processos de caching de dados BLOBs; Obteno de um Handle de acesso ao BDE.
Existem trs datasets baseados em BDE: TTable, um table-type dataset que representa todas as linhas e colunas de uma nica tabela de um banco. TQuery, um query-type dataset que prov recursos de execuo de consultas SQL. TStoredProc, um stored procedure-type dataset que executa um procedimento armazenado de uma servidor de dados SQL. Nota: adicionalmente, TBDEClientDataset pode trabalhar como um dataset BDE normal, mas trabalha tambm como um client dataset.
Entendendo TDatabase e TSession Para que datasets baseados em BDE possam recuperar dados de um servidor de dados remoto, eles precisam trabalhar com um objeto TDatabase e com um objeto TSession. 140
Tdatabse representa uma conexo para um servidor especfico. Ele identifica um driver BDE, um servidor de dados que aceita este driver e um conjunto de parmetros de conexo a serem passados ao servidor. Cada banco de dados representado por um componente Tdatabase ao qual voc pode associar muitos datasets. Se os datasets de seu aplicativo no possuem um TDatabase associado, o Delphi criar dinamicamente um destes componentes e vincular os datasets a ele. Voc deveria sempre criar o seu prprio TDatabase, pois ele propicia um controle muito centralizado da conexo e seus parmetros. Para associar um dataset BDE a um TDatabase, use a propriedade DatabaseName, que uma string que contem diferente informaes, dependendo do tipo de banco de dados que voc estiver usando. Uma seo (session) prov gerenciamento global para um grupo de conexes com um banco de dados em um aplicativo. Qhando voc adiciona datasets baseados em BDE sua aplicao, ela automaticamente incluir uma componente TSession denominado Session. medida que voc adiciona datasets em seu programa eles so automaticamente associados com este componente de seo padro. Este componente tambm controla o acesso a a arquivos Paradox ou Dbase protegidos e especifica localaizaes de diretrios para arquivos Paradox compartilhados em uma rede. Voc pode controlar conexes com bancos de dados e acessos a arquivos Paradox usandos as propriedades, eventos e mtodos de TSession. Alternativamente, voc pode adicionar um componente TSession ao seu aplicativo em tempo de projeto (ou ento cri-lo dinamicamente durante a execuo de se aplicativo) para controlar um conjunto de datasets. Para associar um dataset com um TSession explicitamente criado, use a propriedade SessionName; porm, se voc no prov um Tsession, voc no deve inserir qualquer valor para esta propriedade. Para acessar um objeto TSession criado explicitamente ou no, use a propriedade DBSession dos datasets.
Mtodos de TDatabase e TSession No geral, o componente Tsession providencia recursos globais que se aplicam a todos componentes TDatabase implicitmente criados. Por exemplo, a propriedade KeepConnection de Tsession determina se uma conexo feita por TDatabase mantida se todos os datasets a ela vinculados so fechados. Similarmente, o evento OnPassword de objetos Tsession garante que uma caixa de dilogo de senha de acesso seja exibida toda vez que um usurio est prestes a estabelecer uma conexo com um banco que exija validao de usurios. Os mtodos de Tsession, por sua vez, agem sobre todas as conexes criadas por uma aplicao. Por exemplo, o mtodo DropConnections fecha todos os datasets vinculados a uma conexo de banco de dados e, ento, fecha todas as conexes, mesmo se a propriedade KeepConnection para um componente TDatabase em particular estiver definida como True. Os mtodos do componente TDatabase aplicam-se apenas para os datasets associados com uma determinada instncia de TDatabase. Suponha, por exemplo, que uma instncia de TDatabase (Database1) est associada com um Tsession padro.
Database1.CloseDataSets;
Fecha todos datasets associados com Database1.
Recursos avanados do BDE
141
CACHING BLOBs Todos os datasets baseados em BDE tm uma propriedade denominada CacheBlobs, que controla se os valores de um campo BLOB so armazenados localmente pelo BDE. Por padro, esta propriedade boolean tem o valor True , o que significa que o BDE deve armazenar localmente uma cpia destes dados. O armazenamento local de dados BLOBs melhora o desempenho de um aplicativo, pois impede a leitura constante de uma fonte de dados medida que o usurio navegaentre os registros de um dataset. Este recurso pode ser extremamente benfico em aplicaes que acessam servidores de dados remotos atravs de uma rede, pois diminui drasticamente o trfego de rede ao longo de acessos a registros de um banco de dados. Em aplicaes onde campos BLOBs so freqentemente alterados ou uma visualizao sempre atual dos dados de um campo BLOB muito importante, voc pode alterar o valor da propriedade CacheBlobs para False, o que assegurar que se seu aplicativo sempre ter as ltimas verses dos dados de uma campo BLOB.
Obtendo um handle BDE Na maioria das aplicaes BDE que voc desenvolver no necessitar necessrio fazer chamadas diretas API do BDE. A combinao de datasets, Tdatabase e Tsession encapsula a maior parte das funcionalidades deste mecanismo. Contudo, se voc precisar fazer chamadas diretas API do BDE, ser necessrio o uso de manipuladores (handles) de recursos gerenciados pelo BDE. Muitas funes e procedimentos da API do BDE requerem estes manipuladores como parmetros. Todos datasets baseados em BDE incluem trs propriedades no alterveis para acessar handles BDE em tempo de execuo: Handle um manipulador para o cursor BDE que acessa os registros no dataset; DBHandle um manipulador para bancos de dados que contm as respectivas tables e procedimentos armazenados. DBLocale um manipulador para drivers de linguagens da BDE. Estes recursos podem controlar a ordenao de campos strings etc.
A estas propriedades so atribudos valores automaticamente quando voc conecta um dataset a um servidor de dados atravs da BDE.
Manipulando transaes Por padro, a BDE prov um controle implcito de transaes para suas aplicaes. Quando uma aplicao est sob controle implcito de transaes, uma transao separada usada para cada registro em um dataset que escrito em uma determinada base de dados. O controle implcito de transaes garante tanto um mnimo de conflito no processo de atualizao do registro como uma viso consistente de um banco de dados. Por outro lado, devido ao fato de cada registro escrito tomar lugar em sua prpria transao, o controle implcito de transaes pode aumentar o trfico na rede e diminuir o desempenho do aplicativo. O controle implcito de transaes tambm impede a execuo de operaes lgicas que escrevem mais de um registro dentro de uma nica operao validvel (spanning). Se voc controla explicitamente as transaes, voc pode escolher o mais efetivo momento de iniciar, confirmar (commit) ou revogar (roolback) suas transao. Quando voc desenvolve aplicaes em um 142
ambiente multi-usurio e, particularmente, quando suas aplicaes acessam um servidor SQL remoto, voc deve controlar explicitamente as transaes. Existem duas maneiras de controlar explicitamente as transaes no BDE. Use o componente TDatabase para controlara as transaes. A maior vantagem de usar este componente o fato de propiciar um portabilidade `aua aplicao, independentemente do servidor SQL remoto que voc deseja usar. Use passthrough SQL em um componente Tquery para passar consultas SQL diretamente para um servidor SQL remoto ou driver ODBC. A maior vantagem de passthrought SQL que voc pode usar o sistema de manipulao de transaes de um servidor de banco de dados particular.
Nota: Quando voc estiver trabalhando com bancos de dados locais, voc no pode usar passthrough SQL. importante observar que o uso de transaes em bancos de dados locais possui limitaes; mas o BDE encapsula a maior parte das funcionalidades relacionadas ao uso de transaes de forma totalmente automtica.
Usando passthroug SQL Com a tcnica denominda Passthrough SQL voc usa os componentes TQuery, TStoredProc ou TUpdateSQL para enviar uma rotina SQL de controle de transao diretamente para um servidor de dados remoto. O BDE no processa a rotina SQL a ser passada. O uso de passthrough SQL possibilitalhe obter vantagens diretas do controle de transaes oferecidos pelo seu servidor remoto. Para usar passthrough SQL necessrio configurar adequadamente o parmetro de configurao SQLPASSTHRU MODE do sql link usado pelo BDE para o seu aplicativo. Para maiores informaes, consulte a ajuda on-line do Delphi.
Usando transaes locais O BDE implementa um mecanismo de transaes locais para bases de dados Paradox, dBase, Acess e FoxPro. Sob a perspectiva da codificao, no existem diferenas entre uma transao local e uma transao em um servidor SQL. Contudo, claro que transaes locais so muito mais limitadas: Recuperao automtica de erros (Automatic crash recover) no provido; Recursos de definio de dados (DDL) no so suportados; Transaes no podem ser executadas em tabelas temporrias; Para tabelas Paradox, transaes s posem ser executado com ndices vlidos. Do contrrio, os dados no podem sofrer rollback; Apenas um nmero limitado de registros podem ser travados e modificados. Em tabelas Paradox, este limite mximo de 255 registros. Em dBase, o limite mximo 100; Na configurao de seu Alias BDE, o permetro TransIsolation deve ser configurado apenas para tiDirtyRead.
Ferramentas de trabalho com a BDE

Quando voc necessitar trabalhar com o BDE, poder usar diversas ferramentas que so distribudas com o Delphi. Estas ferramentas incluem:
143
SQL Explorer. Esta ferramenta propicia um mecanismo de exame e manipulao muito detalhado da estrutura e dos dados bancos de dados registrados na BDE. Voc pode examinar as tabelas existentes; os campos de cada tabela; os dados de cada tabela etc. Tambm possvel inserir ou alterar dados e executar consultas SQL em um banco de dados. Voc pode criar atributos de objetos de bancos de dados, manipular um dicionrio de dados; criar objetos SQL tais como stored procedures em servidores SQL remotos etc.
Figura O SQL Explores exibindo os dados de objetos de um banco de dados que associado ao alias atual.
SQL Monitor Esta ferramenta de monitoramento e debugao permite o exame das comunicaes feitas entre um servidor SQL remoto e o BDE. BDE Administrator Esta ferramenta permite a voc adicionar novos drivers de bancos de dados, configurara os existentes e criar/manter alias BDE que apontam para bancos de dados.
144
Figura Janela principal do BDE Administrator. Os aliases so exibidos esquerda, enquanto suas configuraes aparecem no painel maior direita.
Database Desktop Esta ferramenta permite a criao, edio e alterao da estrutura de tabelas Paradox ou dBase. Voc pode tambm visualizar os dados de tabelas e edit-los.
O futuro da BDE
Em 2000, a Borland lanou um nova arquitetura de drivers SQL chamada DBExpress. A DBExpress desenhada para propiciar alta performance no acesso a dados e simplificar a distribuio e configurao de drivers SQL. A arquitetura DBExpress destinada ao acesso a bancos SQL, e foi desenhada para ser altamente portvel entre as plataforma Linux e Window. A DBExpress no usa a BDE. Esta nova arquitetura de drivers substitui a funcionalidade de acesso SQL a dados dos drivers SQL-links do BDE, mas o faz sem a necessidade de runtimes e outros objetos distribudos que compoem o BDE. Atualmente, DBExpress a soluo de acesso recomendada pela Borland, que agora desaconselha a construo de aplicativos que acessam servidores sql remotos via BDE. A tecnologia de SQL links usada pelo BDE no sofrer mais evolues, de forma que a Borland hoje os considera depreciados ou superados, declarando publicamente que aconselha a migrao para a tenologia DBExpress. Como o Delphi oferece diferentes mecanismos de acesso a banco de dados baseados em datasets, possvel realizar uma migrao com um mnimo de alterao do seu cdigo-fonte ou mesmo sem alterao alguma, de forma que a Borland tem divulgado um esforo mnimo durante a migrao.
Acesso a dados para tabelas locais O BDE possui um grande suporte a bancos de dados locais, atis como Paradox, dBase e Acess. A Borland tem declarado que o suporte ao BDE como middleware de acesso a bancos de dados locais ir ser continuado normalmente. Isto significa que o BDE ser distribudo com as novas verses do Delphi, porm novos recursos no sero adicionados ao BDE, exceo de correes de possveis bugs. O resumo de tudo isto que novos desenvolvimentos devem ser feitos sempre com bancos de dados sql e usando a tecnologia de alta performance DBExpress.
145
146
CAPTULO 13 - APLICAES
BASEADAS EM
ADO
Os componentes ADOExpress proveem acesso a dados atravs Microsoft ActiveX Data Objects (ADO) framework, um conjunto de objetos COM que acessam dados atravs de um provedor OLEDB. Os componentes ADOExpress encapsulam estes objetos em uma arquitetura de banco de dados. O layer de uma aplicao baseada em ADO consiste de Microsoft ADO 2.1, um OLEDB provider ou um ODBC driver para acesso a fontes de dados, programas clientes para um sistema de banco de dados especfico (em sistemas de bancos de dados SQL) e o banco de dados. Tudo isto deve dever estar acessvel para a aplicao baseada em ADO para que ela seja funcional. Os objetos COM ADO mais proeminentes so Connection, Command e Recordset. Estes objetos ADO so encapsulados pelos componentes TADOConnection, TADOCommand e alguns datasets. O framework ADO incluem outros objetos auxiliares, como objetos Field e Properties, mas eles no so tipicamente usados na implementao Delphi de acesso via ADO. Neste captulo voc poder perceber os principais aspectos desta tecnologia, bem como possvel construir aplicaes robustas acessando fontes de dados muito variadas, como uma planilha de dados, bancos MSAcess, MSSQL Server, Oracle ou Interbase. Porm, para compreender bem como ADO trabalha e como voc poderia retirar o mximo desta tecnologia, indispensvel um conhecimento bsico do modelo de objetos COM e DCOM do Windows, que o fundamento real tanto deste sistema operacional como do framework ADO.
147
A arquitetura ADO
A arquitetura ADO foi criada pela Microsoft dentro do escopo de uma estratgia maior de desenvolvimento de tecnologias de acesso a dados conhecida como UDA (Universal Data Acess), que tambm engloba OLEDB e ODBC. Embora muitas destas tecnologias se confudam em alguns pontos, e ODBC esteja em franco processo de depreciao e abandono, voc deve compreender ADO como um mecanismo de acesso a dados que usa objetos COM (Component Object Model) e DCOM (Distributed Component Object Model) que sabem como acessar um tipo de dado em paricular. Estes objetos COM so acessados por outras aplicaes atravs das interfaces que exportam, o que quer dizer que colocam acessvel ao mundo externo mtodos e propriedades das suas interfaces. ADO pode acessar diversos tipos de dados, pois, na verdade, constitui apenas um framework no qual as aplicaes podem ser executadas e, muito especialmente, oferece um mecanismo complexo de isolamento de execuo de aplicativos. Disto tudo, pode-se concluir que a tecnologia ADO tende a ser realmente universal, no sentido de que, sob seu ponto de vista, dados no so somente os registros que podem ser recuperados de um determinado banco de dados, mas qualquer tipo de informao disponvel que um driver OLEDB consiga entender, tais como textos, documentos, sistemas de arquivos, informaes do sistema operacional etc. A tecnologia ADO tambm foi desenvolvida inicialmente pensando-se em uma arquitetura de software distribuda, na qual ADO apenas um invlocro agradvel para a comunicao entre uma camada de aplicativo servidor e outra contendo as fontes de dados. No diagrama ao lado voc pode perceber claramente isto: ADO acessa uma fonte de dados atravs de um driver OLEDB que sabe como faz-lo. O framework ADO, por si, no sabe como poderia trabalhar com esta fonte de dados. A camada intermediria (business Process ou business tier) sabe como requerer de ADO uma determinada informao, pois conhece os mtodos exportados pelas interfaces dos objetos COM do driver OLEDB.
Figura Modelo da arquitetura de objetos do Microsoft ADO.
148
A camada de interface (cliente) usa COM ou DCOM para se comunicar com a camada intermediria, recebendo e enviando dados.
Voc perceber, ao longo dos prximos captulos, que grande parte do suporte Delphi a banco de dados e, de uma forma mais ampla, a acesso a dados est voltado para o desenvolvimento de aplicaes distribudas. A tecnologia ActiveX Data Objects (ADO) uma soluo muito adequada a este tipo de desenvolvimento. Mas lembre-se: ADO uma soluo de todo dependente da plataforma Windows, embora o modelo distribuda permita-lhe sempre dividie as peas lgicas de uma determinada aplicao em um ou mais sistemas operacionais. Nota: a tecnologia COM, DCOM, ActiveX e suas derivadas sero estudadas no curso Delphi e Tecnologias para Internet. Tecnologia OLEDB OLEDB uma interface de programao a nvel de sistema para acesso a dados. OLEDB tambm uma especificao aberta, desenhada para acessar uma grande variedade de fontes de dados e, em ltima instncia, qualquer tipo de dados, e pode acessar fontes de dados relacionais ou no-relacionais. Vrios funes de sistemas gerenciadores de bancos de dados so encapsulados por OLEDB, que abilita a criao de componentes de softwares implementados como servicos OLE. Os componentes consistem de provedores de dados (Data Providers), que contm e expem os dados; Data Consumers, que usam os dados; e services, que operam funes de agrupamento, ordenao de dados etc. Drivers OLEDB so objetos OLE existentes em bibliotecas dinmicas que, uma vez registrados, podem ser usados por qualquer aplicao que seja capaz de comunicar-se atravs do COM. Existem muitos drivers OLEDB desenvolvidos para fontes de dados diferentes, como bancos Acess, Oracle ou Interbase. Com Delphi, voc tambm pode desenvolver seus prprios drivers OLEDB para as fontes de dados que desejar. A figura abaixo ilustra o mecanismo de funcionamento de um driver OLEDB atravs de interfaces de objetos COM.
Figura Esquema geral de funcionamento de um provedor OLEDB. Atravs de interfaces de objetos COM, eles se comunicam com a camada ADO que, por sua vez, transfere os dados para um cliente ou um servidor de dados.
Conhecendo a interface ADO Microsoft ActiveX Data Objects (ADO) uma interface de programao para dados a nvel de aplicaes para dados encapsulados junto a um driver OLEDB. ADO prov um consistente acesso a
149
dados em alta performance e suporta uma variedade de tarefas de desenvolvimento, como a criao de aplicaes clientes de bancos de dados, objetos middle-tier de validao de regras comerciais usadas pelas aplicaes clientes ou navegadores WEB. ADO desenhada para ser uma interface de dados necessria para aplicaes de uma ou multi-camadas (incluindo aplicaes servidoras baseadas na WEB). Um dos prncipais recursos implementados por ADO oferecer uma interface de programao de fcil uso para alguns dos mais complexos aspectos do trabalho com drivers OLEDB. Como ADO oferece um mecanismo de acesso a objetos OLE/COM, voc tambm pode us-la com linguagens de scripts. Nota: ADO instalado como padro nos sistemas operacionais Windows98 em diante e substitui a fracassada tecnologia ODBC. A imagem abaixo mostra o modelo de objetos implementado com ADO.
Figura Modelo de objetos ADO implmentados pela Microsoft.
Conhecendo a ADOExpress A pgina ADO da palheta de componentes aramzena os componentes ADOExpress. Estes componentes permitem realizar uma conexo com uma fonte de dados ADO, executar comandos e retornar dados de tabelas em bancos de dados usando o framework ADO. Voc precisa ter instalado o Microsoft ADO 2.1 (ou superior) em seu computador. Alm disto, no computador on as aplicaes clientes sero executadas, para drivers OLEDB para o sistema de banco de dados a acessar tambm devem estar instalados. Muitos componentes ADOExpress escontram componentes semelhantes disponveis para outros mecanismos de acesso. ADOExpress disponibiliza um componente de conexo (TADOConnection) e vrios tipos de datasets. Adicionalmente, ADOExpress inclui TADOCommand, um componente que no um dataset, mas representa um comando SQL a ser executado. A tabela abaixo lista os componentes ADOExpress:
150
Componente TADOConnection TADODataset TADOTable TADOQuery TADOStoredProc TADOCommand
Funcionalidade Estabelece uma conexo com uma fonte de dados ADO. Os datasets podem compartilhar uma mesma conexo. O componente primrio usado para para retornar e operar sobre dados. Pode retornar dados de mltiplas tabelas. Usado para retornar e operar sobre dados produzidos a partir de uma nica tabela. Usado para retornar e operar dados produzidos a partir de um comando SQL vlido. Pode tambm executar DDL. Usado para executar procedimentos armazenados de todos os tipos. Usado primariamentepara executar comandos SQL que no retornam dados.
Conectando com fontes de dados ADO

Para conectar sua aplicao com uma fonte de dados ADO, use o componente TADOConnection. Embora TADOConnection so seja estritamente requirido, pois TADOCommand e os componentes datasets so capazes de estabelecer uma conexo direta usando a propriedade ConnectionString, voc pode usar TADOConnection para compartilhar uma mesma conexo entre divesos componentes ADO. Isto pode reduzir o consumo de recursos, e permite a execuo de transaes em muitos datasets (spanning). Como outros componentes de conexo, TADOConnection prov suporte para: Controle de conexes; Controle de login de usurios; Manipulao de transaes; Trabalho com datasets associados; Envio de comando ao servidor; Obteno de metadata.
Adicionalmente a estes recursos comuns a componentes de conexo, TADOConnection prov seu prprio suporte para: Grande quantidade de opes que voc pode usar para ajustar o desempenho da conexo; Capacidade de listar objetos de comandos que usam a conexo; Eventos adicionais durante tarefas comuns.
Para compartilhar uma conexo entre muitos datasets, associe-os a um mesmo TADOConnection atravs das suas propriedades Connection. Contudo, antes de voc poder usar a conexo, necessrio identificar os parmetros da conexo da ser feita. Tipicamente, voc fornece estes dados atravs da propriedade ConnectionString. Esta propriedade uma string delimitada por ponto-e-vrgula (;) que lista um ou mais parmetros de conexo. Os parmetros indicam a fonte de dados a ser usada e muitos outros detalhes que podem diferenciar conforme o driver OLEDB utilizado. Uma valor tpico para esta propriedade : Provider=LCPI.IBProvider.1;Persist Security Info=False;DataSource=c:\databases\ADOTeste\Projects.gdb A maneira mais simples de configurar TADOConnection acessando o editor disponvel para a propriedade ConnectionString. Voc pode ver na imagaem abaixo um imagem deste editor
151
Figura O editor de propriedades de ConnectionString, que faz uma conexo com uma fontes de dados ADO.
Este editor permite o acesso janela de configurao de uma conexo com uma fonte ADO. Todo o trabalho de configurao de sua conexo feito a. Veja abaixo uma viso desta janela, com driver OLEDB SIBProvider, para acesso a Interbase, selecionado.
Figura Janela padro do Windows para edio de fontes de dados ADO. A imagem s mostra a pgina Provedor.
TADOConnection x Connection string Cada dataset ou TADOCOmmand em um aplicativo pode ser conectado diretamente a uma fonte de dados. Contudo, quando numerosos datasets ou comandos so uisados, sempre mais fcil trabalhar usando um componente TADOCOnnection para estabelecer a conexo e compartilh-la entre todos datasets e comandos. O usode TADOCOnnection para estabelecer uma conexo oferece mais controle sobre a conexo do que conectar cada dataset individualmente.
152
Logins e timeout Voc pode controlar o tempo vlido para estabelecer uma conexo com um objeto TADOCOnnection. A propriedade CommandTimeOut de TADOCOnnection estabelece o tempo mximo necessrio para conectar a uma fonte de dados. Se a conexo no for completada at o limite mximo determinado por CommandTimeOut, a conexo ser considerada falha e cancelada. Configure ConnectionTimeOut com o nmero de segundos aps o qual a conexo ser cancelada se no puder estabelecer uma conexo com uma fonte de dados. Veja o fragmento de cdigo abaixo que ilustra o uso de ConnectionTimeOut:
with ADOCOnnection1 do begin ConnectionTimeOut := 10;//10 segundos Open; end;
Ao tentar conectar um TADOConnection a uma fonte de dados, o evento de segurana OnLogin disparado. Uma manifestao deste evento o aparecimento de uma caixa de dilogo para o usurio inserir seu nome e senha. Se voc desejar, possvel suprimir esta caixa de dilogo e o nome do usurio e senha ser fornecido programaticamente. Para suprimir a caixa de dilogo padro, primeiro configure a propriedade LoginPrompt para False. Ento, fornea programaticamente as informaes de acesso atravs da propriedade ConnectionString. Veja o fragmento de cdigo abaixo:
with ADOCOnnection1 do begin LoginPrompt := False; ConnectionSTring := Provider=IBProvider;Remote Server=PDC;User Name=Joo;Password=Cooperi; Connected := True; end;
Outra opo fornecer as informaes de login atravs de parmetros do mtodo Open. Veja:
with ADOCOnnection1 do begin LoginPrompt := False; ConnectionSTring := Provider=IBProvider;Remote Server=PDC Open(Joo,Cooperi); end;
Se voc decide exibir a caixa de dilogo de login de usurio, mas o nome ou senha fornecidos estiverem incorretos, uma exceo do tipo EoleException disparada.
Transaes em ADO
153
O componente TADOConnection inclui mtodos e eventos para trabalhar-se com transaes. Estas capacidades de trabalho com transaes so compartilhadas por todos datasets baseados em ADO ou comandos que usam a mesma conexo com uma fonte de dados.
Usando mtodos de transaes Use os mtodos BeginTrans, CommitTrans e RollbackTrans para realizar processamento de transaes. BeginTrans inicia uma transao na fonte de dados associada com o componente TADOCOnnection; CommitTrans confirma uma transao atualmente ativa, salvando as mudanas no banco de dados e finalizando a transao. RollbackTrans cancela a transao atualmente ativa, abndonando todas as mudanas feitas durante a transao e finalizando-a;
Quando voc precisar determinar se uma transao est em andamento, utilize a propriedade InTransaction, que retornar True se ainda estiver em andamento e False no caso contrrio. Uma transao iniciada por um componente TADOConnection compartilhada por todos datasets e comandos vinculados a ele.
Usando eventos de transao O componente TADOConnection tambm oferece eventos para a manipulao de transaes. Estes eventos indicam quando uma transao iniciada, confirmada ou cancelada. OnBeginTransComplete disparado quando uma transao for iniciada com sucesso. OnCommitTransComplete disparado aps uma transao ser confirmada com sucesso. OnRollbackTransComplete disparado aps uma transao ser cancela com sucesso.
Trabalhando com comandos

O conjunto de componentes ADO providos pelo Delphi permite a uma aplicao executar comandos. No ambiente ADO, comandos so representaes textuais de uma ao de requisio a um provedor especfico. Tipicamente, os comandos so rotinas SQL de Data Definition Language (DDL) ou Data Manipulation Language (DML). A linguagem usada nos comandos particular a cada um dos provedores, mas, em geral, so usualmente compatveis com o padro SQL-92. Os comandos podem ser executados a partir de mais de um componente Delphi. Cada componente de comandos executa-os de forma ligeiramente diferente. Qual componente voc deve usar para um comando particular determinado pelo tipo de comando e pelo fato de retornar ou no um resultset. No geral, para comandos que no retornam um resultset, use o componente TADOCommand (apesar de TADOQuery tambm poder executar estes comandos). Para comandos que retornam um resultset, voc pode usar um TADODataset ou um componente TADOQuery.
154
Especificando o comando O componente TADOCommand prov a abilidade de executar muitos comandos, mas sempre um de cada vez. Foi desenhado primariamente para executar comandos que no retornam resultset de uma forma rpida e direta. Voc informa o comando a ser executado atravs da propriedade CommandText, mas um comando pode ser tambm especificado atravs da propriedade CommandType. Em tempo de projeto, digite uma instruo SQL vlida na propriedade CommanText de um TADOCommand atravs do Object Inspector. Em tempo de execuo, atribua uma string a esta propriedades. Se desejar, defina explicitamente o tipo de comando a ser executado atravs da propriedade CommandType. Entre as constantes disponveis para esta propriedade temos: CmdText: usada para indicar que o comando uma instruo SQL; CmdTable: usada para especificar o nome de uma tabela; CmdStoredProc: usada para especificar um procedimento armazenado.
Em tempo de projeto, especifique um valor adequdo para a propriedade CommandType. Durante a execuo do programa, atribua um valor tanto para a propriedade CommandType, como tambm para CommandText. Veja um exemplo no fragmento de cdigo que segue: with ADOCommand1 do begin CommandText := AddEmployee; CommandType := cmdStoredProc; end;
Usando o mtodo Execute Quando voc usar um componente TADOCommand, antes de um comando poder ser executado, ele precisa estar conectado a uma fonte de dados. Uma vez que j o esteja, basta chamar o mtodo Execute para executar o comando. Para comandos que no requerem parmetros ou opes de execuo, chame a verso simples de Execute, que no possui quaisquer parmetros. Veja um exemplo abaixo: with ADOCommand1 do begin CommandText := UpdateInventory; CommandType := cmdStoredProc; Execute; end;
Cancelando comandos Aps um comando houver sido executado (atravs do mtodo Execute), possvel cancelar a sua execuo chamando-se o mtodo Cancel. Por exemplo, veja o fragmento abaixo: procedure TForm1.ExecuteButton.Click(Sender: Tobject); begin ADOCommand1.Execute; end; procedure TForm1.CancelButton.Click(Sender: Tobject);
155
begin ADOCommand1.Cancel; end;
O mtodo Cancel somente tem efeito se houver um comando pendente e o comando for executado de forma assncrona, isto , se a opo eoAsynchExecute estiver no parmetro do mtodo Execute. Um comando est pendente quando, aps a chamada do mtodo Execute, ele ainda no foi completado ou encerrado por um TimeOut.
Retornando dados com comandos A execuo de um comando que retorna dados feita da mesma forma que a execuo de comandos que no retornam, exceto que um componente ADO Dataset pr-existente deve representar o resultset. O mtodo Execute do comando retorna um objeto ADO Recordset. Atribua este valor de retorno propriedade RecordSet de um dataset ADO, tal como um TADODataset. No exemplo abaixo, o ADO Recordset produzido pela chamada do modo Execute de um componente TADOCommand atribudo propriedade RecordSet de um componente TADODataset:
with ADOCommand1 do begin CommandText := select company, state from customer where state = :state; CommandType := cmdText; Parameters.ParamByName(state).Value := HI; ADODataset1.RecordSet := Execute; end;
To logo esta atribuio feita, o dataset ativado automaticamente e os dados esto disponveis.
ADO.NET
Recentemente, a Microsoft tem lanado uma grande campanha de marketing para divulgao da sua nova tecnologia e arquitetura para desenvolvimento de aplicaes WEB, que foi denominada .NET. Esta nova tecnologia baseada basicamente na construo de WebServices e acesso a bancos de dados de forma desconectada. ADO.NET o framework no qual toda tecnologia .NET de acesso a dados (no apenas bancos de dados) est baseada, em estreita ligao com o uso de XML como repositrio de dados. Com efeito, todos os dados que um servio .NET implementa so expostos via XML (tanto dados de bancos de dados como atributos de campos, propriedades definidas pelo usurio etc). Embora o estudo de tecnologias WEB seja assunto de captulos posteriores, este tpico ir introduzir rapidamente alguns conceitos fundamentais sobre a tecnologia ADO.NET. Um estudo muito mais detalhando sobre servios WEB (WebServices) e ADO.NET ser desenvolvido nos captulos destinados s tecnologias WEB disponibilizadas pelo Delphi.
156
A arquitetura ADO.NET ADO.NET prov acesso consistente a muitas fontes de dados expostas via OLEDB e XML. As aplicaes que compartilham muitos dados podem usar ADO.NET para conectar a estas fontes de dados e retornar, manipular e atualizar dados atravs de provedores de dados .NET para conexo com bancos de dados. O framework de ADO.NET executa estas atividades atravs de objetos COM existentes em bibliotecas como XML.dll e Data.dll que so primariamente desenhados para acessar dados em aplicativos multi-camadas, como em um WEBService. Embora, ADO.NET seja capaz de trabalhar normalmente com acessos locais a dados, sua inteno primordial estabelecer uma camada intermediria entre um cliente (front-end) e uma fonte de dados, configurando assim uma arquitetura de acesso em vrias camadas lgicas inter-relacionadas. O mecanismo pelo qual ADO.NET transfere os dados recuperados de uma fonte de dados a um cliente, independentemente da sua origem ou natureza, o XML. A figura abaixo ilustra como ADO.NET trabalha com uma fonte de dados e com clientes de diversos tipos, como um aplicativo Windows comum ou um aplicativo WEB e um ambiente multi-camadas.
Figura A arquitetura ADO.NET em um esquema multi-camadas tpico. Na camada de apresentao , vemos aplicativos clientes de diversos tipos acessando dados de uma camada intermediria atravs de XML. Na camada intermdiria, vemos objetos ADO.NET que so responsveis pelo acesso camada de dados.
Datasets ADO.NET O objeto Dataset (no confundir com TDataset do Delphi) um elemento central no suporte a cenrios disconectados e distribudos caractersticos de ADO.NET. Dataset uma representao de dados residentes em memria que prov um modelo relacional consistente de programao de acesso a fontes de dados. Pode ser usado com fontes de dados mltiplas e diferentes, usadas com dados XML ou usado para manipular dados locais de uma aplicao. O objeto Dataset representa um completo conjunto de dados que incluem constries, tabelas relacaionadas e relacionamento entre tabelas.
157
Provedores de dados .NET Um provedor .NET usado para conexo com um banco de dados, e pode executar comandos e retornar dados em um resultset. Este resultset tanto pode ser processado diretamente como tambm pode ser atribudo a um dataset ADO.NET, para que seja exibido ao usurio de uma maneira adequada. Os provedores de dados .NET so desenhados para ser leves, criando um layer mnimo entre a fonte dos dados e seu aplicativo, aumentando performance sem sacrificar qualquer funcionalidade. O framework .NET inclui um provedor de dados para MSSQL server 7.0 ou superior e um provedor OLEDB .NET. Outros provedores esto sendo adicionados constantemente para oferecer suporte a outras tecnologias de acesso. Voc pode observar que ADO.NET no oferece nenhum mistrio para um programador Delphi que conhea ADOExpress e, principalmente, que esteja acostumado com o desenvolvimento de aplicativos multi-camadas. Na verdade, quando a tecnologia .NET dispontou, os programadores Delphi j desenvolviam aplicativos multi-camadas com marshaling de dados via MIDAS e, conseqentemente, XML. Caracteristicamente, a Microsoft formou acordo de parceria com a Borland para o desenvolvimento de todo o escopo do que hoje chamamos .NET e WebService. Em captulos posteriores, estudaremos em profundidade estas tecnologias.
158
CAPTULO 14 - APLICAES INTERBASE EXPRESS

A Interbase Express (IBX) um conjunto de componentes de acesso a dados que prov um mecanismo que pode acessar, administrar, monitorar e rodar servios no Interbase. A maior vantagem oferecida pelos componentes IBX que eles podem acessar um servidor Interbase diretamente, sem a necessidade de um middle ware como o BDE. Este acesso direto se faz atravs de chamadas API do Interbase, que so encapsuladas em objetos do Delphi para fcil manipulao. Isto certamente aumenta o desempenho de um aplicativo, pois assim possvel livrar-se dos complicados mecanismos usados pelo BDE que geram um considervel overhead no acesso aos dados. A IBX capaz de acessar bancos Interbase ou Firebird, e est disponvel para as plataformas Linux e Windows. Atravs deste conjunto de componentes, voc pode desenvolver aplicativos, servidores WEB etc que permitem-lhe um controle direto e rpido de todas as funes e servios disponibilizados por um servidor Interbase. Este captulo oferece uma viso geral do desenvolvimento de aplicativos usando a Interbase Express, mas parte do pressuposto de um conhecimento mnimo do Interbase e Sistemas Gerenciadores de Bancos de Dados Relacionais (SGBDR). Certamente, voc no precisa conhecer bastante o Interbase para conseguir compreender como o Delphi oferece suporte a este servidor SQL remoto atravs da IBX.
159
A arquitetura Interbase Express

A arquitetura dos componentes da biblioteca Interbase Express tem como forte caracterstica a capacidade de acessar diretamente bancos de dados Interbase 6.0 ou Firebird 1.0 ou superiores. O fato de acessarem estes servidores SQL diretamente, significa que os componentes Interbase Express no necessitamde nenhum tipo de software para conseguir conversar com os servidores, mas sim estabelecem este contato atravs dechamadas API do Interbase/Firebird. Como conseqncia deste acesso direto, a Interbase Express oferece o modelo de acesso mais rpido e poderoso a estes servidores. Alm disto, voc pode desenvolver aplicaes IBX que acessam diversas funcionalidades relacionadas estatstica de acesso, manuteno de servidores, servios de backup etc. Estas funcionalidades so providas da mesma forma, isto , atravs de acessos API dos servidores. Neste tpico, voc conhecer os componentes disponibilizados pela Interbase Express, bem como como us-los para obter um rpido acesso a bancos de dados Interbase/Firebird.
Figura A arquitetura de datasets para acesso a banco de dados via Interbase Express.
Conhecendo a IBX A Interbase Express (IBX) um conjunto muito completo e flexvel de componentes para acesso direto a bancos de dados Interbase. Voc no encontrar apenas componentes de conexo e datasets diversos dentro deste pacote, pois grande parte dos recursos de administrao de um servidor Interbase/Firebird, monitoramento, controle de usurios, estatsticas de dados etc so encapsulados em diversos componentes IBX. Sob o ponto de vista de suas funcionalidades, existem dois tipos bsicos de componentes IBX: Componentes relacionadaos a acesso e manipulao dos dados de um banco; Componenes relacionados administrao de um banco e de um servidor Interbase/Firebird.
Certamente, voc usar muito os componentes do primeiro tipo (englobam datasets, comandos e componentes de conexo e controle de transaes), mas muitas outras funcionalidades podem ser obtidas de maneira muito simples atravs de componentes de manipulao de servidores e bancos de dados. Este suporte completo s funcionalidades de um servidor SQL remoto possvel devido ao fato de o Interbase/Firebird possuirem uma arquitetura de software muito aberta, o que quer dizer, entre outras coisas, que expem todas as suas funcionalidades atravs de uma API de acesso bastante desenvolvida. A tabela abaixo oferece uma descrio simples dos componentes encontrados na Interbase Express em sua verso 4.4.
160
Componente TIBDataBase TIBTransaction TIBQuery TIBStoredProc TIBUpdateSQL TIBDataSet TIBSQL TIBDataBaseInfo TIBSQLMonitor TIBEvents TIBExtract TIBConfigService TIBBackupService TIBRestoreService TIBValidationService TIBStaticalService TIBLogService TIBSecurityService TIBLicensingService TIBServerProperties TIBInstall TIBUninstall
Descrio Realiza a conexo entre a sua aplicao e o banco de dados InterBase. o responsvel pelo controle de transaes da sua aplicao. Voc pode controlar transaes concorrentes, ou em threads independentes. Usado para fazer uma consulta SQL em a seu banco de dados InterBase. Este componente aceita quase todas as instrues DDL, DML e DQL. Para utiliz-lo em modo live resultset, necessrio o uso do TIBUpdateSQL. Executa um procedimento armazenado no servidor InterBase. Permite definir instrues DML para cada mtodo Insert, Edit e Delete. TIBUpdateSQL associado a um TIBQuery representa toda a funcionalidade SQL de manipulao de Dados e live resultset. Engloba toda a funcionalidade de TIBQuery+TIBUpdateSQL, e ainda mais rpido. Seu uso recomendado pelos criadores dos componentes Interbase Express. Executa instrues ou comandos SQL. Recomendvel para o uso de instrues DML ou DDL. Retorna vrias informaes do seu banco de dados. Cria um LOG para acompanhamento de todas as instrues enviadas para o servidor.Trabalha em conjunto com a propriedade TraceFlags de TIBDataBase. Captura eventos de um banco de dados InterBase. O Interbase capaz de emitir eventos que podem ser capturados por aplicaes. Extrai informaes de metadados das tabelas de sistemas, de usurio e todos outros objetos existentes em um banco InterBase. Envia e muda os parmetros de um banco InterBase; entre eles, o Intervalo de Sweap, Page Controls e outros. Realiza uma operao de backup em um banco de dados. Restaura um backup feito anterirormente. Valida a sua base de dados, como as transaes em Limbo, as transaes Default e outras validaes. Mostra as estatsticas de um banco de dados; entre elas : Log, Header Pages, ndices e outras. Cria seu prprio LOG de um banco de dados InterBase. Gerencia o acesso a usurios ao seu banco Interbase, assim como a manuteno dos dados dos mesmos. Oferece recurso para a manuteno nos certificados de acesso do InterBase. Retorna informaes de configurao do servidor InterBase. Oferece um mecanismo para instalar o InterBase, configurar os diretrios de instalao e os componente que sero instalados. Oferece um mecanismo para desinstalar os componentes usados na instalao do InterBase.
Herana baseada em TDataset A arquitetura IBX baseada na herana bsica de TDataset. Isto significa que todos os mtodos, eventos e propriedades com os quais voc est acostumado a lidar como desenvolvedor de aplicativos de banco de dadados estaro disponveis tambm nos datasets IBX. Como voc pode observar analisando a hierarquia de objetos IBX, os datasets herdam de uma classe genrica TIBCustomDataset. A partir dela, so criados datasets correspondentes a tabelas, consultas, procedimentos armazenados e outros. Voc no deve usar uma instncia de TIBCustomDataset, mas sim de um dos seus descendentes. Observe tambm que o uso de componentes baseados em tabelas (como o caso de TIBTable) deve ser feito com muito critrio em bancos de dados SQL como o Interbase ou o Firebird. Sempre escolha um componente capaz de trabalhar com consultas SQL. O componente TIBSQL capaz de executar comando em uma banco de dados com muita rapidez e eficincia. Voc pode observar que ele no herda de TDataset, o que significa que no possui os recursos implementados por esta classe que se referem exibio e navegao de dados. TIBSQL destinado a executar comandos DDL ou DML, mas no comandos DQL. Isto significa que TIBSQL incapaz de obter um resultset de dados. As vantagens do uso de TIBSQL so evidentes quando pensamos que possvel executar comandos da maneira mais rpida possvel no Interbase, com um mnimo de alocao de recursos. TIBDataset um componente diferente, pois dispoem em s mesmo todos mecanismos para recuperao e edio dos dados. Use-o para executar comandos SQL do Interbase/Firebird. Cada componente TIBDataset possui propriedades separadas para lidar com dados recuperados (tipicamente atravs de um comando SELECT), para executar alteraes nos registros, para inserir novos registros, 161
para eliminar registros e para atualizar o resultset (refresh). TIBDataset criar um buffer local do resultset, tornando-o completamente rolvel.
Datasets unidirecionais Uma vez que os datasets IBX acessam um servidor SQL remoto, voc deve considerar com cuidado o consumo de recursos e o trfego na rede demandado por suas aplicaes. Por padro, o resultset criado a partir de uma consulta a um banco de dados SQL unidirecional e no aceita edio. Isto significa que voc no poder rolar os dados recuperados para trs, mas somente para o prximo registro; tambm no poder alterar qualquer dado recuperado. Os servidores SQL usam esta estratgia como um mecanismo para enconomizar recursos e minimizar o trfego em uma rede corporativa. Contudo, a IBX permite usar datasets bidirecionais e atualizveis (live result set), tal como voc pode observar em bancos de dados locais. Mas lembre-se sempre de usar estes recursos com ateno para que seu aplicativo no atole a rede com constantes fetch de dados desnecessrios. A tcnica mais limpa consiste em usar datasets capazes de buferizar seus dados no cliente (como TIBDataset e muitos client datasets). Alm disto, procure sempre retornar o menor resultset possvel e mantenha suas transaes curtas e rpidas.
Extensibilidade da arquitetura IBX Uma das caractersticas marcantes da arquitetura IBX sua forte extensibilidade. Com isto se quer dizer que voc pode facilmente criar novos componentes ou alterar algum existente para atender as suas necessidades. Um fator que contribui muito para esta caracterstica a prpria arquitetura da API do Interbase/Firebird. Muitos objetos IBX encapsulam as funcionalidades expostas atravs desta API, e voc pode criar livremente novos componentes e classes que acesses esta API e os objetos de um banco de dados Interbase. Para ilustrar esta caractersticas vamos criar um novo componente Delphi que ser adicionado Interbase Express. Este componente possuir a funcionalidade bsica de trabalhar com Generators, que so objetos existentes nos bancos de dados Interbase. Um Generator um objeto simples, e tem a funo bsica de armazenar um valor inteiro que pode ser lido ou alterado. Como os generators so objetos globais de um banco de dados, eles podem ser acessados em qualquer rotina que voc possa escrever no seu banco (como Triggers ou Stored Procedures). Um uso tpico de generators para que se possa dar suporte a campos auto-incrementados em uma tabela, ou simplesmente como variveis globais de um banco de dados. Nota: Embora a criao de componentes no Delphi esteja fora do escopo deste captulo, introduziremos apenas os principais pontos que ilustram a extensibilidade da arquitetura da IBX e da prpria API do Interbase/Firebird. O componente ser chamado TIBGenerator e derivar diretamente de TComponent. Ele ter as seguintes funes bsicas: Ler um valor de um determinado generator; Alterar um valor em um determinado generator; Criar novos generators; Deletar um determinado generator; Listar os generators existentes em um banco de dado. 162
TIBGenerator ter 2 propriedades importantes que temos de destacar. DatabaseName. uma referncia a um objeto TIBDatabase; GeneratorName. o nome de um generator; Transaction. uma referncia a um objeto TIBTransaction que ser usado nos mtodos de TIBGenerator.
As outras propriedades de TIBGenerator sero ignoradas por enquanto. Como no Interbase todas as referncias aos objetos de dados internos de um banco so armazenadas em tabelas especiais, denominadas Tabelas de sistema, TIBGenerator usar sempre um componente TIBSQL interno para executar todas estas atividades descritas acima. Ou seja, ele far todas as atividades acima usando rotinas DDL executadas por um objeto de comando da IBX, que o TIBSQL. Para ler um valor de um determinado generator, ns precisamos construir no Delphi um mtodo de TIBGenerator que ser chamado GetGeneratorValue. Este mtodo uma funo que retorna um inteiro (o valor do generator de nome igual ao da propriedade GeneratorName). Para ser sucinto, o mtodo conecta-se ao TIBDatabase assinalado e inicia uma transao com o objeto assinalado propriedade Transaction. O centro o camando SQL GEN_ID que uma funo interna de todo banco Interbase que altera/retorna o valor do generator. Veja o cdigo abaixo:
function TIBGenerator.GetGeneratorValue: integer; var WasIntransAction: Boolean; IBSQL: TIBSQL; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try if not WasIntransAction then TransAction.StartTransaction; IBSQL := TIBSQL.Create(Self); try IBSQL.Database := FDatabase; IBSQL.Transaction := FTransAction; IBSQL.SQL.Text := Format('SELECT GEN_ID(%s, 0) FROM RDB$DATABASE', [GeneratorName]); IBSQL.ExecQuery; FValue := IBSQL.Fields[0].AsInteger; finally IBSQL.Free; end; result := FValue; finally if not WasIntransAction then TransAction.Commit; end; except FValue := -1; result := FValue; end; end;
163
O mtodo DropGenerator deleta o generator GeneratorName do banco de dados atravs de um comando DDL do tipo DROP. Veja o mtodo abaixo:
procedure TIBGenerator.DropGenerator; var WasIntransAction: Boolean; IBSQL: TIBSQL; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try if not WasIntransAction then TransAction.StartTransaction; IBSQL := TIBSQL.Create(Self); try IBSQL.Database := FDatabase; IBSQL.Transaction := FTransAction; IBSQL.SQL.Text := Format('DELETE FROM RDB$GENERATOR WHERE RDB$GENERATOR_NAME = %s' , [FGeneratorName]); IBSQL.ExecQuery; finally IBSQL.Free; end; finally if not WasIntransAction then TransAction.Commit; end; except SHowMessage(format('Write value operation to generator %s is failed!', [GeneratorName])); end;
O mtodo AlterGenerator altera o nome de um generator e assinala um valor para ele:
procedure TIBGenerator.AlterGenerator(NewName: string; Value: integer); var WasIntransAction: Boolean; IBSQL: TIBSQL; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try if not WasIntransAction then TransAction.StartTransaction; IBSQL := TIBSQL.Create(Self); try IBSQL.Database := FDatabase; IBSQL.Transaction := FTransAction; IBSQL.SQL.Add(Format('DELETE FROM RDB$GENERATOR WHERE RDB$GENERATOR_NAME = %s' , [FGeneratorName]) + ';'); IBSQL.SQL.Add(Format('CREATE GENERATOR %s', [NewName]) + ';'); IBSQL.SQL.Add(Format('SET GENERATOR %s TO %d', [NewName,Value])+ ';'); IBSQL.ExecQuery; finally 164
IBSQL.Free; end; finally if not WasIntransAction then TransAction.Commit; end; except SHowMessage(format('Update operation to generator %s is failed!', [GeneratorName])); end; end; O mtodo AlterGeneratorValaue altera o valor do generator GeneratorName:
procedure TIBGenerator.AlterGenereatorValue(Value: integer); var WasIntransAction: Boolean; IBSQL: TIBSQL; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try if not WasIntransAction then TransAction.StartTransaction; IBSQL := TIBSQL.Create(Self); try IBSQL.Database := FDatabase; IBSQL.Transaction := FTransAction; IBSQL.SQL.Text := Format('SET GENERATOR %s TO %d', [FGeneratorName, Value]); IBSQL.ExecQuery; finally IBSQL.Free; end; finally if not WasIntransAction then TransAction.Commit; end; except SHowMessage(format('Write value operation to generator %s is failed!', [GeneratorName])); end; end;
O mtodo ListGenerator insere o nome de todos os generators existentes em um banco em uma TStrings passada como parmetro do mtodo:
procedure TIBGenerator.ListGenerators(GenList: TStrings); var WasIntransAction: Boolean; IBQuery: TIBQuery; IDSystem: integer; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try 165
if not WasIntransAction then TransAction.StartTransaction; IBQuery := TIBQuery.Create(Self); try IBQuery.Database := FDatabase; IBQuery.UniDirectional := True; IBQuery.Transaction := FTransAction; if FSystemGenerators = True then IDSystem := 1 else IDSystem := 0; IBQuery.SQL.Add(Format(LstGenerators, [idsystem])); IBQuery.Open; while not IBQuery.Eof do begin GenList.Add(IBQuery.Fields.Fields[0].AsString); IBQuery.Next; end; finally IBQuery.Close; IBQuery.Free; end; finally if not WasIntransAction then TransAction.Commit; end; except SHowMessage('List operation to generators is failed!'); end; end;
Finalmente, o mtodo CreateGenerator cria um novo generator com o nome contido na propriedade GeneratorName no banco de dados:
procedure TIBGenerator.CreateGenerator; var WasIntransAction: Boolean; IBSQL: TIBSQL; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try if not WasIntransAction then TransAction.StartTransaction; IBSQL := TIBSQL.Create(Self); try IBSQL.Database := FDatabase; IBSQL.Transaction := FTransAction; IBSQL.SQL.Text := Format('CREATE GENERATOR %s', [FGeneratorName]); IBSQL.ExecQuery; finally IBSQL.Free; end; 166
finally if not WasIntransAction then TransAction.Commit; end; except SHowMessage(format('Write value operation to generator %s is failed!', [GeneratorName])); end; end;
O importante a observar em todos estes mtodos o fato de usarmos objetos IBX para realizar todas estas tarefas atravs de comando DDL disponveis na SQL do Interbase/Firebird. Voc poderia encapsular qualquer objeto de um banco de dados Interbase (tal como Exceptions ou Triggers) em um objeto Delphi, e trabalhar de forma idntica com eles. Segue-se abaixo o cdigo-fonte completo da unidade que define TIBGenerator:
unit IBGenerator; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, IBSQL, IBDatabase, IBCustomDataSet, IBQuery, SQLStrings; type TIBGenerator = class(TComponent) private FGeneratorName: string; FSystemGenerators: Boolean; FValue: Integer; FDatabase: TIBDatabase; FTransAction: TIBTransAction; FAutoCommit: boolean; procedure procedure function procedure procedure protected SetDatabase(const Value: TIBDatabase); SetTransAction(const Value: TIBTransAction); GetValue: Integer; SetGeneratorName(const Value: string); SetAutoCommit(Value: boolean);
{} public constructor Create(AOwner: TComponent); override; destructor Destroy; override; function Increment(const Step: Integer = 1): Integer; function GetGeneratorValue: integer; procedure DROPGenerator; procedure AlterGenerator(NewName: string; Value: integer); procedure AlterGenereatorValue(Value: integer); procedure CreateGenerator; procedure ListGenerators(GenList: TStrings); property Value: Integer read GetValue; published property AutoCommit: boolean read FAutoCommit write SetAutoCommit; property Database: TIBDatabase read FDatabase write SetDatabase; property GeneratorName: string read FGeneratorName write SetGeneratorName; 167
property Transaction: TIBTransAction read FTransAction write SetTransAction; property SystemGenerators: Boolean read FSystemGenerators write FSystemGenerators; end; procedure Register; implementation { TIBGenerator } procedure Register; begin RegisterComponents('Interbase', [TIBGenerator]); end; constructor TIBGenerator.Create(AOwner: TComponent); begin inherited Create(AOwner); end; destructor TIBGenerator.Destroy; begin inherited Destroy; end; procedure TIBGenerator.SetDatabase(const Value: TIBDatabase); begin if Value <> FDatabase then begin FDatabase := Value; if not Assigned(FTransAction) then FTransAction := FDatabase.DefaultTransaction; end; end; procedure TIBGenerator.SetTransAction(const Value: TIBTransAction); begin if Value <> FTransaction then FTransaction := Value; end; function TIBGenerator.GetValue: Integer; begin result := Increment(0); end; procedure TIBGenerator.SetGeneratorName(const Value: string); begin if not AnsiSameText(FGeneratorName, Value) then FGeneratorName := Value; end; function TIBGenerator.Increment(const Step: Integer): Integer; var WasIntransAction: Boolean; IBSQL: TIBSQL; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; 168
try if not WasIntransAction then TransAction.StartTransaction; IBSQL := TIBSQL.Create(Self); try IBSQL.Database := FDatabase; IBSQL.Transaction := FTransAction; IBSQL.SQL.Text := Format('SELECT GEN_ID(%s, %d) FROM RDB$DATABASE', [GeneratorName, Step]); IBSQL.ExecQuery; FValue := IBSQL.Fields[0].AsInteger; finally IBSQL.Free; end; result := FValue; finally if not WasIntransAction then TransAction.Commit; end; except FValue := -1; result := FValue; end; end; function TIBGenerator.GetGeneratorValue: integer; var WasIntransAction: Boolean; IBSQL: TIBSQL; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try if not WasIntransAction then TransAction.StartTransaction; IBSQL := TIBSQL.Create(Self); try IBSQL.Database := FDatabase; IBSQL.Transaction := FTransAction; IBSQL.SQL.Text := Format('SELECT GEN_ID(%s, 0) FROM RDB$DATABASE', [GeneratorName]); IBSQL.ExecQuery; FValue := IBSQL.Fields[0].AsInteger; finally IBSQL.Free; end; result := FValue; finally if not WasIntransAction then TransAction.Commit; end; except FValue := -1; result := FValue; end; end; procedure TIBGenerator.DropGenerator; var WasIntransAction: Boolean; 169
IBSQL: TIBSQL; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try if not WasIntransAction then TransAction.StartTransaction; IBSQL := TIBSQL.Create(Self); try IBSQL.Database := FDatabase; IBSQL.Transaction := FTransAction; IBSQL.SQL.Text := Format('DELETE FROM RDB$GENERATOR WHERE RDB$GENERATOR_NAME = %s' , [FGeneratorName]); IBSQL.ExecQuery; finally IBSQL.Free; end; finally if not WasIntransAction then TransAction.Commit; end; except SHowMessage(format('Write value operation to generator %s is failed!', [GeneratorName])); end; end; procedure TIBGenerator.AlterGenerator(NewName: string; Value: integer); var WasIntransAction: Boolean; IBSQL: TIBSQL; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try if not WasIntransAction then TransAction.StartTransaction; IBSQL := TIBSQL.Create(Self); try IBSQL.Database := FDatabase; IBSQL.Transaction := FTransAction; IBSQL.SQL.Add(Format('DELETE FROM RDB$GENERATOR WHERE RDB$GENERATOR_NAME = %s' , [FGeneratorName]) + ';'); IBSQL.SQL.Add(Format('CREATE GENERATOR %s', [NewName]) + ';'); IBSQL.SQL.Add(Format('SET GENERATOR %s TO %d', [NewName,Value])+ ';'); IBSQL.ExecQuery; finally IBSQL.Free; end; finally if not WasIntransAction then TransAction.Commit; end; except SHowMessage(format('Update operation to generator %s is failed!', [GeneratorName]));
170
end; end; procedure TIBGenerator.AlterGenereatorValue(Value: integer); var WasIntransAction: Boolean; IBSQL: TIBSQL; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try if not WasIntransAction then TransAction.StartTransaction; IBSQL := TIBSQL.Create(Self); try IBSQL.Database := FDatabase; IBSQL.Transaction := FTransAction; IBSQL.SQL.Text := Format('SET GENERATOR %s TO %d', [FGeneratorName, Value]); IBSQL.ExecQuery; finally IBSQL.Free; end; finally if not WasIntransAction then TransAction.Commit; end; except SHowMessage(format('Write value operation to generator %s is failed!', [GeneratorName])); end; end; procedure TIBGenerator.CreateGenerator; var WasIntransAction: Boolean; IBSQL: TIBSQL; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try if not WasIntransAction then TransAction.StartTransaction; IBSQL := TIBSQL.Create(Self); try IBSQL.Database := FDatabase; IBSQL.Transaction := FTransAction; IBSQL.SQL.Text := Format('CREATE GENERATOR %s', [FGeneratorName]); IBSQL.ExecQuery; finally IBSQL.Free; end; finally if not WasIntransAction then TransAction.Commit; end; except
171
SHowMessage(format('Write value operation to generator %s is failed!', [GeneratorName])); end; end; procedure TIBGenerator.SetAutoCommit(Value: boolean); begin if FAutoCommit <> Value then FAutoCommit := Value; end; procedure TIBGenerator.ListGenerators(GenList: TStrings); var WasIntransAction: Boolean; IBQuery: TIBQuery; IDSystem: integer; begin try Database.Connected := true; WasInTransAction := TransAction.InTransAction; try if not WasIntransAction then TransAction.StartTransaction; IBQuery := TIBQuery.Create(Self); try IBQuery.Database := FDatabase; IBQuery.UniDirectional := True; IBQuery.Transaction := FTransAction; if FSystemGenerators = True then IDSystem := 1 else IDSystem := 0; IBQuery.SQL.Add(Format(LstGenerators, [idsystem])); IBQuery.Open; while not IBQuery.Eof do begin GenList.Add(IBQuery.Fields.Fields[0].AsString); IBQuery.Next; end; finally IBQuery.Close; IBQuery.Free; end; finally if not WasIntransAction then TransAction.Commit; end; except SHowMessage('List operation to generators is failed!'); end; end; end.
172
Compatibilidade inter-plataformas
Ao contrrio de mecanismos de acesso como o BDE e ADO, a Interbase Express est disponvel para o desenvolvimento de aplicativos para as plataformas Windows e Linux. Esta caracterstica notvel permite ao desenvolvedor compartilhar o mesmo cdigo para gerar verses Linux ou Windows de seus aplicativos. claro que todos os componentes Delphi que voc adicionar IBX (como o TIBGenerator) estaro tambm disponveis para o desenvolvimento Linux e vice-versa (desde, claro, que no usem recursos especficos de uma plataforma). Se voc deseja escrever aplicativos inter-plataformas que acessem bancos de dados Interbase ou Firebird, a IBX com certeza uma excelente escolha.
173
Conectando com bancos de dados Interbase/Firebird

A IBX oferece um suporte muito completo de controle de conexes com bancos de dados Interbase. Este suporte baseado no componente TIBDataset, que possui muitas propriedades, eventos e mtodos relacionados aos mecanismos de conexo de um aplicativo com um servidor Interbase, tais como validao de usurios, character set, idleTimer etc. A maneira mais fcil de configurar um componente TIBDatabase atravs de seu editor de propriedades, que oferece uma interface completa para as suas opes. Veja, a seguir a tela do editor e a descrio das propriedades fundamentais de TIBDatabase:
Figura O editor de propriedades do componente TIBDataBase.
Propriedade DatabaseName LoginPrompt Params IdleTimer DefaultTransaction
Descrio o nome do banco de dados no formato do endereo do arquivo principal do banco. Se o(s) arquivo(s) do banco estiver em um outro computador, o endereo deve indicar o nome do computador. importante observar o formato a ser Indica se uma caixa de dilogo para validao de acesso de usurio deve ser exibida. Esta propriedade usada para passar ao servidor o nome do usurio, senha, SQLRole e character set a serem usados. Indica quantos segundos o servidor deve esperar, quando uma conexo estiver inativa, para encerrar a conexo. Objeto TIBTransaction que ser usado como transao padro da conexo.
Voc acessa o editor de propriedades do componente TIBDatabase clicando com o boto direito do mouse sobre um componente TIBDatase e, no menu de contexto quee se abre, escolher o item Database Editor...; ou simplesmente dando um duplo clique sobre um TIBDatabase.
Transaes no Interbase
O Interbase e o Firebird so servidores SQL fortemente transacionais. Isto quer dizer que qualquer operao que voc fizer (como uma simples consulta SELECT ou uma DDL, por exemplo) deve ser feita 174
dentro do contexto de uma transao. Esta caracterstica uma exigncia bsica da arquitetura muligeracional destes produtos. Este tpico discute como as transaces so tratadas pela Interbase Express.
Usando o TIBTransaction Na Interbase Express, o componente central que voc usa quando quer trabalhar com transaes o TIBTransaction, que um descendente direto de TComponent. Todos os datasets ou comandos da Interbase Express precisam trabalhar com um TIBtransaction, pois os comandos SQL que executam devem necessariamente estar encapsulados dentro do contexto de uma determinada transao. Voc pode executar muitos comandos SQL dentro do contexto de uma mesma transao, mas receber uma mensagem de erro se tentar executar um SQL em uma transao inativa ou inexistente. Ao escrever uma aplicao usando Interbase Express, voc no precisa se preocupar com os detalhes referentes manipulao e gerenciamento de transaes. Todos os datasets Interbase Express sabem como fazer todo o trabalho de inicializao de uma transao etc. Porm, muitas vezes voc desejar controlar manualmente os processos de transaes em seus aplicativos. Esta estratgia oferece o maior nvel de controle sobre as transaes de seu aplicativo. Para a execuo destas tarefas o componente TIBTransaction possui alguns mtodos e propriedades. InTransaction StartTransaction Commit Rollback CommitRetaining RollbackRetaining Call
Nveis de isolamento de transaes O Interbase/Firebird oferece suporte a diferentes nveis de isolamento de transaes. Os nveis de isolamento se referem visibilidade oferecida dentro do contexto de uma transao diferente da referenciada.
Figura O editor de propriedades do objeto TIBTransaction.
175
TIBTransaction tambm providencia, atravs da propriedade AutoSTopAction, um mecanismo para voc determinar o que fazer quando uma transao for encerrada automaticamente . Considera-se uma transao encerrada automaticamente, quando no receber uma instruo commit ou rollback explcita, como, por exemplo, quando voc fecha um dataset IBX. Os valores possveis para esta propriedade e o significado de cada um so os seguintes:
VALOR saNone saRollback saCommit saRollbackRetaining saCommitRetaining SIGNIFICADO A transao no ser implicitamente encerrada. A transao ser encerrada e todas as alteraes sero desfeitas. A transao ser encerrada e todas as alteraes sero confirmadas. A transao no encerrada quando o dataset fecha, mas todas alteraes, inseres, delees de dados sero desfeitas. Esta opo s suportada pelo Interbase 6.0 ou superior ou o Firebird 1.0. A transao no encerrada quando o dataset fecha, mas todas alteraes, inseres, delees de dados sero confirmadas.
Esta propriedade apenas funciona quando os datasets so fechados. Se o objeto TIBTransaction est associado tambm a um componente TIBSQL, AutoStopAction deveria ser saNone, pois a transao no pode determinar se um comando TIBSQL est ativo. This property only works with the closing of TDataset descendants. If the transaction also includes TIBSQL components, AutoStopAction should be saNone, because the transaction cant tell whether there are any active TIBSQL components. Se voc um desenvolvedor de clientes de servidores SQL remotos, voc deveria dedicar algum tempo para compreender bem como funciona uma transao nestes sistemas. Particularmente em servidores SQL fortemente transacionais (como Oracle, Interbase e Firebird), quase certo que voc necessitar trabalhar diretamente com o controle de transaes. Uma vez dominado este conhecimento, voc mesmo o considerar como um recurso indispensvel em suas aplicaes.
Trabalhando com comandos

Comandos so instrues SQL que voc envia a um servidor remoto. A diferena bsica entre um comando e um dataset comum que um comando no possui um link com uma TDataSource, o que o torna incapaz de estar ligado a controles de exibio de dados. Esta caracterstica os torna a escolha ideal quando voc deseja executar intrues SQL que no retornam um resultset, como se faz comumente atravs de DDL ou DML. Este tpico abordar o suporte oferecido pela IBX para execuo de comandos em servidores Interbase/Firebird.
O componente TIBSQL O componente TIBSQL caracterizado pelo fato de oferecer grande suporte execuo de comandos. Na verdade, TIBSQL foi desenhado unicamente para efetuar esta tarefa, e no pode trabalhar como um dataset comum. Como se pode verificar ao observarmos a estrutura da IBX, TIBSQL no um descendente de TDataset, e no implementa nenhuma interface padro para controles de dados, o que siginifica que incapaz de executar muitas tarefas ligadas manipulao e cursores de dados. TIBSQL tambm unidirecional. A grande vantagem de TIBSQL o fato de ser capaz de executar comandos em um servidor SQL com um mnimo de consumo de recursos (overhead) e de forma muito rpida. Voc sempre deveria usar um TIBSQL quando for executar qualquer instruo SQL que no retorne um resultset.
176
TIBSQL implementa muitos mtodos para o trabalho com comandos SQL. Citamos alguns deles na tabela abaixo:
Mtodo CheckValidStatement ExecQuery FreeHandle Prepare Descrio Dispara uma exceo se o comando a ser executa no conter uma instruo SQL vlida. Executa a instruo SQL do comando. Libera os recursos do Interbase associados com uma consulta. Aloca recursos para execuo otimizada de uma instruo SQL.
Muitos outros mtodos esto disponveis ainda para TIBSQL. Para uma referncia completa consulte a ajuda online da Interbase Express.
Executando comandos O mtodo ExecQuery do componente TIBSQL executa um comando SQL em um servidor Interbase. A nica coisa que voc precisa se certificar antes de chamar este mtodo se seu TIBSQL possui uma instruo SQL vlida atribuda sua propriedade SQL e se est associado a uma transao. Como em muitos casos voc desejar tornar as alteraes feitas por seu comando imediatamente disponveis, voc deve encerrar a transao aps executar o comando. Veja o exemplo que segue:
procedure TForm1.BotaoExecuatarClick(Sender: Tobject); begin if not IBSQL1.Transaction.InTransaction then //Se no estiver iniciada... IBSQL1.Transaction.StartTransaction;//Inicia uma transao IBSQL1.SQL.Clear; IBSQL1.SQL.Add(Delete from employee where custno = 2015); IBSQL1.ExecQuery;//Executa o comando IBSQL1.Transaction.Commit;//Confirma a transao end;
Controlando um servidor Interbase

Adicionalmente a objetos de conexo, datasets, transaes e comandos, a Interbase Express disponibiliza uma grande quantidade de componentes responsveis pelo acesso a muitos servios do Interbase/Firebird, tais como backup/restore, estatsticas, configuraes de servidore, instalao/desinstalao etc. Este conjunto de componentes conhecido com o nome InterbaseAdmin e est disponvel desde a verso 4.0 da Interbase Express e s pode ser usado em servidores Interbase 6.0, Firebird 1.0 ou superiores. Este tpico abordar alguns dos principais recursos expostos pela InterbaseAdmin.
A InterbaseAdmin Com a InterbaseAdmin voc pode ir muito alm de criar um simples cliente Interbase. Os componentes oferecem suporte a praticamente qualquer servio disponvel em um servidor Interbase de maneira
177
direta, sempre atravs de chamadas API deste SGDB. Os componentes InterbaseAdmin so instalados por padro na pgina com o mesmo nome na palheta de componentes. A seguir daremos uma descri o simples da funcionalidade de cada um destes componentes:
Componente TIBConfigService TIBBackupService TIBRestoreService TIBValdationService TIBStatisticalService TIBLogService TIBSecurityService TIBLicensingService TIBServerProperties TIBInstall TIBUninstall Utilidade Configura parmetros de um banco de dados, como page buffers, async mode, reserve space e sweep interval. Realiza um backup de um banco de dados. Todas as opes disponveis em uma operao de backup so encapsuladas por este componente. Restaura um backup de um banco. Todas as opes disponveis em uma operao de backup so encapsuladas por este componente. Valida um banco e reconcilia transaes. possvel configurar opes de validaes, aes padro de transaes e retornar informaes de transaes no encerradas. Permite ver diversos dados estatsticos de um banco, tais como log, header pages, index pages, system relations e data pages. Cria um arquivo de log. Permite manipular o acesso de usurio a um servidor Interbase. Com este componente voc pode fazer qualquer alterao nos usurio e roles de um servidor. Permite adicionar ou remover certificados de ativao de um servidor Interbase. Permite recuperar informaes sobre um servidor Interbase. Permite criar aplicativos que instalem o Interbase com total controle de todas opes. Permite criar aplicativos que desinstalem o Interbase com total controle de todas opes.
Voc tambm pode criar qualquer novo componente que acesse um servio de um servidor Interbase e adicion-lo a esta coleo. Alguns destes componentes somente no possuem muita utilidade para desenvolvedores de aplicativos clientes, enquanto outros so extremamente teis. Se voc desenvolve um aplicativo cliente, por exemplo, pode ser muito interessante oferecer uma maneira bastante fcil de oferecer uma instalao do Interbase que qualquer usurio possa realizar sem dificuldades. Um programa que realize operaes de backup de maneira muito simples para o susrio comum ainda mais interessante. Na verdade, os componentes da InterbaseAdmin permitem a criao de um
Figura A ferramenta de exemplo da Borland AdminTool ilustra o uso de muitos componentes da palheta InterbaseAdmin. Na imagem ao lado voc v a janela
aplicativo completo de gerenciamento e manuteno de um servidor Interbase, tal como o IBConsole, que instalado com o servidor. Voc pode encontrar um exemplo de demonstrao das funcionalidades de alguns dos componentes da Interbase Admin no diretrio de instalao do Delphi ...Delphi6\Demos\DB\IBX\Admin\AdminTool.dpr. A imagem abaixo mostra esta ferramenta de exemplo exibindo as propriedades de um banco de dados.
178
179
BASEADAS NA
DBEXPRESS
DBExpress um conjunto de drivers muito leves para acesso rpido a servidores de banco de dados remotos. Para cada banco de dados suportado, a DBExpress prov um driver que se adapta a um servidor SQL especfico e forma uma interface DBExpress uniforme. DBExpress permite o acesso a bancos de dados usando datasets unidirecionais, que so desenhados para acesso rpido a dados de um banco, com um mnimo de overhead. Como outros datasets, eles podem enviar uma instruo SQL para o servidor SQL remoto, e se esta instruo retornar um conjunto de dados, fornece um cursor para o acesso a esses dados. Contudo, datasets unidirecionais podem retornar apenas um cursor unidirecional. Eles no buferizam os dados em memria, o que os faz mais rpidos e menores consumidores de recursos do que outros datasets. Muitas das capacidades implementadas em TDataset esto tambm indisponveis nos datasets unidirecionais, ou o seu dispara excees. Por exemplo: Os nicos mtodos de navegao suportados so Next e First. Todos os outros disparam excees. Alguns mtodos que envolvem bookmarks simplesmente no esto disponveis. No existe suporte para edio local de dados, pois isto requeriria um buffer de dados em memria. Contudo, voc pode atualizar dados de datasets unidirecionais usando comando SQL do tipo UPDATE ou prover mecanismos de edio atravs de datasets clientes. No existe suporte a filtros, pois eles trabalham com mltiplos registros, o que requer um buffer de dados. Todas as limitaes sobre quais dados devem aparecer devem ser feitos atravs de clusulas de comando SQL. No existe suporte para campos lookup, que requerem um buffer de dados para armazenar mltiplos registros contendo os valores dos campos lookup. Se voc definir um campo lookup para um dataset unidirecional, ele no funcionar adequadamente.
A despeito destas limitaes, datasets unidirecionais so poderosos componentes de acesso a dados. Eles so o mais rpido mecanismo de acesso a dados, alm de muitos simples de usar. Este captulo discutir o funcionamento da DBExpress e o conjunto de datasets e outros objetos que ela disponibiliza. Discutiremos tambm como voc pode criar aplicaes altamente flexveis e que suportam tanto a plataforma Linux quanto a Windows ao usar a tecnologia DBExpress.
180
A arquitetura DBExpress
A DBExpress um mecanismo de acesso a fontes de dados SQL. Voc sempre deve Ter isto em mente, pois ela foi projetada com esta finalidade, e no oferece suporte a bancos de dados locais como Paradox ou MSAcess. Atualmente, a DBExpress o mecanismo de acesso a dados que oferece o melhor desempenho e velocidade; e oferece isto sempre da mesma maneira, independentemente do servidor SQL que voc desejar utilizar. Outra caracterstica mpar da DBExpress a sua grande portabilidade. De fato, usando a DBExpress voc poder criar aplicativos para Windows ou Linux, usando sempre o mesmo cdigo-fonte. Este tpico nos introduzir os elementos mais importantes da arquitetura de objetos que usam a DBExpress como mecanismo de acesso a dados.
Como trabalha a DBExpress? DBExpress uma camada independente que define uma interface comum para prov rpido acesso a servidores SQL remotos. Para cada servidor suportado, DBExpress prov um driver na forma de uma biblioteca que implementa as interfaces DBExpress comuns para processar consultas e procedimentos armazenados. Como uma camada leve e simples, DBExpress prov alto desempenho na conexo com bancos de dados, almde ser de distribuio muito simples. Como os drivers DBExpress esto disponveis no Windows como bibliotecas dinmicas (dlls), voc precisa apenas distribuir esta biblioteca com a sua aplicao. Existem drivers DBExpress para os seguintes servidores SQL: MY SQL Interbase Firebird Oracle Informix Sybase MS SQL Server DB2
Os drivers DBExpress podem acessar um servidor SQL diretamente, atravs da sua API (como a maioria deles o faz) ou atravs de um outro mecanismo como ODBC, ADO ou BDE. Voc deveria usar apenas drivers que fazem um acesso direto, pois de outra forma o Delphi j permite um acesso usando estes outros mecanismos sem a DBExpress. Observe, igualmente, que se portabilidade entre plataformas um fator importante no desenvolvimento de um aplicativo, alguns drivers DBExpress no podem ser usados, como qualquer um que acesse MS SQL Server ou aqueles que usem ODBC, ADO ou BDE para realizar acessos. Estes mecanismos e programas no possuem compatibilidade alguma com a plataforma Linux.
Tipos de datasets unidirecionais A pgina DBExpress da Paheta de Componentes contm 4 tipos de datasets unidirecionais: TSQLDataset; TSQLQuery; TSQLTable; TSQLStoredProc.
181
TSQLDataset o mais geral dos quatro. Voc pode um TSQLDataset para representar qualquer dado disponvel atravs da DBExpress. Este o componente atualmente recomendado para o trabalho com bancos de dados. TSQLQuery um dataset baseado em consultas (query-type) e encapsula uma consulta SQL e manipulao de dados de retorno, caso estes existam. TSQLTable um dataset baseado em tabelas (table-type) que representa todas as linhas e colunas de uma nica tabela. TSQLStoredProc um dataset baseado em procedimentos armazenados (stored procedure-type) que executa procedimentos armazenados em um servidor SQL. Nota: Na pgina DBExpress tambm pode ser encontrado o componente TSQLClintDataset, que tambm um dataset unidirecional. Iremos estud-lo no tpico sobre datasets clients.
Conectando com um servidor SQL

O primeiro passo a ser dado quando voc for trabalhar com datasets unidirecionais, prover um mecanismo de conexo com um servidor SQL. Em tempo de projeto, desde que voc tenha uma conexo ativa, o Object Inspector poder listas de valores para outras propriedades. Por exemplo, ao trabalhar com procedimentos armazenados, o Object Inspector pode listar aqueles que existem no servidor SQL para a sua escolha. A conexo com um servidor de dados representada por um componente TSQLConnection. Voc trabalha com este componente da mesma forma com que trabalha com outros componentes de conexo. Em tempo de projeto, escolha qual conexo deseja efetuar a partir de uma lista disponvel na propriedade SQLConnection de TSQLConnection. Tipicamente, todos os datasets unidirecionais de uma aplicao compartilham o mesmo objeto de conexo, a menos que voc esteja trabalhando com dados em mltiplos servidores SQL. Contudo, voc pode quere usar um componente de conexo para cada dataset se o servidor de dados no suportar mltiplas consultas em uma nica conexo. Assegure-se deste fato atravs da propriedade MasxStmtsPerConn de um componente TSQLConnection.
Configurando o objeto TSQLConnection Antes de voc usar o componente TSQLConnection, necessrio configur-lo adequadamente, a fim de que possa identificar o servidor de dados e realizar quaisquer operaes requeridas em uma conexo, como a validao de senhas de usurios e identificao de drivers, por exemplo.
Identificando o driver O driver usado em uma conexo identificado atravsda propriedade DriverName, que o nome de um driver DBExpress instalado, tal como : INTERBASE, ORACLE, MYSQL ou DB2. O nome do driver est associado com dois arquivos: O driver DBExpress, que pode ser tanto uma dll como uma unidade Delphi compilada. 182
O nome da dll provida para suporte DBExpress no lado cliente.
Especificando parmetros de conexo A propriedade Params uma lista de strings com pares NAME/VALUE em cada uma des suas linhas, onde Name o nome do parmetro e Value um valor a ele assinalado. Os parmetros necessrios sua conexo dependem do servidor SQL que voc est usando, mas o parmetro Database requerido para todos os servidores. Por exemplo: com Interbase, Database o nome de um arquivo .GDB; com Oracle a entrada no arquivo TNSMNames.ora etc. Outros parmetros tpicos incluem User_Name (o nome do usurio ao efetuar um login), password (senha do usurio), HostName (o nome de um computador ou endereo IP etc) e TransIsolation ( o nvel de isolamento das transaes executadas no servidor). Voc pode inserir e alterar os valores da propriedade Params acessando o editor para edies de valores de listas desta propriedade. A imagem abaixo mostra este editor.
Figura O editor de parmtros docomponente TSQLConnection.
Nomeando uma descrio de conexo Embora voc possa sempre especificar uma conexo usando apenas as propriedades DatabaseName e Params de um componente TSQLConnection, pode ser mais conveniente nomear uma combinao especfica e passar a identificar a conexo diretamente por este nome. O nome de cada uma das combinaes quevoc criar so chamados connection names. Uma vez definido um connection name, voc pode identificar uma conexo DBExpress atravs da propriedade ConnectionName de um TSQLConnection. A atribuio desta propriedade automaticamente configura todos os detalhes necessrios a uma conexo. A maneira mais simples de criar uma conexo DBExpress atravs do editor de propriedades Connection Editor. Em um s local voc realiza todas as tarefaz de configuraes necessrias de maneira muito rpida. Para exibir o Connection Editor, d um duplo clique no componente TSQLConnection. Este editor permite a criao e alterao de connections names, com todos os seus parmetros. O editor exibe uma lista de drivers instalados, bem como todos os connection names j criados. Atravs dos botes do editor, voc pode criar novos nomes de conexo, delet-los ou alterar
183
seus parmetros. A imagem abaixo mostra o Connection Editor com muitos drivers e connections names.
Figura O editor de conexes DBExpress.
Especificando quais dados exibir

Existe algumas maneiras de especificar que dados um dataset unidirecional representa. O mtodo que voc pode usar depende do tipo de dataset usado e se as informaes provem de uma nica tabela ou no. Quando voc trabalha com o componente TSQLDataset, use a propriedade CommandType para indicar onde o dataset recuperar os dados. Os valores possveis para CommandType so: CtQuery. TSQLDataset executar uma consulta especificada por voc. Se a consulta um comando SELECT, o dataset poder conter o resultset. CtTable. TSQLDataset retorna todos os registros de uma tabela especificada. CtStoredProc: TSQLDataset executa um procedimento armazenado. Se este procedimento retornar um cursor, o dataset conter os registros retornados.
Representando o resultado de uma consulta O uso de uma consulta o mecanismo mais genrico de se recuperar um conjunto de registros. Consultas so simplesmente comandos escritos em SQL. Voc pode usar tanto um componente TSQLDataset quanto um TSQLQuery para representar o resultado de uma consulta. Quando usar um componente TSQLDataset, configure a propriedade CommandText para ctQuery e escreva a consulta SQL na propriedade CommandText. Quando usar um componente TSQLQuery, apenas escreva a consulta SQL na propriedade SQL. Estas propriedades trabalham da mesma maneira.
Representando os registros em uma tabela
184
Quando voc quer representar todos os campos e todos os registros de uma nica tabela, possvel usar tanto um componente TSQLDataset quanto um TSQLTable para gerar uma consulta sem que voc mesmo precise escrev-la. Porm, nem sempre este apanhado insteressante. Se o desempenho uma questo importante em suas aplicaes, quase sempre melhor um apanhado diretamente manipulado por voc atravs de consultas otimizadas. Definitivamente, por mais que parece cmodo o seus usos, datasets baseados em tabelas no so adequados no acesso a servidores SQL. O uso do componente TSQLDataset nestas situaes, implica que o componente gerar uma consulta e transferir todas as colunas e registros da tabela especificada. Apenas configure a propriedade CommandType para ctTable. Quando CommandType possui este valor, o componente TSQLDataset gera uma consulta baseado nos valores de duas propriedades: CommandText, que especifica o nome da tabela que TSQLDataset deveria representar; SortFieldNames, que lista os nomes de todos campos a serem usados para ordenar os dados, em ordem de maior importncia. Por exemplo, se voc especifica o seguinte:
SQLDataSet1.CommandType := ctTable; SQLDataSet1.CommandText := 'Employee'; SQLDataSet1.SortFieldNames := 'HireDate,Salary'
TSQLDataset gera a seguinte consulta, que lista todos os registros na tabela Employee, ordenados pelos campos HireDate e, dentro da ordenao de HireDate, Salary: select * from Employee order by HireDate, Salary
Representando uma tabela usando TSQLTable Quando usar o componente TSQLTable, especifique a tabela que voc deseja atravs da propriedade TableName. Para especificar a ordenao dos campos no dataset, voc deve informar um ndice. Existem duas maneiras de se fazer isto: Configure a propriedade IndexName com o nome de um ndice definido no servidor SQL; Configure a propriedade IndexFieldNames como uma lista de nomes de campos, separados por ponto-e-vrgula, que sero usados na ordenao.
Representado os resultados de uma stored procedure Procedimentos armazenados (stored procedures) so conjuntos de instrues SQL que so armazenadas em um servidor SQL. A maneira como voc indica o procedimento armazenado a ser usado depende do dataset unidirecional que voc usa. Quando for usar um TSQLDataset, especifique um procedimento armazenado: Configurando a propriedade CommandType para o valaor ctStoredProc; Especificando o nome do procedimento armazenado na propriedade CommandText.
Veja um exemplo no fragmento de cdigo abaixo:
185
SQLDataSet1.CommandType := ctStoredProc; SQLDataSet1.CommandText := 'MyStoredProcName';
Quando usar um componente TSQLStoredProc, necessrio apenas especificar o nome do procedimento armazenado na propriedade StoredProcName. Aps haver identificado um procedimento armazenado, sua aplicao pode precisar entrar com valores para quaisquer parmetros de entrada e/ou sada antes de executar o procedimento armazenado.
Obtendo os dados
Uma vez que voc tenha especificado a fonte dos dados, necessrio recuperar os dados antes que sua aplicao possa manipul-los. Como em qualquer dataset, existem duas maneiras de se obter dados nos datasets unidirecionais: Configurando a propriedade Active para True; Chamando o mtodo Open.
Contudo, existem algumas tcnicas que podem otimizar estas operaes.
Preparando o dataset Antes que uma consulta ou procedimento armazenado possam ser executador em um servidor, eles devem primeiro ser preparados. A preparao de um dataset significa que a DBExpress e o servidor alocm recursos para as instrues e seus parmetros. Os datasets unidirecionais so automaticamente preparados quando voc configura a propriedade Active para True ou chama o mtodo Open. Quando voc fecha o dataset, os recursos alocados so liberados. Se voc precisa executar uma consulta ou procedimento armazenado mais de uma vez, ganhar desempenho ao preparar explicitamente o dataset antes de abr-lo pel primeira vez. Para explicitamnte preparar um dataset, configure sua propriedade Prepared para True, como segue:
CustQuery.Prepared := True; Os recursos alocados no sero liberados at que voc configure a propriedade Prepared para False.
Transferindo dados de mltiplos datasets Alguns procedimentos aramazenados retornam mltiplos conjuntos de registros. O dataset apenas transfere o primeiro conjunto quando voc o abre. Para acessar os outros conjuntos de registros, chame o mtodo NextRecordSet. Por exemplo, veja o fragmento abaixo:
var DataSet2: TSQLDataSet; nRows: Integer;
186
begin DataSet2 := SQLDataSet1.NextRecordSet(nRows); ... O mtodo NextRecordSet retorna um TSQLDataset criado novamente que prov6e acesso aos prximo conjunto de registros. Isto , a primeira vez que NextRecordSet for chamado, retorna-se o terceiro dataset e assim por diante at no haverem mais conjuntos de registros.
Executando comandos
Voc pode usar datasets unidirecionais sempre que uma consulta ou procedimento armazenado no retornar um resultset. Tais comando, tipicamente, incluem DDL e DML. No caso de comandos, os datasets meramente passam o comando para o sevidor SQL executar. Contudo, estes comandos que no retornam dados no precisam ser executados por datasets unidirecionais, pois no h necessidade alguma dos mtodos deste componentes para manipulao dos dados. O componente TSQLConnection pode ser usado diretamente para executar comandos no servidor.
Mtodos de execuo Para executar um comando com datasets unidirecionais, voc no usa o mtodo Open ou a propriedade Active. Neste caso, os mtodos a serem usados so: O mtodo ExecSQL, se o dataset uma instncia de TSQLDataset ou TSQLQuery. Veja o exemplo abaixo:
FixTicket.CommandText := 'DELETE FROM Traffics WHERE (TicketID = 1099)'; FixTicket.ExecSQL;
O mtodo ExecProc, se odataset uma instncia de TSQLStoredProc. Veja o exemplo:
SQLStoredProc1.StoredProcName := 'MyCommandWithNoResults'; SQLStoredProc1.ExecProc;
187
COM PROVEDORES E DATASETS CLIENTES
Datasets clientes (client datasets) so datasets especializados que armazenam seus dadosem memria. O suporte manipulao dos dados que eles armazenam na memria provido pela unidade compilada MidasLib.dcu ou pela biblioteca Midas.dll. O formato que os datasets clientes usam para armazenar dados auto-contido e facilmente transportado, o que permite aos datasets clientes: Ler e escrever em arquivos dedicados no disco, agindo como um dataset baseado em arquivo; Armazenar as atualizaes dos dados de um servidor de dados SQL; Representar os dados em um aplicativo cliente de aplicaes multi-camadas. Para trabalhar desta forma, o dataset cliente deve trabalhar com um provedor de dados externo; Representar os dados provindos de uma outra fonte que no um dataset. Como os datasets clientes podem usar os dados vindos de um provedor externo, provedores especializados podem adaptar uma variedade de fontes de informaes que trabalham com datasets clientes. Por exemplo, voc pode usar um provedor XML, a fim de permitir que um dataset cliente represente as informaes de um documento XML.
Se voc usa um dataset cliente em bancos de dados baseados em arquivos, atualizaes em cache, dados obtidos de um provedor externo (tais como os obtidos com um documento XML ou aplicaes multi-camadas), ou uma combinao destes apanhados, como em um aplicativo de modelo portaarquivos (briefcase), voc pode obter vantagens atravs da grande quantidade de recursos implementados em datasets cllientes para trabalhar com dados. Este captulo abordar toda a extenso do suporte Delphi a datasets clientes, esclarecendo as razes de esta tecnologia estar se tornando cada vez mais importante no desenvolvimento de aplicativos Windows.
188
A arquitetura dos datasets clientes

As aplicaes distribudas introduzem um novo conjunto de conceitos de desenho, distribuio e logstica que objetivam racionalizar as atribuies de operao e funcionalidades em diversos aplicativos, ao mesmo tempo que objetiva um acesso profundamente compartilhado dos dados. Desde o surgimento dos primeiros aplicativos distribudos, em grandes sistemas corporativos crticos e em muitos servios implementados via WEB, as grandes corporaes fornecedoras de tecnologias de desenvolvimento tm investido nas capacidades desta arquitetura de acesso. Particularmente a Borland e a Microsoft tm estado frente nas pesquisas de tecnologia para implantao de aplicativos distribudos, o que resultou no fato de estas empresas terem desenvolvido tecnologias que hoje tm se tornado padro para o desenvolvimento de aplicaes distribudas. As grandes possibilidades hoje colocadas aos desenvolvedores atravs das tecnologias de WEBServices, SOAP e XML so fortes exemplos de como a Borland tem investido fortemente em tecnologias de aplicaes distribudas. Nos nossos dias a Borland detm reconhecida vanguarda e domnio mundial no desenvolvimento de tecnologias para acesso distribudos. Por outro lado, a Microsoft j tem publicamente divulgado os seus planos de dotar paulatinamente o sistema operacional Windows de recursos que ofeream suporte a um ambiente de aplicativos distribudos. Inicialmente com DCOM e ActiveX e, mais recentemente, com o conjunto de tecnologias denominado .NET. Como desenvolvedor Delphi, voc s pode esperar avanos no suporte ao desenvolvimento de aplicativos distribudos. Ano aps ano, principalmente nesta rea que as novas verses do Delphi tm oferecido maiores novidades. Como desenvolvedor Delphi, voc deve considerar, ainda, o fato de a Borland ser a parceira da Microsoft no desenvolvimento das tecnologias .NET. Este fato no s refora o intuito h muito pblico da empresa focar seus esforos neste campo, como tambm abre de imediato a voc uma perspectiva sedutora para os novos desenvolvimentos. Neste tpico, voc se introduzir no suporte Delphi criao de aplicaes distribudas que acessam bancos de dados. Muitos aspectos no podero ser discutidos agora, como aplicaes distribudas que so executadas via WEB, CORBA, WEBServices, SOAP e aplicativos .NET. Todos estes assuntos (uma enormidade!) so objeto do curso que trata do suporte Delphi a tecnologias WEB distribudas.
Estudando TClientDataset
TClientDataset um componente dataset desenhado para trabalhar sem um suporte de conectividade. Tudo o que ele usa a biblioteca MIDAS.dll. Este componente oferece todo o suporte a edio, navegao, constrio de dados e filtros oferecidos por muitos dos outros datasets, mas implementa seu prprio mecanismo de obteno e atualizao de dados. Isto provido de uma das seguintes maneiras: Lendo e escrevendo em um arquivo de dados (flat file) acessado diretamente. Obtendo dados a partir de outros datasets. Usando uma interface de acesso remoto para obter os dados e enviar as atualizaes para um aplicativo servidor de dados.
Estes mecanismos podem ser combinados de muitas formas diferentes, mas o comportamento geral de um TclientDataset ser sempre semelhante. Editando dados Datasets clientes representam seus dados como um pacote residente na memria. Este pacote o valor da propriedade Data. Por padro, contudo, as edies feitas nos dados no so armazenadas na 189
propriedade Data. Ao contrrio, todas inseres, delees ou edies (feitas por usurios ou programaticamente) so armazenadas em uma espcie de log interno de mudanas, que a propriedade Delta. O uso deste mecanismo serve a dois propsitos: Ao se trabalhar com um provider, o log de alteraes requerido pelo mecanismo que ir atualizar as mudanas no servidor de dados. Em qualquer arquitetura de aplicaes com datasets clientes, o log prov um mecanismo sofisticado para se desfazer alteraes.
A propriedade LogChanges permite-lhe desabilitar temporariamente o recurso de log. Quando LogChanges True, as alteraes sero registradas no log; do contrrio, elas so feitas diretamente na propriedade Data. Voc pode, por exemplo, desabilitar o recurso de log em uma aplicao de uma camada que no necessite desfazer as alteraes. As edies no log de mudanas permanecem at que sejam removidas pela aplicao, quando: Se desfazem alateraes; Salvam-se as mudanas.
Nota: Ao salvar-se registros em datasets clientes ligados a arquivos, o log de alteraes no desfeito. Isto oferece suporte a aplicaes briefcase.
Desfazendo alteraes Datasets clientes so capazes de armazenar mltiplas entradas nos seus mecanismos de log de mudanas. Isto significa que a cada alterao feita em um registro gerada uma entrada especfica no log de alteraes. Este armazenamento em separado torna possvel o suporte a mltiplos nveis de operaes de desfazer, at o nvel onde a primeira alterao foi feita. Para remover a ltima alterao de um registro, chame o mtodo UndoLastChange. Este mtodo exige o parmetro FollowChange, do tipo boolean, que indica se se retornar o cursor no registro a ser restaurado. UndoLastCHange retorna um valor boolean, indicando se a operao de restauramento foi feita com sucesso ou no. Use a propriedade ChangeCount para conhecer o nmero de alteraes existentes na propriedade Delta. Voc tambm pode remover todo o contedo do log de alteraes, referentes a um determinado registro, de uma s vez, usando o mtodo RevertRecord. Neste caso, o registro a ser considerado o registro atual. Em qualquer ponto durante uma edio, voc pode salvar o estado atual do log de mudanas usando a propriedade SavePoint. A leitura de SavePoint retorna um marcador dentro da posio atual do log. Mais tarde, se voc desejar desfazer todas as mudanas que ocorreram desde a leitura do ponto marcado, configure SavePoint para o valor lido previamente. A sua aplicao pode obter valores para mltiplos marcadores de pontos.
190
possvel tambm abandonar todas as mudanas feitas chamando o mtodo CancelUpdates. Desta forma, voc limpa efetivamente o log de alteraes. Seja cuidadoso ao usar CancelUpdates. Se voc us-lo inadivertidamente, no poder obter novamente o log eliminado.
Salvando as alteraes Os datasets clientes usam mecanismos diferentes para incorporar as mudanas obtidas de um log de alteraes, dependendo se eles so usados em uma aplicao stand-alone ou se representam os dados obtidos de um servidor remoto. Independentemente do mecanismo usado, o log de alteraes automaticamente esvaziado quando todas as atulizaes so incorporadas. Aplicaes stand-alone podem simplesmente gravar as mudanas no cache de dados representado pela propriedade Data. No necessrio se preocupar com a manipulao de acessos concorrentes ou verificar alteraes feitas por outros usurios antes de voc. Apenas chame o mtodo MergeChangeLog. Voc no pode usar este mtodo em aplicaes distribudas. A aplicao servidora precisa das informaes do log a fim de resolver possveis conflitos de atualizao. Use, ento, o mtodo ApplyUpdates, que envia as mudanas para o aplicativo servidor e atualiza a propriedade Data apenas quando as modificaes foram salvas com sucesso no servidor de dados SQL. O mtodo ApplyUpdates exige um parmetro do tipo inteiro chamado MaxErrors. Este parmetro informa o limite mximo de erros admissvel no processo de atualizao dos dados de um dataset cliente. Isto , ao resolver o processo e atualizao, o servidor de dados tentar atualizar os dados no servidor SQL e, caso o nmero dos erros encontrados for maior do que o valor indicado no parmetro MaxErrors, todo o processo ser cancelado at que as correes sejam feitas. O processo de correo dos erros encontrados conhecido com Reconciliao. Se a MaxErrors for atribudo 0, todos os possveis erros sero retornados; do contrrio, se seu valor for 1, nenhum error ser retornado. Veja um exemplo usando ApplyUpdates:
ClienteDataset1.ApplyUpdates(0); //Quaisquer erros sero retornados ClienteDataset2.ApplyUpdates(-1);//Nenhum erro retornado ClienteDataset3.ApplyUpdates(5); //No mximo 5 erros sero tolerados.
Nota: o provider no pode detectar um conflito em atualizaes em campos tipo Memo (texto com muitas linhas), e, portanto, no retornar erros nestes casos.
Indexando colunas com TClientDataset
DG 24-6..8 O uso de ndices prov muitos benefcios para suas aplicaes. Os datasets clientes oferecem grande suporte ao trabalho com ndices de diversas maneiras. Se o dataset cliente usado em uma aplicao distribuda, ele herda os ndices do servidor de dados, e exibe os dados ordenados por este ndice. O ndice padro denominado DEFAULT_ORDER. Voc tambm pode usar outro ndices existentes, assim como criar seus prprios ndices.
191
Adicionando um novo ndice Para criar um novo ndice em um dataset cliente, chame o mtodo AddIndex que permite-lhe especificar as propriedades do ndice, tais como: O nome do ndice. Os campos marcados pelo ndice. A forma como o ndice ordena os registros. Por padro, ele o faz de forma ascendente e casesensitive.
Os ndices que voc cria so listados em ordem alfabtica ascendente em seu computador. A ordenao em ndices de campos string case sensitive, mas voc pode alterar este padro adiconando a opo ixCaseInsensitive nas opes de configuraes dos ndices. De forma pouco comum nos datsets, os datasets clientes oferecem suporte a ndices em campos calculados e agregados. Estes ndices trabalham de maneira idntica a um ndice normal de um campo fsico. Veja um exemplo simples, que ilustra algumas tcnicas de trabalho com ndices em datasets clientes:
procedure TForm1.QuickIndexClick(Sender: TObject); begin if Edit1.Text <> '' and ClientDataSet1.Fields.FindField(Edit1.Text) then begin ClientDataSet1.AddIndex(Edit1.Text + 'Index', Edit1.Text, [ixCaseInsensitive],'','',0); ClientDataSet1.IndexName := Edit1.Text + 'Index'; end; end;
No exemplo acima, se existir um campo com o nome digitado em um Tedit (edit1), um ndice com o nome do campo concatenado com a constante Index criado. Em seguida, o dataset cliente ClientDataset1 comea a usar o novo ndice.
Excluindo e alternando ndices Voc pode remover um ndice de um dataset cliente usando o mtodo DeleteIndex, que exige como parmetro o nome do ndice a ser excludo. Voc no pode excluir o ndice atribudo como DEFAULT_ORDER. A propriedade IndexName indica o nome do ndice que um dataset cliente deve usar. Para trocar o ndice a ser usado, basta atribuir o nome de um ndice j existente propriedade IndexName dos datasets clientes. Veja um exemplo:
ClientDataset1.IndexName := NovoIndice; ClientDataset1.DeleteIndex(IndiceAntigo);
Campos calculados e agregados

Como com qualquer dataset, voc pode usar campos calaculados em um dataset cliente. Campos calculados no so armazenados na estrutura de sua tabela, mas unicamente exibem valores 192
calculados a partir de outros dados disponveis. Datasets clientes, contudo, permitem uma grande otimizao no clculo de campos calculados atravs do uso de campos internamente calculados.
Campos internamente calculados Em outros datasets, sua aplicao deve computar os valores de campos calculados todas as vezes que ocorrem uma alterao no registro ou o usurio edita qualquer campo no registro atual. O clculo feito atravs do manipulador de eventos OnCalcField dos datasets. Enquanto voc continua podendo fazer isto, os datasets clientes permite-lhe minimizar o nmero de vezes que os campos calculados so computados salvando seus valores em suas propriedades Data. O clculo de campos calculados continua sendo necessrio quando voc edita um registro, mas no ser necessrio o recalculo todas as vezes que o registro se modificar. Para usufruir destes benefcios, voc precisa usar campos calculados internamente, em vez dos tradicionais campos calculados. Campos calculados internamente, exatamente como os outros campos calculados, so calculados em um manipulador de eventos OnCalcField. Contudo, voc otimiza seu manipulador checando a propriedade State dos datasets clientes. Quando a propriedade State contiver o valor dsInternalCalc, voc necessita recalcular o valor do campo. De outra forma, se State contiver o valor dsCalcFields, ser necessrio recalcular apenas os campos calculados comuns. Em tempo de projeto, voc define um campo calculado internamente adicionando um novo campo do tipo InternalCalc na janela NewField.
Figura A janela New Field acessada quando voc for criar um campo do tipo InternalCalc.
Usando campos agregados Datasets clientes oferecem suporte a campos que sumarizam dados em grupos de registros. Na sua forma mais simples, campos agregados permitem-lhe obter informaes tais como a soma dos valores de uma coluna de um dataset cliente. Contudo, estes campos so flexveis suficiente para suportar uma grande variedade de clculos de sumarizao para obter subtotais de grupos de registros definidos por um ndice que suporta agrupamento.
193
Para especificar que voc deseja criar sumarizaes em um dataset cliente, use a propriedade Aggregates. Esta propriedade uma coleo de especificaes de sumarizaes (TAggregate). Para cada item criado n propriedade Aggregates, a propriedade Expression o clculo a ser efetuado atravs de expresses de clculo simples, como Sum(Field) Ou mais complexas, como em Sum(Qty * Price) Sum(AmountPaid) A tabela abaixo indica os operadores de sumarizao aceitos:
Operador Sum Avg Count Min Max Uso Totaliza os valoes de camposnumricos ou expresses. Computa o valor mdio para campos numricos, de datas ou expresses. Especifica o nmero de valores no nulos para um campo ou expresso Indica um valor mnimo para campos numricos, string, datas ou expresses. Indica um valor mximo para campos numricos, string, datas ou expresses.
Muitos tipos de campos agregados precisam de um ndice especfico para executar os clculos de sumarizao. Tipicamente, isto necessrio em clculos sobre grupos de dados. Neste caso, voc deve criar um ndice que suporte agrupamento de dados e, em seguida, indicar o seu nome na propriedade IndexName da definio criada na propriedade Aggregates.
Copiando dados de outros datasets

Datasets clientes oferecem suporte para cpia dos dados de outro dataset. Este processo pode ser feito de maneira muito simples, tanto em tempo de projeto como em execuo. Datasets clientes copiam estes dados sempre da mesma maneira, independentemente do tipo de dataset que servir como fonte de dados.
Assinalando dados diretamente Voc pode usar a propriedade Data de um dataset cliente para assinalar dados de um dataset para outro. Como a propriedade Data do tipo OleVariant na forma de um pacote de dados, um determinado pacote de dados pode vir de outro dataset cliente ou de outros datasets atravs de um provider. Desde que os dados estejam atribudos propriedade Data, o seu contedo exibido automaticamente. Se o seu dataset cliente no usa um provider, voc pode copiar os dados de outro dataset cliente como se segue: ClientDataset1.Data := ClientDataset2.Data;
194
Quando voc copia a propriedade Data de outro dataset cliente, gerada uma cpia do log de alteraes tambm, mas a cpia no reflete quaisquer filtros aplicados. Para obter tambm este ltimo benefcio, necessrio clonar um cursor de dados. Se voc est copiando dados de outro dataset que no seja um dataset cliente, possvel criar um componente provider, lig-lo ao dataset que servir de fonte dos dados e copiar os dados:
TempProvider := TDatasetProvider.Create(Form1); TempProvider.Dataset := SourceDataset; ClientDataset1.Data := TempProvider.Data; TempProvider.Free;
Nota: quando a propriedade Data assinalada diretamente, o novo pacote de dados no adicionando ao pacote existente. Ao contrrio, o novo pacote substitui completamente o pacote anterior.
Clonando um cursor de dados Datasets clientes fornecem o mtodo CloneCursor para possibilitar o trabalho com uma outra viso de um dataset cliente especfico durante a execuo de um aplicativo. CloneCursor permite a um segundo dataset cliente compartilhar os dados originais de outro dataset cliente. Devido ao fato de os dados clonados serem compartilhados, o segundo dataset no pode alterar seus dados sem afetar o dataset original. O mtodo CloneCursor requer trs parmetros. Source especifica o dataset cliente que deve ser clonado. Resep e KeepSettings indicam se a cpia incluir outras informaes alm dos dados. Propriedades como Filter, Filtered, FilterOptions, e OnFilterRecord IndexName MasterSource e MasterFields ReadOnly RemoteServer e ProviderName
so afetadas por estes dois ltimos parmetros. Para uma referncia completa, consulte a ajuda do Delphi.
Manipulando TClientDataset com um provedor de dados

No contexto de aplicaes distribudas, o dataset cliente obtem os dados de um provider residente no aplicativo servidor de dados. Os providers so componentes que se encarregam do empacotamento dos dados obtidos de um dataset ou arquivo XML, enviando-os em seguida a um dataset cliente. Os providers podem estar na mesma aplicao que um dataset cliente, mas mais comum inser-lo em outra aplicao a fim de criar mecanismos remotos de comunicao entre aplicativos. Aps editar localmente os dados empacotados por um provider, um dataset cliente aplica todas as atualizaes ao servidor remoto atravs do aplicativo servidor de dados. Os seguintes passos descrevem como usar um dataset cliente com um provider:
195
Especificao de um provedor de dados (provider); Opcionalmente, obteno de parmetros da aplicao servidora de dados ou enviando parmetros para a mesma. Opcionalmente, sobrescrio do dataset na aplicao servidora de dados. Requisio dos dados da aplicao servidora. Manipulao das constries recebidas no servidor remoto e da aplicao servidora. Gravao das alteraesdos dados. Atualizao dos registros.
Adicionalmente, datasets clientes tambm permitem a comunicao com um provider usando eventos customizados. O captulo seguinte descreve em detalhes o funcionamento de providers nos ambientes Delphi e Kylix.
Especificando um provedor de dados (data provider )

Antes que um dataset cliente possa receber dados e aplicar atualizaes em um servidor de dados, ee deve ser associado com um provedor de dados. Para associar um dataset cliente com um provedor em uma aplicao de arquitetura distribuda, use as propriedades RemoteServer e ProviderName do dataset cliente. Em aplicaes de apenas uma camada e em aplicaes que usam o modelo protaarquivos, estas duas propriedades no so usadas. Ao usar um dataset cliente com um provider que instanciado em uma mesma aplicao, voc no precisa usar a propriedade RemoteServer, mas ainda pode usar a propriedade ProviderName. A propriedade RemoteServer especifica o nome de um componente de conexo a partir do qual se poder obter uma lista de providers exportados. O componente de conexo reside no mesmo mdulo de aplicao que o dataset cliente, estabelecendo e mantendo uma conexo com uma aplicao servidora, que s vezes denominada data broker. Em tempo de projeto, aps voc especificar um valor para RemoteServer, possvel selecionar um provedor da lista exibida na propriedade ProviderName. Esta lista tambm incluir quaisquer provedores locais que estiverem definidos na sua aplicao.
Obtendo parmetros da aplicao servidora

Existem duas situaes nas quais uma aplicao cliente precisa obter valores de parmetros de uma aplicao servidora de dados: O cliente precisa saber o valor de um parmetro de sada em um procedimento armazenado; O cliente quer inicializar os parmetros de entrada de uma consulta ou procedimento armazenado para os valores correntes de uma consulta ou procedimento armazenado na aplicao servidora de dados.
Todo dataset que suporta parmetros armazena os valores de parmetros em sua propriedade Params. Estes valores so atualizados com qualquer parmetro de sada se o dataset cliente recebe dados de uma aplicao servidora. Para maiores informaes sobre o suporte a parmetros em datasets clientes, consulte a ajuda on-line do Delphi.
196
Pasando parmetros para a aplicao servidora

Os datasets clientes podem passar parmetros para a aplicao servidora para especificar quais dados eles querem obter. Estes parmetros podem especificar. Valores de parmetros para uma consulta ou procedimento armazenado da aplicao servidora; Valores de campos que limitam os registros enviados nos pacotes de dados.
Voc pode especificar valores de parmetros que o se dataset cliente envia para a aplicao servidora em tempo de projeto ou em execuo. Em tempo de projeto, acesse a propriedade Params e fornea os valores desejados. Em execuo, use o mtodo CreateParams da propriedade Params para adicionar um parmetros em um dataset cliente. Este mtodo retorna um objeto de parmetros, e voc pode especificar seu nome, valor, tipo etc. Veja o exemplo abaixo:
with ClientDataset1.Params.CreateParams(ftInteger, CustNo, ptInput) do AsInteger := 605;
Enviando consultas ou parmteros de procedimentos armazenados Quando um provider de uma aplicao servidora representa o resultado de uma consulta ou procedimento armazenado, voc pode usar a propriedade Params para especificar os valores dos parmetros. Quando o dataset cliente requisitar os valores do provider ou executar seu mtodo Execute (para executar uma consulta que no retorna dados), ele passa estes valores de parmetros junto com a requisio de dados. Quando o provider recebe estes valores de parmetros, ele os assinala para o seus dataset associado. A aplicao servidora executa o dataset e, se houverem dado retornados, retorna-os para o dataset cliente.
Limitando registros com parmetros Quando o provider na aplicao servidora representa os dados de um dataset baseado em tabela, voc pode usar a propriedade Params para limitar os registros que so providos na propriedade Data. Cada nome de parmetro deve corresponder ao nome de um campo no dataset baseado em tabela. Por exemplo, considere uma aplicao cliente eu exibe as compras de um nico cliente de cada vez. Quando o usurio identifica o cliente, o dataset cliente configura sua propriedade Params para incluir um parmetro denominado CodCli, que representa o campo que armazena o cdigo do cliente. Quando o dataset cliente requisitar os dados da aplicao servidora, ele passar o valor deste parmetro. A aplicao servidora retornar, ento, somente os dados deste cliente procurado. Esta tcnica mais eficiente do que permitir que o servidor recupere muitos dados e, aps envi-los ao dataset cliente, este ltimo se encarrecaria de filtr-los para a exibio do dado procurado.
Sobrescrevendo o resultset de um provedor de dados
197
Usualmente, os providers de uma aplicao servidora so associados com datasets que determina os dados que sero retornados aplicao cliente. Estes datasets contm uma instruo SQL ou fazem referncai a lgum objeto especfico do banco de dados. Se um provider permitir, um dataset cliente pode sobrescrever a propriedade que indica quais dados ele representa. Voc faz isto atravs da propriedade CommandText de um dataset cliente. CommandText deve conter uma instruo SQL que ir substituir aquela usada pelo dataset associado ao provider, ou conter o nome de uma tabela ou procedimento aramazenado que substituir o nome de uma tablea ou procedimento armazenado do dataset associado ao provider. Este recurso permite aos datasets clientes especificar dinamicamente os dados com os quais vai trabalhar. Por padro, o provider no permite que o dataset cliente faa esta troca. Para permitir o uso deste recurso, voc deve adicionar o item poAllowCommandText na propriedade Options do provider da aplicao servidora. Do contrrio, a ionstruo contida em CommandText ser ignorada. Os datasets clientes enviam sua instruo definida na propriedade CommandText de duas maneiras: Quando um dataset cliente aberto; Quando um dataset cliente envia um comando a ser executado na aplicao servidora. Ele o faz atravs do mtodo Execute.
Requisitando dados de uma aplicao servidora A tabela seguinte lista as propriedades e mtodos dos datasets clientes que determinam como os dados so transferidos para a aplicao cliente nas aplicaes multi-camadas:
Propriedade ou mtodo FetchOnDemand PacketRecords GetNextPacket FetchBlobs FetchDetails Propsito Esta propriedade determina se um dataset cliente automaticamente transfere ou no os dados quando for necessrio. Esta propriedade especifica o tipo ou nmero de registros a serem retornados em cada pacote de dados. Este mtodo transfere o prximo pacote de dados da aplicao servidora. Este mtodo transfere qualqier campos BLOB para o registro atual quando a aplicao servidora no os transfere automaticamente. Este mtodo transfere datasets embutidos para cada registro quando a aplicao servidora no os transfere automaticamente.
Por padro, um dataset cliente recupera todos os registros de uma aplicao servidora. Voc pode controlar coo os dados so recuperados usando a propriedade PacketRecords e o mtodo FetchOnDemand. PacketRecords especifica tanto a quantidade de registros a recuperar em cada pacote de dados como o tipo de registros a serem recuperados. Por padro, PacketRecords configurada para 1, o que siginifica que todos os registros sero recuperados em um nico pacote. Neste caso, o dataset cliente no precisa mais transferir dados, pois todos j esto disponveis. Para sobrescrever este padro, configure PacketRecords para um determinado nmero de registros. Por exemplo, o fragmento de cdigo abaixo instrui um dataset client a recuperar pacotes com 10 registros cada:
ClientDataset1.PacketRecords := 10;
Este processo de recuperao de registros em diversos pacotes conhecido como incremental fetching. Os datasets usam este recurso auando o valor de PacketRecord maior do que zero. 198
O mtodo GetNextPacket retorna um nmero de registros em um pacote. Este nmero determinado pela propriedade PacketRecords. Se o nmero de registros recuperados igual ao valor de PacketRecords, o dataset cliente sabe que existem mais pacotes disponveis. Se GetNextPacket retorna 0, ento no existem mais pacotes a serem transferidos. Nota: o recurso incremental fetching apenas funcionar desta forma se a aplicao servidora for capaz de preservar informaes de estado. Servidores COM que so sem estado ou que so executados em protocolos sem estado por natureza, como HTTP, no podem trabalhar com este recurso atravs de seus mtodos padres. Nos captulos posteriores, veremos como usar incremental fetching em servidores ou protocolos sem estado.
Manipulando constries
Datasets clientes suportam dois tipos de recursos de manipulao de constries: Constries que so enviadas do aplicativo servidor nos pacotes de dados; Constries personalizadas escritas na aplicao cliente.
Este tpico abordar como os datasets clientes trabalham com recursos de constries de dados.
Manipulando constries do servidor de dados Por padro, constries do servidor so expresses passadas para os datasets clientes pela aplicao servidora, onde elas podem ser impostas na edio de dados dos usurios. Quando as constries esto agindo, o usurio pode editar dados nas aplicaes clientes que violariam as constries impostas na aplicao servidora. As constries importadas de um aplicativo servidor para um cliente agem no sentido de impedir que os possveis erros de edio dos dados sejam levados ao aplicativo servidor, sendo, de outra forma, detectados e tratados na prpria aplicao cliente. Esta estratgia visa a minimizar a quantidade de erros durante o processo de atualizao dos dados de um dataset cliente. Enquanto a importao das constries definidas no aplicativo servidor por um cliente um recurso extremamente valoroso, pois possibilita ao programador preservar a integridade dos dados nas aplicaes, podem existir situaes onde ser necessrio desabilitar as constries temporariamente. Por exemplo: se uma constrio de um servidor baseada no mximo valor corrente de um campo, mas os datasets clientes usam o recurso de incremental fetching, o mximo valor corrente de um campo pode diferir do valor mximo no servidor de banco de dados. Em uma outra situao, se uma aplicao cliente aplia um filtro sobre os registros quando as constriesesto ativadas, o filtro pode interferir de uma maneira no prevista nas condies de constries. Em cada um destes casos, a aplicaes poderia desabilitar a checagem das constries. Para desabilitar a checagem de constries temporariamente, chame o mtodo DisableConstraints de um dataset cliente. Para retornar com a checagem de constries, chame o mtodo EnableConstraints. Sempre chame estes dois mtodos em um mesmo bloco de cdigo, a fim de garantir que as checagens de constries desativadas sero novamente colocadas em servio. Veja um exemplo:
199
Procedure Tform1.ProcessaPagamentos; Begin Try ClientDataset1.DisableConstraints; //Opera sobre os dados... Finally ClientDataset1.EnableConstraints; End; End;
Nota: os mtodos DisableConstraints e EnableConstraints determinam se um dataset cliente deve aplicar constries aos seus dados. Contudo, eles no tm efeito algum quando a aplicao servidora inclui informaes de constrio nos pacotes de dados. Voc pode previnir o envio de informaes de constries pelo servidor usando a propriedade Contraints do provider associado a um dataset cliente.
Adicionando constries personalizadas Voc pode usar as propriedades dos campos (objetos fields) de um dataset cliente para criar condies de constries personalisadas. Cada componente field possui duas propriedades que voc pode usar para fazer isto: A propriedade DefaultExpression define um valor padro que assinalado ao campo caso o usurio no informe um valor. Observe que se as constries importadas do aplicativo servidor tambm define um valor para esta propriedade, o valor definido manualmente por voc ter precedncia. A propriedade CustomConstraints permite criar uma consdio de constrio que deve ser validada antes de um valor para o campo ser aceito. As constries definidas desta maneira so aplicadas adicionalmente a qualquer contrio importada do aplicativo servidor.
Adicionalmente, voc tambm pode criar constries executadas a nvel de regsitro, isto , quando um registro tentar ser salvo. Isto feito atravs da propriedade Constraints do dataset cliente. No geral, voc sempre deve definir suas constries na aplicao servidora, a fim de que ela possa transmit-las aos clientes. Isto feito assim em obedincia arquitetura de aplicaes distribudas, que sempre coloca as tarefas de validaes a cargo da aplicao servidora. Existem ainda muitas outras vantagens obtidas com o uso desta estratgia, mas algumas validaes podem ser mais adequadas na camada cliente.
Atualizando registros em um servidor

O processo de atualizaode registros em aplicaes distribudas muito diferente do processo normal que conhecemos em aplicaes Desktop ou Client/Server. Uma das diferenas maiores consiste na forma como os datasets clientes armazenam as alteraes feitas, bem como a estratgia usada por um provider para salvar os dados em um servidor SQL remoto. 200
Este tpico ir abordar, em detalhes, todo o processo dee atualizao de registros que deve ser mplementado nas aplicaes distribudas.
Gravando as alteraes Quando uma aplicao cliente conectada com um servidor de dados, os datasets clientes trabalham com uma cpia local dos dados passados pela aplicao servidora. O contedo das alteraes gravado em um log de mudanas, que a propriedade Delta dos datasets clientes. Para tornar as mudanas registradas em Delta permanentes, o dataset cliente precisa grav-las no banco de dados. Sempre que um dataset cliente envia suas alteraes ao aplicativo servidor, os seguintes processo ocorrem: A aplicao cliente chama o mtodo ApplyUpdates de um objeto dataset cliente. Este mtodo passa o contedo da propriedade Delta do dataset cliente para a aplicao servidora. O componente provider da aplicao servidora aplica as atualizaes no servidor de banco de dados, guardando quaisquer problemas que ele no consiga resolver ao nvel de aplicaes servidoras. O componente provider da aplicao serviora retorna todos os registros no atualizados (que contm algum tipo de erro) para a aplicao cliente em um pacote de dados Result. Este pacote contm as informaes dos erros encontrados em cada registro. A aplicao cliente tenta reconciliar os erros retornados no pacote Result.
Reconciliando erros de alteraes

J vimos anterirormente como o mtodo ApplyUpdates trabalha, e a funo especial do seu parmetro MaxErrors. Este tpico avanar nestes pontos, explicando em que consiste o processo de reconciliao dos dados retornados aplicao cliente com o pacote Result.
Atualizaes em uma s tabela Usando datasets clientes em aplicaes distribuda, a reconciliao dos dados junto ao aplicativo servidor pode ser to simples como: ClientDataset1.ApplyUpdates(-1);
Todas as ayualizaes so feitas no contexto de uma transao do servidor SQL, e o exemplo acimo poderia ser traduzido da seguinte forma: Atualize, em uma transao, todos os dados possveis. Porm, um apanhado maiss seguro exigiria mais rigor durante as atualizaes. Como em:
ClientDataset1.ApplyUpdates(0);
201
J o cdigo acima significa: Dentro de uma transao, atualize tudo ou nada. O que quer dizer que, se durante o processo de atualizaes um erro for encontrado, o aplicativo cliente que enviou o pacote de atualizaes deve resolver de alguma forma os dados problemticos. O aplicativo poder solucionar o problema atravs do processo de reconciliao dos dados, que consiste, basicamente, na apresentao dos erros ao aplicativo cliente em uma caixa de dilogo para que ele possa corrigir o erro ou indicar o que fazer com aquela alterao. Voc pode usar a caixa de dilogo padro para reconcilia de erros para oferecer um meio para que seu aplicativo possa executar estas tarefas. No Delphi 6, voc introduz uma janela de reconciliao acessando o Object Repository e, na pgina Dialogs, escolher o cone Reconcile Error Dialog. Desde que este formulrio esteja disponvel em sua aplicao, basta implementar o seguinte cdigo no manipulador de eventos OnReconcileError de seus datasets clientes.
Action:=HandleReconcileError(Dataset, UpdateKind, E);
Isto ser suficiente para voc oferecer um suporte completo para reconciliao de erros em seus aplicativos distribudos. claro que voc no precisa obrigatoriamente usar esta janela padro. Voc pode criar qualquer uma que lhe agrade mais ou, se os aplicativos clientes de seu servidor so servios WEB de qualquer natureza, voc poder oferecer o suporte a reconciliao atravs de uma pgina HTML. Tudo feito com a mesma estratgia.
Atualizaes em dados com joins O processo de atualizaes de dados em um dataset cliente que possua dados recuperados de junes (joins) de duas ou mais tabelas tambm bastante simples. Geralmente, voc faz joins para exibir determinadas relaes entre as tabelas. Muitas vezes, as junes permitem-nos exibir dados de duas (ou mais) tabelas como se estivessem em apenas uma. O controle do modo como uma atualizao feita, nestes casos, determinado por um componente especfico para atualizaes (um update dataset), que conter em suas propriedades quais campos devem ser atualizados. Estes componentes esto ligados a um dataset especfico da aplicao servidora, e o provider ir consult-lo na hora de definir como gravar um registro. Como cada dataset de um aplicativo servidor possui um componente a ele vinculado que ir determinar como ser feita a alterao ( em termos de SQL, quais os comandos sero usados), os providers no precisam se encomodar em tentar descobrir como faz-lo. Voc sempre deveria colocar um componente dataset update para gerenciar as atualizaes de seus datasets, pois isto garante um controle absoluto sobre todo o processo de atualizao.
TClientDataset com dados baseados em arquivos

Os datasets clientes podem funcionar independentemente de um provider, tal como em aplicaes de bancos de dados baeadas em arquivos. Quando no existe um provider, contudo, datasets clientes no podem recuperar os dados de um servidor SQL remoto. Assim, o dataset cliente deve fazer independentemente: Definir e criar tabelas; Carregar e salvar dados dos arquivos;
202
Armazenar as edies no seus dados; Salvar os dados.
O que o modelo porta-arquivos? ( briefcase ) O modelo porta-arquivos implementa uma arquitetura de acesso isolado a dados locais com suporte a atualizaes locais e em servidores de dados. Uma aplicativo porta-arquivos possui um banco de dados baseado em arquivos, e tipicamente um aplicativo muito leve. Os datasets clientes so o centro desta arquitetura, e implementam toda a funcionalidade de um banco de dados sem exigir quaisquer outros mecanismos de acessos adicionais. Embora os dados de um aplicativo possam ser usados como um banco de dados definitivo, voc pode pensar em um aplicativo porta-arquivos como um repositrio de dados temporrio; isto , novos dados adicionados em um aplicativo porta-arquivos um dia sero repassados a um banco de dados central. Por exemplo, imagine que voc tenha uma empresa que venda planos de manuteno de equipamentos pesados. Voc possui muitos vendedores de planos, e deseja automatizar todo o processo de vendas e andamento dos contratos de manuteno. A soluo porta-arquivos ideal para resolver as suas necessidades. Como os vendedores precisam realizar visitas aos seus cliente para fechar novos contratos e relizar uma srie de outras tarefa referentes ao contrato do cliente visitado, um aplicativo porta-arquivos tudo o que eles precisam. Com um desses aplicativos instalados em um notebook, eles realizam novas vendas e muito mais. Aps o retorno de um vendedor, basta atualizar o banco de dados central com as novas informaes trazidas pelo vendedor. Como voc j estudou, os datasets clientes oferecem grande suporte ao processo de atualizao dos dados de maneira automtica. Este tpico introduzir o uso de datasets clientes em aplicativos tipo porta-arquivos.
Carregando dados de um arquivo ou stream Para carregar os dados de um arquivo, use o mtodo LoadFromFile de um dataset cliente. Este mtodo reque um parmetro, que o nome do arquivo que deve ser aberto. Este nome deve ser um caminho completo onde se encontra o arquivo, tal como c:\Databases\Flat\Customer.cds. Se voc sempre usa o mesmo arquivo com um dataset cliente, possvel usar a propriedade FileName para designar o arquivo. Para carregar dados de um stream, use o mtodo LoadFromStream do dataset cliente. Este mtodo requer um parmetro, que uma referncia a um objeto stream que fornecer os dados. Quando voc usa LoadFromFile ou LoadFromStream, todos os dados so transferidos para a propriedade Data do dataset cliente. As alteraes que voc fizer nos dados so armazenadas na propriedade Delta, e no afetam os dados originais em Data. Para tornar uma alterao permanente, chame o mtodo MergeChangeLog, que escreve todas as alteraes na propriedade Delta. Aps MergeChangeLog ter sido chamado, a propriedade Data conter um misto de dados existentes em Data com as mudanas que podem ser feitas. Finalmente, a propriedade Delta limpa.
Salvando dados em um arquivo ou stream
203
Quando voc chama o mtodo MergeChangeLog, os dados que voc possui esto salvos apenas em memria. necessrio, em um determinado momento, escrever as alteraes em um arquivo no disco. Esta operao pode ser feita usando o mtodo SaveToFile. SaveToFile requer um parmetro, que o nome do arquivo onde eos dados sero escritos. Se o arquivo j existe, seu contedo ser sobrescrito pelo atual do dataset cliente. Voc pode tambm salvar dados em um stream atravs do mtodo SaveToSTream. Este mtodo requer um parmetro que uma referncia ao objet stream onde os dados sero armazenados. Se voc salvar os dados em um arquivo sem haver chamado antes o mtodo MergeChangeLog e, em seguida, encerrar sua aplicao, no perder as alteraes feitas. Na prxima vez que executar sua aplicao todas as alteraes estaro ainda disponveis no log. Isto importante para dar suporte a aplicaes porta-arquivos. Nota: SaveToFile no preserva qualquer ndice criado dinamicamente em sua aplicao.
Outros datasets clientes

Com o Delphi 6, a arquitetura de datasets clientes foi expandida de forma a oferecer componentes que simplificam ainda mais a criao de aplicaes distribudas. Estes componentes podem resumir o processo de trabalho entre um dataset cliente e um provider em um nico componente. Grande parte do trabalho de configurao e conexo entre as peas de uma aplicao distribuda podem ser isolados com o uso destes componentes.
TBDEClientDataset De fato, TBDEClientDatase um dataset cliente que possui um comonente provider (TDatasetProvider) interno para recuperar os dados de um dataset BDE. Voc s pode usar TBDEClientDataset se a fonte de dados deste dataset cliente for um dataset que trabalha com a BDE. TBDEClientDataSet trabalha como um TClientDataset quando est conectado com um componente TQuery local via um provider. Ele oferece algumas das propriedades e eventos dos componentes TQuery e TdatasetProvider, de form que voc pode especificar a fonte DBE de onde os dados sero recuperados e realizar muitas outras tarefas que no estariam disponveis diretamente para um componente TClientDataset. Adiconalmente, TBDEClientDataSet oferece as seguintes vantagens: Voc pode usar TBDEClientDataSet para trabalhar com dados armazenados em arquivos ou fornececidos por um servidor de banco de dados. Isto permite a implantao de aplicativos portaarquivos com grande facilidade. Voc pode obter vantagens de todos recursos nicos implementados em TClientDataset.
TIBClientDataset TIBClientDataSet trabalha com armazenamento de dados local fornecidos por um dataset Interbase Express. Este componente um dataset cliente que usa componentes TIBDataset e TdatasetProvider 204
para transferir e aplicar atualizaes de dados. A grande vantagem do componente TIBClientDataset o fato de permitir o o acessos a datasets Interbase Express sem a necessidade de um componente provedor externo. Alm disto, TIBClientDataSet agir como um dataset cliente comum, excetuando-se o fato de acessar exclusivamente fontes de dados atravs da Interbase Express. O uso de atualizaes em cache local permite muitas vantagens, como: Voc pode usar o componente TIBClientDataSet para trabalhar com dados armazenados em arquivos em disco, assim como em um servidor de banco de dados Interbase/Firebird. Esta caracterstica permite uma fcil implementao de uma aplicao porta-arquivos. Todos os recursos e vantagens oferecidas pelo componente TClientDataset esto igualmente disponveis para TIBClientDataSet. Sua aplicao pode ser convertida muito mais facilmente para um outro mecanismo de acesso a dados, uma vez que existem grande similaridades de arquitetura entre todos os datasets clientes; os componentes TIBClientDataSet, TSQLClientDataSet e TBDEClientDataSet podem ser usados sempre da mesma maneira, apesar de acessarem fontes de dados atravs de mecaninsmos diferentes.
TIBClientDataSet trabalha como TClientDataset quando est conectado a um componente TIBDataset atravs de um provider, exceto pelo fato de tanto este dataset como o provider so alocados internamente. Contudo, TIBClientDataSet inteligente o suiciente para expor diversas propriedades, eventos mtodos destes componentes internos, de forma a oferecer-lhe grande controle sobre eles. Paralelamente ao acesso a dados via um dataset TIBDataset, TIBClientDataSet pode tambm acessar dados armazenados em arquivos no disco de maneira idntica que voc pode fazer com um componente TClientDataset.
TSQLClientDataset O componente TSQLClientDataSet um dataset cliente que usa os componentes TSQLDataset e TdatasetProvider para transferir dadose aplicar atualizaes. TSQLClientDataSet combina o mais rpido acesso e a mais fcil distribuio de um dataset unidirecional com a abilidade de edio e navegao de dados de um dataset cliente. Devido ao fato de TSQLClientDataSet possuir um componente TSQLDataset interno, TSQLClientDataSet usa a DBExpress como mecanismo de acesso a dados. Mas, TSQLClientDataSet trabalha como um dataset cliente, o que significa que ele recupera os dados de um provedor e aplica as atualizaes da maneira comum a todo dataset cliente. Assim, TSQLClientDataSet trabalha como o componente TClientDataset quando est conectado a um TSQLDataset local atravs de um provedor, excetuando-se o fato de o dataset e o provider que usa so internos. Da mesma forma que outros datasets clientes, TSQLClientDataSet oferece mecanismos para voc controlar as propriedades, eventos e mtodos destes dois componentes internos. Adicionalmente, voc pode usar TSQLClientDataSet para acessar e escrever dados em arquivos armazenados em disco. Isto permite o uso de TSQLClientDataSet para o desenvolvimento de aplicativos porta-arquivos que manipulam dados de bancos baseados em arquivos. Nota: TSQLClientDataSet no recomendado para uso em relacionamentos tipo mestre/detalhe. Ele no pode otimizar as consultas que usa para este propsito, o que resulta em um desempenho muito baixo.
205
CAPTULO 17 USANDO
PROVEDORES DE DADOS
Os componentes provedores (TdataSetProvider e TXMLTransformProvider) oferecem o mecanismo mais comum pelo qual datasets clientes podem obter seus dados. Os componentes provedores: Recebem a requisio de dados de um dataset client (ou um XML broker), transferindo os dados requisitados em um pacote de dados transfervel, e retornando os dados para um dataset cliente (ou XML broker). Esta atividade denominada provimento (providing). Recebem atualizaes de dados de um dataset client (ou XML broker); aplicam as atualizaes a um servidor de banco de dados, dataset fonte, ou um documento XML, e registram quaisquer atualizaes que no podem ser aplicadas, retornando-as a um dataset cliente para o processamento de uma reconciliao. Esta atividade denominada resoluo (resolving).
Muito do trabalho de um componente provedor acontece automaticamente. Voc no precisa escrever qualquer cdigo no provedro para criar pacotes de dados a partir de dados obtidos em datasets ou documentos XML, bem como para aplicar atualizaes. Contudo, os componentes provedores incluem um nmero de eventos e propriedades que permitem um controle mais direto de sua aplicao sobre as informaes que so empacotadas e enviadas em resposta s requisies dos clientes. Quando usar TBDEClientDataSet,TSQLClientDataSet, ou TIBClientDataSet, um provedor encapsulado internamente, e aplicao no possui acesso direto a este componente interno. Quando se usa TClientDataset ou TXMLBroker, contudo, o provedro um componente separado que voc pode usar para controlar quais informaes so empacotadas para os clientes, assim como definir as operaes de resposta nos eventos que podem ocorrer durante o processo de provimento e resoluo. Os DataSets clientes que tm provedores internos oferecem uma interface para algumas propriedades e eventos do provedor interno, mas quando for necessrio um controle maior, voc pode desejar usar um componente TClientDataset com um provedor separado. Na situao onde se usa um componente provedor separado, ele pode residir na mesma aplicao que um dataset cliente (ou XML broker), ou pode residir em uma aplicao servidora que parte de um sistema distribudo. Este captulo descreve como usar um componente provedor para controlar a interao com datasets clientes ou XML brokers.
206
Determinando a fonte dos dados

Quando voc usa um componente provedor, necessrio especificar a fonte que ele usa para obter dados que sero empacotados. Dependendo da sua verso do Delphi, voc pode especificar esta fonte atravs de um dos seguintes componentes: Se for prover os dados a partir de um dataset, use o componente TdataSetProvider. Se for prover dados de um documento XML, use o componente TXMLTransformProvider.
Usando um dataset como fonte de dados Se o provedor um TdataSetProvider, configure a sua propriedade DataSet para indicar o componente dataset que ser a fonte dos dados. Em tempo de projeto, selecione o dataset de uma lista disponvel na propriedade dataset. TdataSetProvider interage com dataset fonte usando a interface IproviderSupport. Esta interface introduzida para acesso a todos descendentes de TDataset, de forma que qualquer espcie de datasets estaro disponveis. Contudo os mtodos implementados em IproviderSupport no so mais que stubs que no fazem nada ou geram excees. As classes de datasets providas com Delphi (Datasets baseados em BDE, ADO, dbExpress, e InterBase Express) sobrescrevem estes mtodos para implementar a interface IproviderSupport em uma maneira mais usual. Datasets clientes no adicionam nada na implementao do IproviderSupport herdado, mais podem ainda ser usados como um dataset fonte, desde que a propriedade ResolveToDataSet do componente provedor esteja configurada como true.
Usando um documento XML como fonte de dados Se o componente provedor um provedor XML, configure a propriedade XMLDataFile do provedor para indicar o documento que servir de fonte. Provedores XML devem tranformar o documento fonte de dados em pacotes de dados, de forma que voc tambm deve especificar como transformar aquele documento em um pacote. Esta transformao manipulada pela propriedade TransformRead do componente provedor. TransformRead representa um objeto TXMLTransform. Voc pode configurar as suas propriedades para expecificar que transformaes fazer, e usar os seus eventos para prover um esquema personalizado de transformao.
Comunicando-se com um dataset cliente

Toda a comunicao entre um provedor e um dataset cliente ou XML broker toma lugar atravs da interface IAppServer. Se o provedor esta na mesma aplicao que o cliente, esta interface implementada por um objeto escondido gerado automaticamente para voc, ou por um componente TLocalConnection. Se o provedor parte de uma aplicao distribuda, esta a interface do mdulo de dados remoto da aplicao servidora. Muitas aplicaes no usam IAppServer diretamente, mas invocam-na indiretamente atravs das propriedades e mtodos dos datasetes clientes ou XML borker. No entanto, quando for necessrio, voc pode fazer chamadas diretas para a interface IAppServer usando a propriedade AppServer de um dataset cliente. A tabela abaixo lista os mtodos da interface IAppServer, assim como os mtodos e eventos correspondentes do componente, assim como os correspondentes mtodos e eventos dos compoentes Provider e datasets clientes. Estes mtodos IAppServer incluem um parmetro denominado Provider. 207
Em aplicaes multi-camadas, este parmetro indica o provedor na aplicao servidora com o qual o dataset cliente se comunica. Muitos mtodos tambm incluem um parmetro do tipo OleVariant chamado OwnerData, que permite a passagem de inormaes customizadas entre um dataset cliente e um provedor. OwnerData no usada comumente, mas passada em todos os manipuladores de eventos de forma que voc pode descrever cdigo que permite ao seu provedor ajustar-se s informaes personalizadas antes e aps cada chamada de um dataset cliente.
Como aplicar atualizaes com um TDatasetProvider

O componente TXMLTransformProvider sempre aplica atualizaes em um documento XML a ele associado. Ao usar um componente TdataSetProvider, contudo, voc pode escolher como as atualizaes so feitas. Por padro, quando o componente TdataSetProvider aplica atualizaes e resolve os possveis erros encontrados elel se comunica diretamente com o servidor de banco de dados usando intrues SQL geradas dinamicamente. Este apanhado tem a vantagem de que a aplicao servidora no realiza atualizaes duas vezes (primeiro para o dataset e, ento, para o servidor remoto). Contudo, nem sempe voc pode desejar este apanhado. Por exemplo, voc pode querer usar alguns dos eventos no componente dataset. Alternativamente, o datasete que voc usa pode no suportar o uso de intrues SQL (como quando se prov dados de um TClientDataset). O componente TdataSetProvider permite que voc decida quando aplicar atualizaes a um servidor de banco de dados usando SQL, ou o datasete fonte ao configurar a propriedade ResolveToDataSet. Quando esta propriedade for true, as atualizaes so aplicadas para o dataset; do contrrio, sero aplicadas diretamente no servidor de banco de dados.
Controlando as informaes em um pacote de dados

Quando voc trabalhar com um dataset provier, existem algumas maneiras de controlar qualis informaes so includas nos pacotes de dados a serem enviados para e do cliente: Especificando quais campos aparecem nos pacotes de dados; Configurando opes que influenciam os pacotes de dados; Adicionando informaes personalizadas aos pacotes de dados. Nota Estas tcnicas de controle do contedo de pacotes de dados esto disponveis apenas para dataset provider. Ao Usar TXMLTransformProvider, voc pode apenas controlar o contedo de pacotes de dados atravs de um arquivo de transformao usado pelo provedor.
Especificando os campos que sero inclusos Ao usar um dataset provider, voc pode controlar quais campos so includos no pacote de dados ao criar campos persistentes nos datasets que o provedor usa para contruir o pacote de dados. Ento, o provedor inclui apenas estes campos. Campos cujos valores so gerados dinamicamente pelo dataset 208
fonte (tais como campos calculados ou do tipo lookup) podem ser includos, mas aparecem nos datasets clientes como campos estticos e no alterveis.
Opes que influenciam os pacotes de dados A propriedade Options do dataset provider permite especificar se campos BLOB ou tabelas de detalhe (nested tables) so enviados, assim como se as configuraes das propriedades dos componentes fields do dataset fonte tambm devem ser transferidas no pacote de dados, que tipo de atualizaes so permitidas e muitas outras opes. A tabela seguinte lista os valores que podem ser includos na propriedade Option.
Valor poAutoRefresh poFetchBlobsOnDemand poFetchDetailOnDemand poIncFieldProps poCascadeDeletes poCascadeUpdates poReadOnly PoDisableEdits PoDisableInserts PoPropagateChanges PoAllowCommandText Significado O provider atualiza o dataset cliente toda vez que ele grava seus dados Campos BLOB no so includo no pacote de dados. Quando o provedor representa o mestre em uma ligao mestre/detalhe, os possveis dados do dataset de detalhe no so includos. O pacote de dados inclui propriedades (sempre que aplicvel) dos campos do dataset, tais como: Alignement, DisplayLabel, Visible, DisplayFormat, EditFormat, MaxValue etc Se o provider representa o mestre de uma ligao mestre/detalhe, automaticamente deleta os dados de detalhe quando um registro for deletado. Se o provider representa o mestre de uma ligao mestre/detalhe, automaticamente atualiza os dados de detalhe quando um registro for alterado. Indica que o dataset cliente no pode aplicar atualizaes no provider. O dataset cliente no pode alterar registros existentes. O dataset cliente no pode inserir novos registros. As mudanas feitas pelo Servidor SQL como parte de um processo de alterao so enviadas junto com o pacote de dados. Indica que o dataset cliente pode enviar comandos SQL para o provider.
Informaes personalizadas em pacotes Dataset Providers podem adcionar informaes definidas pelas aplicaes aos pacotes de dados atravs do evento OnGetDataSetProperties. Esta informao codificada como um tipo OleVariant, e armazenada sob o um nome que voc especifica. Datasets clientes podem, ento, recupera a informao usando o mtodo GetOptionalParam. Voc pode tambm especificar qual a informao includa no pacote Delta que o dataset cliente envia quando atualiza registros. Neste caso, o dataset cliente nunca pode conhecer da informao, mas o provedor pode enviar uma mensagem para si mesmo. Ao adicionar informaes customizadas no evento OnGetDataSetProperties, cada atributo individual (s vezes chamado parmetro adicional) especiifcado usando um array de dados do tipo Variant que contm trs elementos: o nome (uma string), o valor (um Variant) e um flag boolean que indica se a informao deveria ser includa no pacote Delta quando for ser aplicada um atualizao. Adicione mltiplos atributos para criar um array Variant de outros arrays Variant. Por exemplo, o seguinte manipulador de eventos OnGetDataSetProperties envia dois valores, a hora e a data e o nmero total de registros no dataset fonte. Apenas a hora e a data retornada quando o dataset cliente aplica as atualizaes:
procedure TMyDataModule1.Provider1GetDataSetProperties(Sender: TObject; DataSet: TDataset; out Properties: OleVariant); begin
Properties := VarArrayCreate([0,1], varVariant); 209
Properties[0] := VarArrayOf(['TimeProvided', Now, True]); Properties[1] := VarArrayOf(['TableSize', DataSet.RecordCount, False]); end;
Quando o dataset cliente aplica as atualizaes, a hora na qual os registros foram providos pode ser lida atravs do evento OnUpdateData do provedor: procedure TMyDataModule1.Provider1UpdateData(Sender: TObject; DataSet: TCustomClientDataSet); var WhenProvided: TDateTime; begin WhenProvided := DataSet.GetOptionalParam('TimeProvided'); ... end;
Respondendo a requisies de datasets clientes

Em muitas aplicaes multi-camadas, as requisies de dados feitas pelos clientes so satisfeitas de forma completamente automtica. Um dataset cliente requer um pacote de dados chamando o mtodo GetRecords (indiretamente, atravs da interface IappServer). Automaticamente, o provedor responde requisio, gera o pacote de dados e o envia para o dataset cliente. O provider pode editar os dados aps eles terem sido empacotados, mas sempre antes de envi-los para os clientes. Por exemplo, o provider poderia querer encriptar dados sensveis antes de envilos etc. Para editar o pacote de dados antes de envi-lo aos clientes, escreva um manipulador de eventos OnGetData.
Respondendo a atualizaes de datasets clientes

Um provedor aplica atualizaes a um banco de dados baseado no pacote de dados Delta, que ele recebe um um dataset cliente. Como com todo mtodo chamado a partir da interface IappServer, o provider tem a oportunidade de comunicar informaes de persistncia de dados e estado com o cliente antes de atualizar os dados. Esta comunicao feita usando os manipuladores de envento BeforeApplyUpdates e AfterApplyUpdates. Estas comunicaes so feitas por motivos muito variados. O mais importante deles, contudo, aplicar constries e verificar a integridade dos dados obtidos do cliente. Esta seo abordar algumas t cnicas de constrio de dados e manipulao de error oferecidas pela arquitetura de acesso distribuda presente no Delphi.
Resolvendo erros de atualizaes no provider Uma primeira informao que o desenvolvedor sempre deve Ter em mente que o aplicativo servidor sempre deve manipular as constries e erros que no exigem interao humana para serem detectadas ou manipuladas. Alm deste nvel, voc poder implementar constries de erros tanto no aplicativo cliente (usando os datasets clientes) quanto no aplicativo servidor (usando providers).
210
Se uma condio de erro detectada quando o provider tenta atualizar um registro do pacote Delta, um evento OnUpdateError ocorre. Se a aplicao servidora no pode resolver por si mesma o erro, ela guarda temporariamente uma cpia do registro que gerou o erro at que o processamento da atualizao tenha terminado. Ento, o provider retorna ao cliente para que ele possa (atravs de interao humana) resolver as atualizaes inconstritas. Este mecanismo denominado de Reconciliao de Erros e permite que voc exiba uma janela (tambm uma pgina html ou outro mecanismo) que exibir a mensagem de erro gerada pelo Servidor SQL ou pelo aplicativo servidor, bem como o conjunto dos dados no constritos. Alm disto, o usurio informado em que condio a exceo foi gerada (ao inserir, editar ou deletar dados) e um conjunto de opes possveis para que o problema possa ser solucionado. Este recurso permite que o usurio possa alterar a condio que gerou a exceo e novamente enviar o pacote corrigido ao provider.
Respondendo a eventos gerados nos clientes Os componentes provider implementam um evento de propsito geral que permite ao programador criar suas prprias chamadas, diretamente, aos providers. O evento OnDataRequest lida com dados OleVariant, o que permite uma interface suficientemente genrica para acomodar quaisquer tipos de dados e parmentos que voc precise usar para comunicar-se com um provider. Para gera um evento OnDataRequest, a aplicao cliente chama o mtodo DataRequest de um dataset cliente.
211
CAPTULO 18 - TRABALHANDO
COM O COMPONENTE
TFIELD
Associadamente aos datasets, o Delphi nos oferece uma grande quantidade de componentes que lidam com os campos de dados (colunas) de uma tabela ou consulta. Tais componentes so denominados fields (campos) e descendem da classe bsica Tfield. Descendentes de Tfield representam colunas individuais em um datasets. Voc nunca usa um componente Tfield diretamente em suas aplicaes. Por padro quando voc coloca um dataset em sua aplicao e o abre, o Delphi automaticamente assinala um descendente de Tfield especfico de um tipo de dado para representar cada coluna na tabela do banco de dados. Em tempo de projeto, voc pode sobrescrever campos criados dinamicamente ao invocar o editor de campos para criar campos perssistentes que substituem os criados de forma automtica. Este captulo descreve as propriedades, eventos e mtodos comuns para os objetos Tfield e seus descendentes.
212
A arquitetura dos componentes fields

Como todos os componentes Delphi de acesso a dados, componentes field no so visuais. Estes componentes tambm no so diretamente visiveis em tempo de projetos; ao contrrio, eles so associados com componete dataset e possibilitam o acesso de controles ligados a banco de dados aos campos de um dataset. Falando de forma geral um componente Tfield espcifico representa as caractersticas de uma nica coluna em um dataset, assim como os seu tipo de dado de tamanho. Ele tambm representa as caractersticas de exibio de um campo, tais como alinhamento, formato e formato de edio. Finalmente, como voc rola de registro em registro em um dataset, um componente field tambm abilita a visualizao e a mudana do valor para aquela coluna no registro corrente. Por exemplo, um componente TFloatField tem quatro propriedades que afetam diretamente a aparncia dos seus dados: Alignment DisplayWidth DisplayFormat EditFormat.
A VCL e a CLX oferecem muitos descendentes de TField especializados na manipulao de um tipo especfico de dado. A tabela abaixo informa os componentes fields mais comuns que voc sempre usar em suas aplicaes.
Descrio um campo ADT (Abstract Data Type) um campo agregado em um Dataset Client um campo array aceita nmeros inteiros entre a faixa de -2 147 483 648 para 2 147 483 647.usado para campos Paradox cujos valores so automaticamente incrementados TBCDField aceita nmeros reais com um nmero de decimais fixo, at 18 dgitos, a faixa depende do nmero de decimais TFMTCBCDField Representa um campo BCD (binary-code decimal) TBooleanField aceita valores true ou false TBlobField aceita dados binrios, o limite terico mximo 2 GB TBytesField aceita dados binrios, o limite terico mximo 2 GB TCurrencyField aceita nmeros reais entre a faixa de 5.0 * 10 -324 a 1.7 * 10308. Usado em campos Paradox com dois digitos decimais de preciso TDatasetField aponta para um outro objeto Dataset TDateField aceita valores de datas TDateTimeField Aceita valores de data e hora ao mesmo tempo TfloatField aceita nmeros reais entre a faixa de 5.0 * 10 -324 a 1.7 * 10308. TBytesField Dados binrios. Limite mximo de bytes: 255 TIntegerField aceita nmeros inteiros entre a faixa de -2 147 483 648 para 2 147 483 647. TLargeIntegerField aceita nmeros inteiros entre a faixa de -263 a 263. TMemoField Aceita texto em muitas linhas. Limite terico mximo: 2 GB. TNumericField Aceita nmeros reais na faixa entre 3.4 * 10-4932 e 1.1 * 104932. TReferenceField Trabalha com um ponteiroa um objeto de banco de dado relacional. TSmallIntField Aceita nmeros inteiros na faixa entre 32768 e 32768 TStringField Dados string. Tamanho mximo em bytes: 8192. TTimeField Aceita valores de horas. TVarBytesField Dados binrios. Tamanho mximo de bytes: 255. TWordField Aceita nmeros entre a faixa de 0 e 65535. TIBStringField Dados string de servidor Interbase/Firebird. Pode exceder 8192 bytes. TGraphicField Trabalha com dados grficos, como imagens. TInterfaceField Trabalha com ponteiros para interface IUnKnown de objetos COM. TDispatchField Trabalha com ponteiros para interface IDispatch de objetos COM. TIBBCDField Trabalha com nmeros reais como valores monetrios do Interbase. TCharField Trabalha com dados tipo Char TGUIDField Trabalha com GUIDs do Windows. TWideStringField Trabalha com widestrings. TVariantField Trabalha com dados variant. Componente TADTField TAggregateField TArrayField TAutoIncField
213
Criando um novo objeto TField Objetos fields persistentes so cirados com o Fields editor, que prove uma maneira eficiente de se ler e configurar as propriedades destes componentes. O uso de componentes fields persistentes garante que a cada vez que sua aplicao executada ela sempre usa e exibe as mesmas colunas, na mesma ordem ainda que a estrutura fsica do banco de dados aos quais se referem tenha sido alterado. Assim, controles conscientes de dados (data-aware controls) podem trabalhar sempre da forma esperada. Se uma coluna na qual um field persistente baseado deletada ou modificada, o Delphi gera uma excesso imediatamente antes de voc ascesar esta coluna. Para criar fields persistentes para um dataset preciso : Coloque um dataset em um formulrio ou mdulo de dados; Configure adequadamente as propriedades do dataset; D um duplo clique no dataset para invocar o Fields editor;
Para inserir os objetos fields no editor acesse o menu de contexto do editor e escolha o item Add Fields. Na lista de campos disponveis que aparece ento, selecione aqueles que deseja criar. Os fields inseridos so fields persistentes, isto , objetos declarados e criados em tempo de projeto com os quais voc pode trabalhar no Object Inspector como qualquer outro componentes.
Campos calculados Um campo calculado exibe valores calculados em tempo de execuo atravs de um manipulador de eventos OnCalcFields de um dataset. Por exemplo, voc poderia criar um campo tipo string que exibe valores concatenados lidos de outros campos. Para criar um field calculado, acesse o menu de contexto do Fields Editor e escolha o item New Field. Na caixa de dilogo que aparece entre com o nome do campo a ser criado e escolha o tipo de dado que o campo calculado ir manipular. Observe que nem todas as opes presentes nesta caixa de dilogo estaro disponveis quando voc determina um tipo de dado em particular. Agora voc precisa escrever algum cdigo no manipulador de eventos OnCalcFields do dataset que contm o campo calculado. DNo fragmento de cdigo que segue voc ver um campo calculado que exibe a idade de um contato comercial a partir de um campo persistente que contm a data de nascimento do contato: procedure TDM.table1OnCalcFields (Sender: Tobject); begin Table1age.Value := Now - Table1Datanasc.Value; end; Campos calculados devem sempre serem usados quando voc deseja exibir algum dado que redunda de calculos sobre outros dados fisicamente existentes nas tabelas de seu banco de dados. Se voc est trabalhando com um dataset client, voc pode tambm criar um campo calculado internamente (InternalCalc Field). Voc o cria exatamente da mesma forma que um campo calculado comum. Para datasets clients a significativa diferena entre estes tipos de campos calculados que os valores calculados para um internalCalc field so armazenados como parte dos dados de um dataset client.
214
Campos Lookup Um campo lookup um objeto read-only, que exibe valores em tempo de execuo baseados num critrio de pesquisa que voc especifica . Na sua forma mais simples, um campo lookup passa o nome de um campo existente em uma pesquisa, e retorna um valor correspondente proveniente de outro campo em um outro dataset. Por exemplo, considere um cadastro de endereos de clientes que possua as tabelas clientes e estados. A primeira tabela armazena os dados dos clientes de sua empresa, como nome, endereo, cep, ect. A segunda tabela armazena os nomes de todos os estados da federao. O campo codUF da tabela de clientes faz referncia a um campo homnimo na tabela de estados. Um campo lookup pode exibir, dentro da tabela de clientes, o nome do estado a partir dos dados do campo codUF. Os campos lookup sao definidos a partir da relao entre dois campos, e no exigem qualquer codificao para funcionarem de maneira adequada.
Campos Agregados Um campo agregado exibe valores a partir de dados agregados em um dataset client. Dados agregados so calculos que sumarizam os dados em um conjunto de registros. Para criar um campo agregado na caixa de dilogo New Field: Escolha um nome para o campo Escolha um tipo de dado que o campo manipular Selecione a opo Aggregate para indicar que deseja criar um campo agregado
Coloque a expresso de calculo para o campo agregado criado em sua propriedade ExprText. Desde de que um TAggregateField persistente seja criado, um controle ligado a dados pode exibir normalmente os seus valores.
Configurando propriedades de TField

Voc pode configurar o conjunto de propriedades e eventos existentes para os componentes Fields persistentes em tempo de projeto. As propriedades destes componentes controlam a forma como um
Figura O editor de propriedades Fields Editor com um campo selecionado.
campo exibido em um controle, por exemplo em um TDBgrid, ou se seus valores podem ser 215
alterados. Os eventos de objetos fields controlam a forma como os dados so tranferidos, alterados ou validados. Para editar as propriedades de um objeto TField, selecione-o no Fields Editor e acesse o Object Inspector. O Fields Editor um editor de propriedades de objetos muito simples. Consiste, basicamente, de um janela constendo a lista de componentes fields associados a um dataset. Ao selecionar um membro desta lista, todos as suas propriedades e eventos podem ser acessadas. Para inserir novos componentes fields, use o menu de contexto do Fields Editor. A tabela seguinte sumariza as propriedades de exibio que podem ser editadas:
Propriedade Alignment DiplayWidth DisplayFormat EditFormat ConstraintErrorMessage Currency DisplayLabel EditMask FieldKind FieldName HasConstraints ImportedConstraints Index LookupDataset LookupKeyFields LookupResultField MaxValue MinValue Name Origin Precision ReadOnly Size Visible Descrio Especifica como o dado ser alinhado em um contole: esquerda, centralizado ou direita. Especifica o nmero de dgitos que sero exibidos. Determina a formatao dos dados a serem exibidos. Determina como exibir a formatao dos dados durante a sua edio. Texto a ser exibido quando houver uma violao de uma constrio. Se for deninido como True, formata o campo com formato de valores monetrios. Determina o nome da coluna em um controle TDBGrid. Cria uma mscara que formatar a entrada de dados em um controle. Especifica o tipo do field. Especifica o nome da coluna na tabela ao qual o field se refere. Indica se existem constries aplicadas ao field. Especifica uma cosntrio importada de um servidor SQL. Especifica a ordem do field no dataset. Especifica o dataset a ser usado pelo field como fonte de dados lookup. Especifica o field do dataset a ser usado como fonte pesquisa de um field lookup. Especifica o field do dataset a ser usado como dados exibido de um field lookup. Determina o valor mximo a ser aceito em fields numricos. Determina o valor mnimo a ser aceito em fields numricos. Indica o nome do componente field Especifica o nome do campo como ele aparece no banco de dados. Especifica o nmero de dgitos significativos em campos numricos. Indica se os dados do field podero ser alterados ou no. Especifica o nmero mximo de caracteres que podem ser exibidos ou editados. Determina se o field ser visvel em um controle TDBGrid ou no.
Note que nem todas estas propriedades esto disponveis para todos os componentes fields. Por exemplo, um componente TStringField no tem as propriedades Currency,MaxValue, ou Displayformat, e um componente TFloatField no tem a propriedade Size. Enquanto o propsito de muitas propriedades se encerra em si mesmas, outras propriedades, tais como Calculated, requerem programao adicional para se tornarem usuais. Outras, tais como DisplayFormat, EditFormat, e EditMask, so interrelacionadas; suas configuraes devem ser coordenadas.
Conjuntos de atributos e mscaras A propriedade EditMask prov uma maneira de controlar o tipo e a faixa de valores que um usurio pode entrar em um controle associado com os componentes TStringField,TDateField, TTimeField, e TDateTimeField. Voc pode usar mscaras existentes, ou ento criar as suas prprias mscaras. A maneira mais fcil pra executar estas tarefas atravs do Input Mask editor. possvel, contudo, editar manualmente uma mscara na propriedade EditMask de um Tfield. Este editor permite criar e editar um formato de mscara. Voc pode textar este novo formato a fim de verificar se trabalha na forma desejada.
216
O Delphi tambm prov rotinas de formatao inteligentes chamadas automaticamente para os componentes TFloatField, TCurrencyField, TIntegerField, TSmalllnField, TWordField, TDateField, TDateTimeField e TTimeField. Para usar estas rotinas voc no precisa fazer nada. A tabela abaixo mostra as funcionalidades destas rotinas.
Rotina FormatFloat FormatDateTimer FormatCurr Usada por... TFloatField, TCurrencyField TDateField, TTimeField, TDateTimeField TCurrencyField
Apenas propriedades de formatao apropriadas para o tipo de dado de um componente Field esto disponveis para um dado componente. As convenes de formatao para datas, horas, moedas e valores numricos so baseadas nas propriedades de configuraes regionais no Painel de controle dos sistemas operacionais Windows. Por exemplo, usando as configuraes padro para o Brasil, uma coluna TFloatField com a propriedade Currency configurada para True, configura a propriedade DisplayFormat para o valor 1234,56 para R$ 1234,56, enquanto a propriedade EditFormat 1234,56. Em tempo de projeto ou execuo, voc pode editar as propriedades DisplayFormat e EditFormat de um componente Field afim de sobrescrever as configuraes de exibio padro para este campo. Da mesma forma, possvel escrever manipuladores de eventos OnGetText e OnSetText para executar formataes customizadas pra um componente field.
Figura O editor de mscaras para objetos fiels.
Manipulando eventos
Como muitos componentes, os descendentes de TField possuem manipuladores de eventos a eles associados. Ao escrever um desses manipuladores, voc pode controlar eventos que afetam a entrada de dados nos fields ligado a um controle. A tabela seguinte lista os eventos dos componentes fields.
Evento OnChange OnGetText OnSetText OnValidate Descrio Disparado quando o valor do componente field muda. Disparado quando do componente field retornado ou editado. Disparado quando o valor do componente field atribudo. Disparado quando o valor do componente field mudado e precisa sofrer validaes.
Os eventos OnGetText e OnSetText so primariamente usuais para programadores que querem realizar formataes customizadas que vo alm daquelas fornecidas automaticamente pelos componentes fields. O evento OnChange usual para para possibilitar a execuo de tarefas especficas junto a controles ligados a dados, tais como os processos de abilitao e desabilitao de controles e menus de 217
navegao de dados. O evento OnValidate til quando se quer controlar a validao da entrada de dados em sua aplicao antes de se retornar os valores para um servidor de banco de dados.
Mtodos de componentes fields

Os mtodos dos componentes fields disponveis em tempo de execuo permitem-lhe converter valores de um tipo de dado para outro, enviar o foco para um determinado controle etc. O controle de foco dos controles associados a componentes fields importante quando sua aplicao executa uma validaao orientada a registro em um evento de datasets, tais como OnBeforePost. A validao pode ser executada em um componente field independentemente do controle a ele associado possuir o foco de entrada. Neste tipo de validao, a idia bsica a de que quando a validao dos dados de um field falhar, o foco de entrada seja direcionado para o controle associado ao field para que o usurio possa entrar com as correes. Isto feito atravs do mtodo FocusControl dos componentes field. Este mtodo transfere o foco de entrada para o primeiro controle no formulrio que estiver associado ao componente field. Um manipulador de eventos deveria chamar um mtodo FocusControl de um campo antes da validao do compo. O fragmento de cdigo abaixo ilustra como chamar FocusControl para o field company da tabela customers:
CustomersCompany.focusControl; A tabela que segue lista alguns mtodos de componentes field e seus usos. Para uma referncia completa de todos os mtodos disponveis em TField, consulte a ajuda do Delphi.
Mtodo AssignValue Clear GetData IsValidChar SetData Descrio Atribui um valor para um componente field usando rotinas automticas de converso. Limpa o valor de um componente field, atribuindo-o o flag null. Retorna dados no-formatados do field. Determina se um caracter digitado em um controle permitido para o componente field. Atribui dados no-formatados ao componente field.
Converses de valores de campos

Funes de converso trabalham convertendo dados de um tipo para outro tipo. Por exemplo, a funo AsString converte valores numricos e Boolean para uma representao no formato string. Os componentes field possuem muitas funes de converso, as quais tero grande utilidade no desenvolvimento de suas aplicaes. A tabela seguinte exibe as principais funes de converso que esto disponveis para diversos descendentes de TField.
AsVariant AsString AsInteger AsFloat AsCurrency AsDateTime AsBoolean
TIntegerField TSmallintField TWordField TFloatField TCurrencyField TBCDField TDateTimeField TDateField TTimeField TBooleanField TBytesField
218
TVarBytesField TBlobField TMemoField TgraphicField TStringField
Observe que o mtodo AsVariant recomendado para converses entre todos os tipos de dados. Em alguns casos converses nem sepre so possveis. Por exemplo, AsDateTime pode ser usado para converter um formato string, date, time, ou datetime apenas se o valor em string for reconhecvel para uma formatao datetime. Uma tentativa falha de converso dispara uma exceo. Em outros casos, a converso possvel, mas os resultados da converso no so sempre intuitivos. Por exemplo, o que significa converter um valor TDateTimeField em um formato Float? O mtodo Asfloat converte a poro referente a data de um field para um nmero de dias a partir de 12/31/1899, e converte a poro referente a horas para uma frao de 24 horas. A tabela abaixo lista as converses que produzem resultados especiais.
Converso String para Boolean Float para Integer DateTime para Float Boolean para string Resultado Converte True, False, Yes e No para boolean. Outros valores geram excees Arredonda valores decimais. Converte a data para nmero de dias a partir de 12/31/1899 e a hora para uma frao de 24 horas. Converte qualquer valor boolean para True ou False.
Em outros casos as converses so de todo imposveis. Nestes casos tentativas de converso tambm disparam excees. Voc usa uma funo de converso como usaria qualquer mtodo de um componente. As converses sempre ocorrem antes de um assinalamento ser feito. Por exemplo, o fragmento seguinte converte o valor de CustomersCustNo para uma string e assinala a string para a propriedade text de um controle Tedit: Edit1.Text := customerscustNo.AsString;
Acessando valores de campos

Existem muitas maneiras de voc acessar programaticamente os valores de componentes fields. Os valores so lidos sempre acessando a propriedade Value dos componentes field. Uma diferena de abordagem essencial colocada quando acessamos componentes fields criados dinamicamente ou, por outro lado, acessamos dados de componentes fields persistentes. Para componentes fields criados dinamicamente, o compilador no pode saber qual o descendente de tfield dever ser criado para representar uma determinada coluna. Ento, tambm no poder saber qual o tipo de dado que este descendente manipula, e usar sempre o tipo de dado Variant na propriedade Value do componente field. Como os componentes fields persistentes esto declarados em tempo de projeto, o compilador sabe determinar quais caractersticas suportam e os tipos de dados que cada um deles pode manipular. Conseqentemente, uma referncia ao valor de um field persistente se basear no tipo de dado que este suporta. Por exemplo, os fragmentos de cdigos que seguem ilustram as situaes discutidas. var I: integer;
219
I := Tabela1.Fields.Fields[1].Value; Neste caso, value um variant que ser atribudo a uma varivel do tipo integer. var I: integer; I := CustNumber.Value; Mas, agora, o compilador sabe que a propriedade value do tipo inteiro, pois o cdigo se refere a um componente field persistente (CustNumber) que manipula dados do tipo integer. Neste exemplo, o componente CustNumber um TintegerField, o que determina o tipo de dado integer da sua propriedade Value.
Acessando valores de componentes field Voc pode acessar os valores de um componente field atravs do Dataset ao qual o componente field est associado ou diretamente, caso o componente field seja persistente. A nica forma de acessar componentes field dinamicamente criados atravs de propriedades do Dataset a ele vinculado. Todo dataset tem uma propriedade denominada Fields, que pode ser usada para acessar tanto componentes fields persistentes como dinmicos. Para usar a propriedade Fields, voc deve saber a ordem dos componentes fields de um dataset. Usa-se nmeros ordinais para enumerar a ordem do componente field, sempre iniciando-se com 0. Como discutido acima, os valores devem ser convertidos para um tipo de dado desejado, uma vez que a referncia em tempo de projeto propriedade value de componentes fields dinmicos sempre retorna um variant. Por exemplo, o fragmento que segue copia o valor do primeiro field de um dataset para um controle TEdit, convertendo-o para o formato string. Edit1.Text := Dataset1.Fields[0].AsString; o que idntico a Edit1.Text := Dataset1.Fields.Fields[0].AsString; Outra maneira de acessar um componente field atravs do nome da coluna da tabela do banco de dados que o componente representa. Este mtodo muito til, mas voc precisa conhecer o nome da coluna para us-lo. Os mtodos de converso tambm devem ser usados de maneira idntica ao mencionado acima. Veja um exemplo:
Edit1.Text := Dataset1.FieldByName(CustNumber).AsString;
Conferindo o valor corrente de um field Se sua aplicao usa um dataset client ou administra um dataset que a fonte para um componente Provider em uma aplicao servidora, voc~e pode usar a propriedade CurValue para examinar o valor de um campo. A propriedade CurValue representa o valor atual de um componente field, incluindo as mudanas feitas por outros usurio do banco de dados. Tipicamente, um aplicao multi-camadas
220
apresenta os valores atuais de campos quando voc tenta atualizar dados de campos que j foram alterados aps voc recuper-lo e edit-los.
Constries de componentes fields

Constries so regras que devem ser cumpridas para que valores de um banco de dados estejam ntegros, do ponto de vista das regras comerciais implementadas. O Delphi implementa diversos tipos de contries em nveis diferentes, para cada uma das necessidades especficas de suas aplicaes. Esta seo discute constries implementadas em componentes fields.
Constries de servidores SQL Os componentes field podem usar constries vindas de um servidor SQL remoto. Todas as constries so regras ou condies que impem um limite no escopo ou faixa de valores que um campo de uma tabela pode armazenar. Muitos servidores de banco de dados SQL usam constries para impor possveis valores aceitveis em uma coluna. Poe exemplo, uma coluna em uma tabela pode no permitir valore nulos (NULL), podem requer que os dados sejam nicos em uma determinada coluna etc. Em vez de voc reimplementar todas estas constries em seus aplicativos clientes, o Delphi oferece a propriedade ImportedConstraints para propagar as constries de um servidor localmente. Estas constries limitam os valores de entrada de alguma maneira, como em x > 0 and X <100 Para adicionar constries nos componentes fields, use a propriedade CustomConstraint, que so implementadas adicionalmente s constries importadas de um servidor SQL. Se as constries de um servidor so modificadas, os valores da propriedade ImportedConstraint tambm so alterados, mas as constries personalizadas no sofrem qualquer alterao.
Constries personalizadas Adicionalmente a constries de servidores SQL, suas aplicaes podem criar e usar constries personalizadas que so locais a sua aplicao. Como tais, constries personalizadas podem ser usuais ao oferecer uma pr-validao da entrada de dados, mas no podem ser aplicadas em dados recebidos ou enviados para um servidor. Para criar constries personalizadas, configure a propriedade CustomConstraint para especificar uma condio de constrio, e escreva uma mensagem de erro a ser exibida ao usurio quando houver violao da constrio na propriedade ConstraintErroMessage. Constries personalizadas tambm so strings SQL, tais como X > 0 and x < 100 O nome usado para se referir ao valor do campo pode ser qualquer string que no seja uma palavra reservada da linguagem SQL. O nome usado para referir-se ao valor do campo pode ser qualquer istring que no uma palavra reservada da SQL.
221
Descendentes complexos de TField

Alm dos componentes fields que manipulam tipos de dados simples (como um tipo inteiro ou string), existem descendentes que manipulam tipos de dados complexos , tais como arrays ou datasets. Este tpico introduzir o uso dos descendentes conplexos de TField.
Usando campos de objetos Os descendentes de TObjectField suportam tipos de campo ADT (AbstractDataType), array, Dataset e reference. Todos esses tipos contem referencias a campos filhos ou outros datasets. Fields ADT e reference so mapeados para campos que contem outros campos filhos, que eles mesmo podem ser de qualquer tipo escalar ou objeto. Um array field contem um array de campos filhos, todos do mesmo tipo. Filds dataset e reference so mapeados para campos que acessam outros datasets, e um field reference armazena um ponteiro (reference) a outro objeto persistente. A tabla abaixo oferece uma descrio simples de alguns fields complexos.
Componente TADTField TArrayField TDatasetField TReferenceField Descrio Representa um campo ADT (Abstract Data Type). Representa um campo array. Representa um campo que contm uma referncia a um dataset embutido. Representa um campo REF, um ponterio para um ADT.
Quando voc adiciona algum destes objetos a um dataset, campos de objetos persistente so adicionados altomaticamente para voc, e propriedade ObjectView do dataset atribuido o valor true. Isto instrui aos campos para serem armazenados hierarquicamente, em vez de isoladamente.
Trabalhando com fields ADT ADTs so tipos definidos pelo usurio criados no servidor, e so similares a estruturas ( Structures). Um ADT pode conter muitos tipos de campos escalares, array fields, referencefields e datasets. Existe uma variedade de mecanismos para acesssar os dados em fields ADT. Os seguintes exemplos assinala um valor de um campo filho para um TEdit chamado CityEdit e usa a seguinte estrutura ADT: Address Street City State zip E os seguintes campos persistentes criados para o componente Ttable chamado Customer.
CustomerAddress: TADTField; CustomerAddrStreet: TStringField; CustomerAddrCity: TstringField; CustomerAddrState: TstringField; CustomerAddrZip: TStringField;
222
A linha de cdigo abaixo usa um field persistente e demonstra o mtodo recomendado para acessar dados em fields ATD. CityEdit.Text := CustomerAddrCity.AsString; Ou, de uma maneira um pouco diferente. CityEdit.Text := Customer.FieldByName (Address.City).AsString; Existem ainda outros mecanismos de acesso a dados em fields ADT como, por exemplo o uso da propriedade fieldvalues.
Trabalhando com TArray Field Um Tarrayfield consiste de um conjunto de fields do mesmo tipo. Os tipos podem ser escalares (como float ou string) ou no escalares (um ADT), mas TarrayField de arrays no permitido. Existe uma variedade de maneiras de acessaros dados em um TarrayField, o seguinte exemplo preenche um TListBox com todos os elementos no nulos de um array:
var OrdeDates: TArrayField; I: Integer; begin for I:= 0 to OrderDates.Size - 1 do begin if OrderDates.Fields [I]. Isnull then Break; OrderDateListBox.Items.Add(OrderDates [I]); end; end; Os exemplos seguintes assinalam um valor de um campo filho a um Tedit chamado TelEdit, e usam o array TelNos_Array, que o sexto elemento de um array de strings. Os seguntes fields persistentes, criados para o TTable Customer, so usados no exemplos
CustomerTelNos_Array: TArrayField; CustomerTelNos_Array0: TStringField; CustomerTelNos_Array1: TStringField; CustomerTelNos_Array2: TStringField; CustomerTelNos_Array3: TStringField; CustomerTelNos_Array4: TStringField; CustomerTelNos_Array5: TStringField; Esta linha de cdigo usa um field persistente e assinala o seu valor para o TEdit.
TelEdit.Text := CustomerTelNos_Array0.AsString;
Os fragmentos de cdigo abaixo requerem que a propriedade ObjectView dos datasets tenham um valor True. Voc pode acessar o valor de campos filho atravs da propriedade FieldValues do dataset. FieldValues aceita e retorna um tipo variant, de maneira que ele possa manipular e converter campos de qualquer tipo. Por exemplo,
223
TelEdit.Text := TArrayField(Customer.FieldByName('TelNos_Array')).FieldValues[1]; Que o mesmo que
TelEdit.Text := TArrayField(Customer.FieldByName('TelNos_Array'))[1];
224
CAPTULO 19 - CRIANDO
UMA APLICAO
DESKTOP
Uma aplicao desktop usa um banco de dados local para obter e armazenar informaes. Existem muitos bancos de dados locais disponveis atualmente, como MS Acess e Paradox, e muitas aplicaes simples podem ser desenvolvidas satisfatoriamente sobre a base desktop. Uma caracterstica dos bancos de dados locais a sua velocidade, uma vez que todo o processo de acesso e transferncia de dados realizado em um nico computador. Com Delphi, voc pode desenvolver aplicativos que acessam bancos de dados locais usando a BDE, ADOExpress ou datasets clientes. Usando datasets clientes, em muitos casos voc desenvolver um aplicativo multi-camadas, e no um desktop. Contudo, ainda assim possvel desenvolver desktops com datasets clientes como TBDEClientDataset. Para o desenvolvimento de desktops, a Borland recomenda o uso da BDE, que um middleware que possui muitos recursos avanados para o trabalho com bancos locais, e suporta uma grande quantidade de bancos sisponveis hoje em dia. Contudo, existem casos onde a opo por ADO pode ser considerada muito seriamente. O caso tpico se sua aplicao ter de acessar bancos de dados MS Acess. A tecnologia ADO oferece um grande suporte (nativo a nvem do sistema operacional) a este banco de dados, e voc conhecer grandes recursos disponibilizados por provedores ADO para acesso a MS Acess. Por outro lado, a ADOExpress oferece um suporte completo ao desenvolvimento de aplicativos que usam ADO. Por estas razes, usaremos ADOExpress acessando um banco MS Acess durante o desenvolvimento de um aplicativo de exemplo. Este captulo ilustrar tambm as necessidades inerentes ao desenvolvimento de aplicativos desktops.
225
Projeto de aplicao Desktop

Desenvolveremos agora um aplicativo desktop de exemplo, usando MS Acess como banco de dados local. Durante este tpico voc conhecer diversos aspectos a serem considerados no incio do desenvolvimento de um aplicativo que acesse bancos de dados locais. Bancos de dados locais Bancos de dados locais so aqueles que no possuem um mecanismo de gerenciamento de acesso, transaes e manuteno mais complexos, conhecidos como servidor de dados. Os servidores de dados (SGDB) so muito sofisticados e usam a linguagem SQL como mecanismo de acesso e manuteno dos dados. Voc pode usar, limitadamente, a linguagem SQL para acessar bancos de dados locais, mas este trabalho sempre feito por um middleware, como a BDE. Uma caracterstica fundamental para a compreenso de como funcionam os bancos de dados locais a maneiro como os dados so armazenados e recuperados: bancos locais so orientados a registros e tabelas. Uma tabela um conjunto de colunas de tipos de dados especficos. Um registro uma linha de uma tabela contendo as colunas a ela pertencentes. Bancos locais trabalham com o gerenciamento de acesso de forma a proibir o acesso a registros que so editados por um usurio. Este comportamento denominado travamento pessimista. Embora, os diversos bancos locais possam diferir quanto ao nvel de travamento pessimista (travamento a nvel de banco, tabela, coluna ou registro), no so capazes de oferecer um gerenciamento completo de acessos concorrentes de usurios. Esta caracterstica explicada pelo fato de os bancos locais terem sido desenvolvidos para acesso de apenas 1 usurio, sem quaquer concorrncia aos dados. Recursos como transaes, triggers etc no existem em bancos locais, mas voc pode implementar um funcionamento limitado de transaes em alguns bancos gerenciados pela BDE ou ADO. Voc pode construir aplicativos rpidos e eficientes acessando bancos de dados locais, como Paradox, MS Acess ou dBase, mas ter muitos problemas se desejar oferecer suporte multi-usurio real, tanto quanto ao acesso a dados como no uso de seu aplicativo. Apesar disto, um banco de dados local pode ser uma soluo eficiente em muitos casos.
Usando ADOExpress como mecanismo de acesso A BDE oferece um suporte completo ao trabalho com bancos de dados locais. O que mais diferencia a BDE da ADO, do ponto de vista da disponibilidade de acessos a bancos, o fato de a BDE oferecer um suporte completo a muitos bancos de dados, enquanto, por padro, a ADO suporta um nmero menor. claro que voc pode instalar novos drivers OLEDB que permitiro um acesso a muitos outros bancos, mas estes drivers no esto automaticamente disponveis como ocorre com a BDE. A ADO, contudo, pode possuir vantagens atraentes sobre a BDE em determinados aspectos e circunstncias. Particularmente, se voc vai desenvolver uma aplicao desktop que acessar MS Acess, considere seriamente o uso de tecnologia ADO em suas aplicao. ADOExpress oferece um mecanismo requintado de acesso a bancos de dados MS Acess atravs de um provedor OLEDB da Microsoft que instalado automaticamente com o sistema operacional Windows 98 ou superiores. O melhor de tudo que ADOExpress disponibiliza suporte ao desenvolvimento de bancos de dados da mesma maneira a qual voc est acostumado, usando a BDE. Como ser demonstrado ao longo deste captulo, voc no necessitar reaprender nada sobre acesso a bancos de dados, principalmente devido ao fato de tantos os datasets ADOExpress como os BDE possuirem uma herana comum de TDataset. Voc tambm deve considerar o fato de ADOExpress disponibilizar datasets muito semelhantes a 226
TTable ou TQuery, com os quais voc j se acostumou. Os componentes TADOTable e TADOQuery trabalham de forma semelhantes aos semelhantes que usam BDE, o que facilitar ainda mais todo o exerccio de aprendizagem.
Modelo de dados Para o exemplo a ser desenvolvido, utilizaremos o banco Acompanhamento de projetos 2000.MDB, que acessado atravs do arquivo com o mesmo nome. Por padro, o endereo deste arquivo o seguinte: C:\Delphi Basico\Capitulo18\Acompanhamento de projetos 2000.mdb Este um banco MS Acess 2000, que objetiva guardar dados sobre o acompanhamento financeiro de projetos de pesquisa e desenvolvimento de energias alternativas. Na imagem que segue, voc pode observar o modelo de relacionamento entre as entidades do banco. Modelo exemplo desktop.gif
Iniciando o desenvolvimento do aplicativo

Neste tpico sero vistos os primeiros passos no desenvolvimento do aplicativo, que consistem na montagem da unidade principal do projeto, e na estruturao de um mdulo de dados para o projeto.
Criando um novo projeto Voc sempre comea o desenvolvimento de um aplicativo em Delphi da mesma maneira: criando um novo projeto de desenvolvimento. No nosso exemplo, ser o projeto de um aplicativo GUI comum, no uma dll ou um aplicativo console. Como o Delphi 6 permite a criao de aplicativos Windows ou Linux, teremos, inicialmente, de decidir qual a biblioteca de componentes que iremos usar, a VCL e a CLX. No nosso caso, a escolha muito simples: s faz sentido criar um aplicativo Windows, pois bancos de dados MS Acess no existem no mundo Linux. O mesmo se pode dizer da tenologia ADO que usaremos. Tendo sido decidido isto, basta acessar o menu File | New | Application para iniciar um aplicativo GUI do Windows. Ao fazer isto, tudo o que voc tem um formulrio com sua unidade de cdigo e a unidade de projeto do aplicativo (voc pode ver o seu contedo acessando Project | View Source) chamada Project1. Salve os dois clicando no boto Save All. O nome do executvel do aplicativo ser o nome dado unidade de projeto (.dpr). Evindentemente voc pode dar qualquer nome a estas unidades, mas ns chamaremos a unidade deste primeiro formulrio Main.pas e o projeto como AcomProj.dpr. A unidade Main.pas contm o 227
formulrio criado, que o principal da aplicao. Antes de mais nada, ajuste as propriedades deste formulrio conforme se pode ver na tabela abaixo:
Propriedade Name Caption Position ShowHint Valor FrmMain Acompanhamento de projetos PoScreenCenter True Significado D um nome ao objeto TForm que a janela principal do aplicativo. D um ttulo janela principal do aplicativo. Determina que a janela aparecer no centro da tela do computador Determina os hints dos controles dos aplicativos da janela sero exibidos.
A janela principal de um aplicativo GUI aquela que, quando fechada, encerra a execuo da aplicao. nela que so inseridos a maioria dos controles gerais de acesso s funcionalidades dos aplicativos, tais como menus, barras de ferramentas, botes etc. Embora nem sempre seja assim, normalmente a janela principal do aplicativo a primeira a ser criada na memria e a ltima a ser dele destruda. na janela Project Options que voc determina qual ser a janela principal de sua aplicao; basta selecion-la na lista das janelas disponveis em seu aplicativo. Acesse a janela Project Options atravs dos menus Project | Options. Na pgina Application desta janela, voc pode tambm digitar um ttulo para sua aplicao, bem como escolher o cone que ela usar. No Windows, o ttulo de um aplicativo aquele que aparece na barra de tarefas do Windows quando ele executado. Para o nosso exemplo, escolha um cone que lhe agradar e escreva algum ttulo sugestivo que ser exibido da barra de tarefas. Se voc compilar e executar o aplicativo (F9), ver que j temos um programa; ele no faz nada de til, mas um programa Widows.
Mdulos de dados Antes de prosseguirmos o trabalho com a janela principal, iremos voltar nossas atenes para um novo elemento que ser adicionado no aplicativo: um mdulo de dados. O que um mdulo de dados? Este objeto um container para outros objetos no-visuais, e permite um acesso centralizado aos componentes e rotinas que manipulam os dados em uma aplicao que acessa banco de dados. Todo aplicativo que acessa bancos de dados deveria possuir ao menos 1 mdulo de dados.
Figura O Objeto TdataModule.
228
primeira vista, um mdulo de dados poderia parecer muito semelhante a um objeto TForm (formulrio) comum de uma aplicao Windows. Contudo, em nada ele se assemelha a um formulrio, a comear pelo fato de um formulrio ser invisvel durante a execuo de um aplicativo, enquanto um formulrio , por excelncia, um objeto visual. Mdulos de dados no podem conter quaisquer tipos de componentes visuais (controles) e so armazenados em memria de maneira especial. A IDE do Delphi e Kylix oferecem um mecanismo visual para lidar com mdulos de dados durante a fase de projeto; este mecanismo se assemelha a uma janela, mas no um formulrio. Um mdulo de dados guarda no somente datasets, mas componentes de conexo, timers (TTimer) e quaisquer outros componentes no-visuais. No nosso exemplo, o mdulo de dados servir como centralizador de objetos e rotinas de acesso e conexo a banco de dados. Existem muitos tipos de mdulos de dados. Pelo momento, estudaremos m mdulo de dados tradicional, um objeto da classe TDataModule. Voc cria um mdulo de dados para uma aplicao que usa a VCL atravs dos menus File | New | Data Module. Ao longo de muitos pontos de nosso aplicativo, referiremo-nos ao nosso mdulo de dados; ento, altere a sua propriedade Name para um nome simples e sugestivo, como DM. Salve a unidade do mdulo de dados com o nome DataModule ou semelhante.
Trabalhando com um mdulo de dados

Neste tpico aprenderemos como trabalhar com um mdulo de dados e os componentes de acesso a dados nele inseridos. Tambm veremos como configurar uma conexo com uma fonte de dados ADO, e os detalhes do trabalho com datasets e fields.
Conectando com o banco MS Acess A primeira coisa que precisamos fazer para acessar os dados de nosso banco fornecer um meio de conectar nosso aplicativo ao banco de dados. No desenvolvimento de aplicativos que usam bancos de dados, este raciocnio uma necessidade sempre presente. Como usamos ADOExpress para acessar o banco de dados, esta tarefa deve ser executada pelo componente de conexo TADOConnection. Insira um componente TADOConnection no mdulo de dados DM. Ele pode ser acessado na pgina ADO da Palheta de Componentes. Altere a propriedade Name deste componente para ADOCon. TADOConnection estabelece e mantm uma conexo com uma fonte de dados ADO atravs de um provedor OLEDB. O provedor que usaremos o Microsoft.Jet.OLEDB.4.0. Este provedor trabalha com fontes de dados MS Acess, e instalado com o sistema operacional. Contudo, voc pode trabalhar com qualquer outro provedor que saiba manipular uma banco MS Acess, sem que seja necessria qualquer alterao no comportamento do aplicativo ou seu cdigo-fonte. A maneira mais simples de se configurara TADOConnection atravs da sua propriedade ConnectionString. Esta propiedade possibilida a criao de uma string de conexo de uma maneira muito simples. Como voc deve estar se lembrando, TADOCOnnection estabelece conexes com os provedores OLEDB atravs de uma string de conexo parametrizada. Esta string contm todas as informaes necessrias para se fazer uma conexo com um provedor OLEDB. Embora voc possa digitar esta string de conexo na propriedade ConnectionString, certamente ser muito mais produtivo e seguro acessar a caixa de dilogo para criao destas strings de forma visual. Para isto, basta clicar no boto que aparece quando a propriedade ConnectionSTring recebe o foco no Object Inspector. Nesta caixa de dilogo, selecione a opo Use connection string e clique no boto Build. Agora voc pode configurar a sua conexo para um provedor OLEDB. A tabela abaixo resume o significado e valor das propriedades que usaremos. 229
Na pgina Provedores, selecione Microsoft Jet OLEDB 4.0 (ou outro provedor que acesse bancos MS Acess); Na pgina Conexo, selecione ou digite o endereo (path) do nosso banco de dados. Clique no boto Testar conexo para verifcar se est tudo correto. Caso positivo, feche as duas caixas de dilogo para que a string de conexo seja criada.
Pelo momento, isto suficiente para comearmos. Repare que a propriedade ConnectionString do componente ADOCOn possui um valor criado pelos editores. Embora ns tenhamos inserido o caminho (path) do banco de dados de forma esttica, futuramente teremos de possibilitar a customizao deste dado, uma vez que possivelmente este path no existir quando o programa for instalado para os usurios. Isto ser feito um pouco mais frente. Agora, para efeito de um teste final, altere as propriedades LoginPrompt e Connected de ADOCon respectivamente para False e True. LoginPrompt determina se uma caixa de dilogo de identificao de usurio (login) ser automaticamente exibida. Como no usaremos senhas de usurios, o valor False garante que esta caixa no ser exibida. J a propriedade Connected ativa a conexo de ADOCon com a fonte de dados que ele usa. A figura abaixo mostra o Object Inspector exibindo a string de conexo criada.
Figura O objeto TADOConnection j conectado com o banco MSAcess.
Inserindo datasets para acesso aos dados O prximo passo inserir os datasets que sero vinculados s tabelas de nosso banco de dados. Na maioria dos casos, bancos de dados locais podem ser manipulados de forma muito eficiente com datasets baseados em tabelas. Estes datasets so flexveis e no exigem nenhum processo especiala para a edio, insero ou deleo de dados. 230
231
232
APLICAES C L I E N T/ S E R V E R
Este captulo enfoca o suporte ao desenvolvimento de aplicaes cliente/eervidor em Delphi. Voc conhecer alguns dos conceitos mais importantes a serem observados surante o desenvolvimento de aplicaes que usam este modelo de acesso. Por exemplo, conheceremos os fundamentos tcnicos do desenvolvimento cliente/servidor e o trabalho com bancos de dados relacionais e SGBDs.
233
Introduo ao modelo cliente/servidor

O termo cliente/servidor foi inicialmente aplicado para a arquitetura de software que descrevia o processamento entre dois programas. Nesse contexto, a aplicao cliente requisitava um servio que era ento executado pelo programa servidor. Entretanto, esse termo ainda no distinguia se o programa cliente e o programa servidor estavam sendo executados em uma mesma mquina ou em mquinas diferentes. Hoje, quando se fala em cliente/servidor, est se referindo a um processamento cooperativo distribudo, onde o relacionamento entre clientes e servidores so relacionamentos entre componentes tanto de software quanto de hardware. Portanto, estaremos interessados na arquitetura cliente/servidor envolvendo duas ou mais mquinas em um processo cooperativo para executar a aplicao.
Arquitetura cliente/servidor Essa arquitetura tambm consiste de vrios computadores, cada um com seu prprio processamento, interligados em rede. A diferena bsica para a arquitetura Resource-Sharing que aqui j comea a haver um processamento distribudo cooperativo. Parte do processamento, que era feito pela mquina da aplicao, feito agora pela prpria mquina responsvel pelo armazenamento e distribuio da informao, diminuindo assim o trfego de informaes na rede. Portanto, pode-se e deve-se selecionar os dados que sero enviados para o usurio para uma melhor eficincia do ambiente. Esse modelo j comea a retirar partes especficas de processamento das aplicaes que eram executadas pelas mquinas clientes, centralizando-as nas mquinas de localizao fsica mais adequada, garantindo assim uma melhor distribuio do processamento e utilizao do ambiente. Atravs dessas especializaes garante-se tambm um melhor gerenciamento e facilidade de manuteno dos servios devido a sua concentrao em um ou poucos locais fsicos. Podemos citar alguns benefcios que esta nova arquitetura traz para o ambiente computacional das empresas: Permite s corporaes alavacarem a tecnologia de computadores desktops. Hoje, as estaes de trabalho j possuem um poder computacional considervel, por um custo muito mais baixo, antes s disponvel em Mainframes. Permite que o processamento seja feito mais prximo da origem dos dados reduzindo o trfego na rede. Facilita a utilizao de aplicaes grficas e multimdias. Isto permite a construo de aplicaes que excedem as expectativas dos usurios proporcionando-lhes um real aumento de produtividade. Permite e encoraja a utilizao de sistemas abertos, j que clientes e servidores podem rodar em diferentes hardwares e softwares, livrando as corporaes de arquiteturas proprietrias.
Entretanto, essa arquitetura ainda no perfeita. Algumas caractersticas necessrias para um completo processo distribudo ainda no foram observadas nesse modelo que ainda apresenta algumas deficincias: Se uma poro significante da lgica da aplicao for movida para o servidor, esse se torna um gargalo assim como na arquitetura de Mainframe. Para resolver esse problema seria necessrio
234
uma melhor distribuio e gerenciamento do processamento da lgica da aplicao. Isto d origem a uma nova arquitetura chamada Segunda gerao cliente/servidor. O processo de construo de aplicaes distribudas bem mais complexo que o desenvolvimento de aplicaes no distribudas devido ao maior nmero de parmetros a serem definidos, ao desconhecimento da tecnologia e a falta de padres e ferramentas que auxiliem essa ambientao. Portanto, muito tempo pode ser consumido no processo de definio e construo do ambiente de desenvolvimento. Esse tempo muitas vezes subestimado pelas empresas devido ao desconhecimento e as falsas propagandas dos vendedores de ferramentas.
Primeira gerao cliente/servidor Podemos definir cliente/servidor como uma arquitetura computacional que visa distribuir os recursos e o processamento de forma inteligente com o objetivo de otimizar o desempenho da rede e dos sistemas, maximizando a utilizao dos recursos de cada mquina e fornecendo uma base slida e flexvel para a implantao de um nmero crescente de servios. Algumas implementaes desse tipo j vm sendo utilizadas em vrias empresas e so conhecidas como a primeira gerao cliente/servidor. Para compartilhar recursos, como disco e impressora, so utilizados Servidores de Arquivos na rede. Estes so sistemas com a funo de processar as requisies aos arquivos e impressoras e gerenciar seu acesso e distribuio. Alm disso, parte do processamento das aplicaes tambm foi distribudo. Alguns servios de manipulao e gerenciamento de dados foram retirados das aplicaes e colocados em pontos centralizados conhecidos como Servidores de Banco de Dados, tornando o processamento dos dados mais prximo do seu local de armazenamento. Os sistemas que fornecem tais servios foram chamados de Sistemas Gerenciadores de Banco de Dados - SGDB. Basicamente, a primeira gerao de cliente/servidor se caracteriza por essa distribuio do processamento da aplicao entre dois componentes: a estao de trabalho do usurio e o servidor de banco de dados. medida que a arquitetura cliente/servidor evolui, novas partes da aplicao vo sendo distribudas e novos elementos vo aparecendo no ambiente.
Segunda gerao cliente/servidor Hoje, a tecnologia cliente/servidor j caminha para sua segunda gerao. Essa gerao explora mais o ambiente de rede e suas mquinas. Surgem novos servidores com a finalidade de retirar das estaes de trabalho grande parte do processamento que elas realizam. Os principais elementos dessa nova arquitetura so os servidores de aplicao e os servidores Web. Os servidores de aplicao so responsveis por retirar o restante da camada de manipulao de dados que ainda havia na estao cliente. Alm disso, tem o objetivo de concentrar a lgica de negcio, antes distribuda entre a estao cliente e o servidor de banco. Normalmente, esse trabalho no feito por um nico servidor de aplicao e sim por um conjunto de servidores onde o processamento balanceado atravs de elementos chamados Midlleware. Desta forma resta para a estao cliente, o processamento da interface visual com o usurio, deixando-a mais leve, exigindo uma menor configurao e melhorando seu desempenho. Os servidores Web tentam ir mais longe ainda, permitindo retirar das estaes de trabalho at parte da lgica da interface visual, deixando-as responsveis apenas por interpretar o cdigo HTML enviado pelos servidores. Entretanto, com a utilizao de componentes como Java e ActiveX, parte do processamento pode retornar estao de trabalho.
235
Essas novas tecnologias trazem mais recursos, mas tornam o ambiente mais complexo e difcil de ser implementado. preciso estar bem certo do que se pretende e no fazer uso de uma tecnologia mais nova sem a conhec-la direito ou sem a real necessidade de utiliz-la.
SGDB - Sistemas gerenciadores de banco de dados

Esse captulo apresenta os sistemas gerenciadores de banco de dados, seus servios, recursos e modelos. Os SGBDs so sistemas responsveis em armazenar os dados e fornecer servios capazes de manipullos. Para armazenar os dados em um disco, os SGBDs possuem uma forma estruturada padro de representar os registros e campos, fornecendo servios que permitem a criao e alterao dessas definies de dados. Fornecem ainda, um mecanismo interno para manter os dados no disco e para saber onde est cada elemento em particular. Tambm so responsabilidades do SGDBs disponibilizar servios para incluir, classificar, atualizar e eliminar os dados armazenados. Pela forma com que os dados so armazenados e de como eles se relacionam podemos classificar os SGBDs atravs de vrios modelos at chegarmos aos bancos de dados relacionais.
Modelos de banco de dados Analisando os diversos modelos de banco de dados, pode-se notar uma evoluo no relacionamento entre os dados, eliminando cada vez mais a redundncia e proporcionando mais flexibilidade e portanto uma maior facilidade de manuteno das definies de dados. Para melhor entendermos os modelos vamos utilizar os dados das trs guias de pedidos da fig. 2.1.
236
Fig. 2.1: Guia de Pedido.
Sistema de gerenciamento de arquivos Esse o nico sistema que descreve como os dados so armazenados. Nesse modelo cada campo ou item de dado armazenado seqencialmente no disco em um nico e grande arquivo. Para encontrar um item de dado necessrio verificar cada elemento desde o incio do arquivo. A nica vantagem desse mtodo sua simplicidade, j que seu formato muito se parece com o de um arquivo texto onde as palavras se encontram escritas em uma determinada seqncia. Entretanto, por causa dessa simplicidade, muitos dados tm que ser escritos repetidamente gerando uma enorme redundncia que dificulta a manuteno e a integridade dos dados. No h tambm nenhuma indicao de relacionamento entre os dados, e o programador precisa saber exatamente como os dados esto armazenados para poder acess-los de forma consistente. Alm disso, sua estrutura fsica rgida, o que dificulta alteraes na definies dos dados, gerando a necessidade de reconstruir todo o arquivo.
1 | 20/10/96 | Ana Maria Lima | 999.876.555-22 | Caneta | 10 10,00 | Lpis | 5 | 5,00 | 15,00 | 2 | 21/10/96 | Maria Jos | 111.111-22 | Caneta | 15 | 15,00 | Caderno | ...
Fig. 2.2: Sistema de Gerenciamento de Arquivos.
Banco de Dados Hierrquico
237
Nesse modelo, os dados so organizados em uma estrutura de rvore que se origina a partir de uma raiz. Essa estrutura identifica as relaes pai-filho entre os vrios itens do banco de dados, mostrando assim suas vantagens sobre o modelo de gerenciamento de arquivos. No modelo hierrquico possvel definir relaes de-um-para-muitos que facilita e acelera o processo de pesquisa dos dados. Para encontrar uma informao, no mais necessrio percorrer o arquivo inteiro. Basta examinar o item pedido, decomp-lo em componentes e descer pelos ramos necessrios at encontr-lo. Esse mtodo, tambm facilita a insero de novos dados, devido aos relacionamentos entre os campos serem feitos atravs de ponteiros. Para inserir um novo elemento basta alterar os ponteiros dos relacionamentos entre pais e filhos.
Raiz
1
20/10/96 15,00
999.876.555-22
2
21/10/96 65,00
111.111.111-22
3
Maria Jos 15 Caneta Caderno
Ana Maria 10
Caneta
Lpis
10,00 5
5,00
15,00
50,00
Fig. 2.3: Banco de Dados Hierrquico.
Entretanto, esse mtodo ainda possui alguns problemas. Cada nvel da rvore inicialmente definido e qualquer alterao na estrutura desses nveis uma tarefa difcil. Alm disso, o problema da redundncia de dados ainda no foi resolvido, j que esse modelo no implementa relaes de muitos-para-muitos. No exemplo, podemos notar a repetio de algumas informaes, o que dificulta a integridade e manuteno dos dados.
Banco de dados de rede O modelo de rede descreve, conceitualmente, os banco de dados nos quais permitem relaes de muitos-para-muitos entre os elementos de dados. Desta forma cada item possui um ponteiro para os itens com os quais se relaciona, eliminando assim a necessidade de qualquer tipo de redundncia de dados. O grande problema desse modelo a sua complexidade devido a flexibilidade existente em suas relaes. Quando o volume de dados comea a crescer, os relacionamentos entre os itens de dados ficam cada vez mais complexos, tornando sua visualizao e entendimento cada vez mais difceis.
238
Raiz
Ana Maria
999.876.555-22
Lpis
Caneta
Caderno
Maria Jos
111.111.111-22
Fig. 2.4: Banco de Dados de Rede.
Banco de dados relacional Em 1969, foi publicado pelo Dr. E. F. Codd, o primeiro artigo que definia um modelo com base no conceito matemtico dos conjuntos relacionais. A partir desse artigo, o modelo relacional tem sido refinado, at que 1985 o prprio Dr. Codd lanou as 12 regras que definiam um banco de dados relacional. Em 1990, foram publicadas as 333 regras que so subconjuntos e expanses das 12 regras originais. O modelo relacional abandona o conceito de relaes pai-filho feitas diretamente entre os dados e os organiza em conjuntos matemticos lgicos de estrutura tabular. Nesse modelo, cada item de dado pertence a uma coluna da tabela e uma linha da tabela composta por vrios elementos diretamente relacionados. As tabelas tambm se relacionam atravs de funes matemticas como JOINs e UNIONs. Para fazer esse relacionamento parte dos dados, que identificam unicamente o registro da tabela, so repetidos dentro da outra tabela. As vantagens desse mtodo so sua simplicidade e flexibilidade nas definies das relaes entre os vrios itens de dados, j que no so feitos diretamente entre os dados e sim entre as tabelas. Entretanto, esse mtodo no elimina por completo a redundncia de dados, j que no mnimo os relacionamentos entre as tabela so feitos atravs da repetio de parte dos dados. Alm dessa redudncia, fica a cargo do projetista do banco de dados se mais repeties de dados iro ou no fazer parte do modelo. O processo de fragmentao dos dados, a fim de serem organizados em subconjuntos (tabelas), conhecido como normalizao.
239
Pedido
NumPed 1 2 3 Data 20/10/96 21/10/96 22/10/96 Valor 15,00 65,00 25,00 Cliente 1 2 2
Itens
NumPed 1 1 2 2 3 3 Produto Caneta Lpis Caneta Caderno Lpis Caderno Quantid. Valor 10 5 15 5 15 1 10,00 5,00 15,00 50,00 15,00 10,00
Cliente
Codigo 1 2 Nome CPF Ana Maria Lima 999.876.555-22 Maria Jos 111.111.111-22
Fig. 2.5: Banco de Dados Relacional.
Os bancos de dados relacionais vm se tornando um padro no mercado, servindo como base de dados para a maioria dos sistemas das empresas. A cada dia, mais ferramentas so construdas para tirar proveito dessa tecnologia, fazendo surgir um nmero crescente de recursos e produtos a serem oferecidos para os usurios. Pode-se dizer ento, que esta uma tecnologia slida e consistente e que ir acompanhar o mercado por um longo perodo de tempo. No entanto, uma tecnologia que continua evoluindo com o objetivo de disponibilizar as informaes para os usurios de maneira eficiente, viabilizando o negcio da corporao e descentralizando as tomadas de deciso.
A linguagem SQL Para acessar os bancos de dados relacionais foi desenvolvida uma linguagem chamada SQL. O Objetivo dessa linguagem fornecer uma forma padro de acesso aos bancos de dados, no importando a linguagem com que esses tenham sido desenvolvidos. Apesar da tentativa de se tornar um padro (ANSI), cada fornecedor hoje possui uma srie de extenses que tornam as vrias verses incompatveis entre si. Por isso, no pense que uma aplicao construda para acessar um determinado banco de dados de um fornecedor, ir acessar tambm, sem qualquer modificao, o banco de dados de um outro fornecedor. Isto s possvel se a aplicao utilizar somente a parte comum (ANSI) da linguagem SQL, mas isto faz com que ela perca vrios recursos importantes disponveis em cada verso SQL de fornecedores diferentes. Alguns bancos de dados j suportam o padro SQL ANSI-92 que j mais abrangente numa tentativa de facilitar o processo de deixar transparente a base de dados utilizada pela aplicao. Entretanto, alguns fornecedores ainda no fornecem suporte ao SQL ANSI-92 de forma completa porque teriam que alterar partes estruturais de seus sistemas gerenciadores.
Categorias da Linguagem SQL A linguagem SQL se divide em trs categorias: DDL ( Linguagem de Definio de Dados). Parte da linguagem com comandos para criao das estruturas de dados como as tabelas, colunas, etc. Ex: CREATE TABLE.
240
DML ( Linguagem de Manipulao de Dados). Parte da linguagem com comandos para acessar e alterar os dados armazenados no banco de dados. Os principais comandos dessa categoria so: SELECT, UPDATE, INSERT, DELETE. DCL ( Linguagem de Controle de Dados). Parte da linguagem com comandos para definir usurios e controlar seus acessos aos dados. Ex: GRANT.
Consistncia e integridade dos dados A maioria dos bancos de dados relacionais possuem recursos para consistir e tornar ntegro os dados armazenados em suas tabelas. Desta forma, qualquer ferramenta que o usurio utilizar para acess-lo obrigada a respeitar as regras, mantendo a integridade dos dados. Os recursos de consistncia variam de banco para banco, mas pode-se definir conceitualmente algumas categorias de integridade como: integridade referencial, domnios e regras do negcio.
Integridade Referencial Integridade referencial um conjunto de regras e de consistncias entre os registros de duas tabelas que se relacionam. Como foi visto no modelo relacional, quando duas tabelas se relacionam, a chave primria de uma copiada para a outra e se esses dados forem alterados ou excludos da tabela original necessrio verificar o que ser feito com os dados e registros duplicados na outra tabela. Quando se define uma integridade referencial, est se definindo o procedimento que ser tomado quando esses processos ocorrerem. Sejam duas tabelas A e B que se relacionam atravs de uma coluna c que a chave primria de A e portanto foi repetida em B para se fazer o relacionamento. Quando se define uma integridade referencial para esse relacionamento, est se definindo que a coluna c da tabela B s pode conter valores j cadastrados na coluna c da tabela A.
Tabela A *c d e . .
Fig 3.19: Integridade Referencial.
Tabela B *a b c
Existem trs formas de se manter essa regra quando registros da tabela A so excludos:
241
Restrict: Define que se o valor da coluna c de A existir em algum registro de B, o registro no poder ser excludo e uma mensagem de erro retornar para a aplicao; Cascade: Define que se o valor da coluna c de A existir em algum registro de B, todos os registros que possurem esse valor sero tambm excludos; Set Null: Define que se o valor da coluna c de A existir em algum registro de B, os valores de c em todos os registros sero transformados para Null;
Em todos os casos, se o usurio tentar inserir um registro em B com um valor de c que no exista na tabela A, um erro ser reportado aplicao. Alguns bancos, tambm permitem fazer o mesmo tratamento quando a chave da tabela for alterada, ao invs de excluda. Entretanto, essa alterao de chaves no deve ser um processo comum nas aplicaes, sendo normalmente proibidas. Os bancos de dados possuem formas diferentes de disponibilizar esses servios. Alguns possuem at mais de uma forma de fazer o mesmo processo. Mas de maneira geral existem duas possibilidades de implementao:
Integridade Referencial Declarativa Essa uma forma mais fcil, porm menos flexvel. Com apenas um comando se define a integridade. Porm, alguns bancos no suportam essa sintaxe ou a fornecem de maneira limitada somente para regras do tipo Restrict. A maior vantagem dessa alternativa sua simplicidade e por isso menos sujeita a erros de implementao.
Triggers Os triggers so pedaos de cdigo escritos em uma extenso da linguagem SQL fornecida por cada fornecedor, sendo portanto uma linguagem proprietria. Essa extenso possui instrues para implementar loops e verificar condies permitindo fazer pequenos programas estruturados. Os triggers so disparados automaticamente pelo banco quando eventos de incluso, alterao ou excluso ocorrem em uma determinada tabela. Portanto, atravs dos triggers pode-se desenvolver a lgica necessria para se manter a integridade referencial entre as tabelas.
Domnio dos dados Outro tipo de consistncia com relao ao domnio dos dados. Para um determinado campo de dado pode existir um conjunto de valores permitidos e o banco de dados deve reportar um erro aplicao se um valor invlido for informado. Um tipo de consistncia de domnio que normalmente fornecido pelos bancos a possibilidade do campo ser nulo ou no. Alguns bancos possuem tambm comandos para definir um conjunto de valores vlidos para um determinado campo. Ex: Valores (J,F) para um campo que armazena se a pessoa fsica ou jurdica. Outros possuem uma sintaxe para definir valores mnimos e mximos. Pode-se, ainda, utilizar o recurso de triggers para esse propsito.
242
Regras de Negcio Pode-se definir como regras de negcio a integridade que deve existir entre os valores de mais de um campo de uma ou mais tabelas. Pode-se considerar como regra do negcio as consistncias e atualizaes que devem ser feitas em vrias tabelas, quando um registro inserido, alterado ou excludo de uma tabela. Ou um processo de clculo disparado sobre os dados do banco que tambm fazem atualizaes em diferentes locais, mas de forma a manter os valores dos dados sempre ntegros e consistentes. Um exemplo seria a atualizao de estoque que normalmente envolve outras tarefas em um sistema de controle de estoque. Para implementar essas regras de negcio no banco de dados so utilizados os recursos de triggers e stored procedures. Stored procedures so blocos de cdigo assim como os triggers. A diferena entre eles que os triggers so disparados automaticamente por inseres, alteraes e excluses feitas nas tabelas, enquanto as stored procedure so chamadas explicitamente pela aplicao.
Distribuio da consistncia e integridade dos dados Como foi visto, possvel implementar vrias regras de consistncia dos dados no prprio banco de dados. Entretanto, possvel implement-las tambm na aplicao e portanto fica uma dvida de qual seria o melhor lugar para implement-las. Ambas as alternativas possuem vantagens e desvantagens que devem ser observadas no incio do processo de desenvolvimento. A principal vantagem em se colocar todas as regras no banco de dados que esse mantm a consistncia e integridade dos dados independente da ferramenta de acesso utilizada pelo usurio. Alm disso, as manutenes dessas regras ficam localizadas em um nico local, ao invs de ficarem espalhadas por toda a aplicao ou por diversas aplicaes. Entretanto, o desenvolvimento utilizando essa linha de trabalho muito mais rduo e demorado. As ferramentas disponveis nesse ambiente no apresentam ainda muitos recursos que dem produtividade na construo das regras. As linguagens utilizadas para escrever as stored procedures e triggers so proprietrias dos fornecedores, tornando a empresa dependente de nico fornecedor, dificultando a distribuio dos dados em bancos de fornecedores diferentes. Alm disso necessrio dividir o desenvolvimento em duas linguagens. A linguagem da ferramenta para se montar a interface e a chamada dos processos e a linguagem para construo das stored procedures. Atualmente, o mercado se encontra dividido com cada empresa tomando um caminho diferente para distribuir essas regras entre o cliente e o servidor. Mas no pode-se dizer que um caminho j seguido por uma empresa que obteve sucesso o mais indicado para uma outra empresa. Muitas outras variveis precisam ser consideradas e dificilmente sero iguais entre duas empresas. Alm disso, as ferramentas e a tecnologia evoluem fazendo como que um mesmo caminho possa obter resultados diferentes, considerando-se a tecnologia atualmente disponvel. De uma maneira geral, as duas primeiras categorias de consistncia (integridade referencial e domnios) so normalmente implementadas no banco de dados, sendo que os domnios so implementados repetidamente na aplicao para evitar que os comandos sejam enviados ao banco. A grande dvida mesmo, com relao s regras de negcio que algumas empresas implementam totalmente no banco de dados, outras totalmente na aplicao e algumas distribuem entre esses dois componentes. Atualmente, existe mais um alternativa na nova gerao da arquitetura Cliente/Servidor: a implementao das regras de negcio em um novo componente chamado Servidor de Aplicaes.
Trabalhando com Bancos de Dados Relacionais

Os bancos de dados relacionais fornecem um conjunto de servios para que as aplicaes possam acess-los e manipul-los. Portanto, importante entender bem sua funcionalidade para melhor aproveitar seus recursos nas aplicaes. Existem algumas diferenas na forma de trabalhar entre os fornecedores, mas grande parte dos conceitos podem ser aplicados a todos os bancos de dados relacionais. 243
Componentes da arquitetura cliente/servidor - dlsf Como foi visto, a arquitetura cliente/servidor composta de dois componentes fsicos que se comunicam atravs da rede: a estao de trabalho do usurio e o servidor de banco de dados. Para se estabelecer a comunicao entre esses dois componentes so utilizadas vrias camadas de software que so instaladas em cada componente fsico. A estao de trabalho cliente deve ter, alm da aplicao final, vrios outros elementos para acessar a base de dados em um SGBD atravs de rede. Database Engine: biblioteca fornecida pelo fornecedor da ferramenta de desenvolvimento com o objetivo de fornecer uma forma nica e transparente da aplicao acessar diferentes bases de dados. Ex: BDE (Borland Database Engine), ADO ou DBExpress; Drivers de conexo responsvel pela comunicao com a fonte de dados. Sua principal caracterstica traduzir os comandos utilizados pelo Database Enginer para comandos conhecidos pela base de dados utilizada. Client do banco de dados: API fornecida pelo fornecedor do SGDB e instalada na estao cliente para estabelecer a comunicao com o banco de dados. Nessa API se encontram as funes de acesso a base de dados. tambm, responsvel por utilizar um determinado protocolo de rede para encontrar o servidor de banco para que a aplicao possa acess-lo enviando comandos e buscando os dados. Protocolo de rede: softwares responsveis pela transmisso dos dados pela rede entre a mquina cliente e o servidor.
CLIENTE CLIENTE
Aplicaes Ferramentas Desenvolvimento Database DatabaseEnginer Enginer NetBios NetBios
MIDDLEWARE
Servios Especficos
SQL/API SQL/API
SERVIDOR SERVIDOR
Banco Bancode deDados Dados
Transporte
TCP/IP TCP/IP IPX/SPX IPX/SPX SNA SNA
SOR
Serv. Serv.Diretrio Diretrio
Sistema Operacional
Serv. Serv.Diretrio Diretrio Segurana Segurana

Sistema Operacional
RPC RPC
Mensagens Mensagens
Projetando Aplicaes Cliente/Servidor

A construo de aplicaes Cliente/Servidor deve obedecer algumas regras de organizao para que os sistemas possam ter um tempo de vida mais longo e acompanhar a evoluo do negcio da empresa e a evoluo tecnolgica da arquitetura. 244
Esse captulo mostra algumas tcnicas de construo de aplicaes voltadas para o ambiente cliente/servidor.
Estrutura de uma Aplicao Como foi visto, o ambiente cliente servidor permite que a aplicao seja distribuda entre dois componentes fsicos: a estao cliente e o servidor de banco de dados. Entretanto, logicamente podemos identificar trs camadas distintas dentro de uma aplicao. Apresentao Composta por componentes responsveis pela interao da aplicao com o usurio final. responsabilidade dessa camada receber os dados e comandos do usurio e devolver-lhe informaes atravs de elementos visuais como consultas, grficos, relatrios e etc; Lgica do Negcio Parte da aplicao responsvel por manter as regras de negcio da empresa. Essa camada recebe os dados da camada de interface e executa as operaes e validaes necessrias para envi-los ao banco de dados. Da mesma forma, extrai os dados do banco de dados de acordo com as regras de negcio da aplicao e os envia para elementos da interface para que sejam exibidos. Portanto, essa camada responsvel em interligar a interface visual com o banco de dados atravs da execuo de transaes, consistncia dos dados e regras de negcio, ou seja, a parte funcional da aplicao. Gerenciamento de Dados Parte da aplicao responsvel pelo acesso e a manipulao dos dados no servidor. Como j foi visto anteriormente, grande parte dessa camada implementada pelo prprio servidor de banco de dados. Normalmente o acesso aos servios feito atravs da linguagem SQL. Porm, tambm necessrio um conjunto de comandos para enviar as sentenas SQLs e gerenciar a comunicao entre a aplicao e o servidor. Esses comandos se encontram em bibliotecas disponibilizadas pelos prprios fornecedores de banco de dados que so instaladas em cada estao de trabalho. Alm disso cada fabricante de ferramentas de desenvolvimento fornece tambm mtodos e componentes capazes de simplificar e tornar mais transparente o acesso aos diversos SGDBs.
CLIENTE APRESENTAO FSICO LGICA do NEGCIO GERENCIAMENTO de DADOS SERVIDOR

Fig 6.1: Camadas Fsicas e Lgicas de uma Aplicao.
LGICO
245
Vantagens da organizao da aplicao em camadas A diviso da aplicao nessas trs camadas lgicas possibilita a organizao e padronizao da codificao e construo da aplicao, alm de proporcionar uma maior facilidade de manuteno e evoluo para novas fases da arquitetura cliente/servidor. Como j foi visto, a tendncia da arquitetura Cliente/Servidor retirar cada vez mais parte do processamento da aplicao realizado pelas estaes de trabalho clientes e centraliz-lo em servidores, provendo um melhor gerenciamento do processo e facilitando a evoluo da funcionalidade que foi distribuda. A distribuio da aplicao em camadas lgicas possibilita tambm que cada camada possa evoluir independente das outras desde que se mantenha a interface entre elas. Por exemplo, pode-se alterar as regras de negcio para atender as necessidades do mercado sem necessariamente ter que modificar a camada de interface ou a camada de gerenciamento de dados. Por outro lado, pode-se evoluir a apresentao para novas tecnologias como multimdia, sem precisar alterar as regras de negcio. Evolues tecnolgicas, como a distribuio da base de dados na camada de gerenciamento de dados pode ser feita de forma transparente das demais camadas. Portanto, esses tipos de distribuio tornam as aplicaes mais escalveis para suportar futuras implementaes possibilitando um tempo de vida muito mais longo.
Construindo Aplicaes Cliente/Servidor Existem vrias maneiras de se utilizar os componentes do Delphi para trabalhar com banco de dados. preciso saber escolher as formas mais adequadas para cada tipo de implementao. Atravs desse tpico sero mostrada vrias dessas opes e o que cada uma difere no comportamento da aplicao com o banco de dados. O aplicativo que iremos construir um controlador de desenvolvimento de aplicativos (projetos). Nele voc poder inserir os membros de um projeto de desenvolvimento, cadastrar bugs encontrados e suas correes, bem como cadastrar tarefas a serem realizadas. Unicamente para efeito de comodidade usaremos o Interbase 6.0 como SGDB, pois praticamente toda instalao do Delphi/Kylix tambm contm o Interbase. Certamente poderamos utilizar o MS SQL Server ou Informix, sempre trabalhando da mesma maneira2. O modelo de dados abaixo ilustra a estrutura de nosso banco Interbase.
Se voc possui uma instalao do Firebird poder us-lo normalmente para este exemplo.
246
Como dito anteriormente, o aplicativo gira em torno de projetos de desenvolvimentos. Cada projeto possui membros a ele ligados, isto , desenvolvedores que nele trabalham. Cada projeto de um determinado tipo, como, por exemplo, Delphi ADOExpress e MS SQL Server, Delphi - aplicativos distribudos ou Delphi desenvolvimento de site. Os projetos possuem tarefas a serem executadas e bugs a serem corrigidos. Cada bug detectado possui seu prprio histrico, quer dizer, possui uma lista de aes que foram feitas no sentido de sua fixao. Veja abaixo a descrio de cada um dos campos das tabelas do banco BUGS.
PROJETOS Campos CDPROJ NMPROJ CDNMPROJ DATAPROJ CDTPPROJ CDDES STATUSPROJ
Descrio Cdigo exclusivo do projeto Nome completo do projeto. Codinome do projeto. Data de cadastro do projeto do sistema. Cdigo do tipo de projeto. Cdigo do desenvolvedor-chefe do projeto. Status do projeto (1 Em andamento, 2 Paralizado, 3 Encerrado).
DESENVOLVEDORES Campos CDDES Cdigo exclusivo do desenvolvedor NMDES Nome completo do desenvolvedor.
Descrio
TIPOPROJETOS Campos CDTPPROJ DSCTPPROJ
Descrio Cdigo exclusivo do tipo de projeto. Descrio do tipo de projeto.
247
MEMBROS Campos CDMBR CDPROJ CDDES ATIVO
Descrio Cdigo exclusivo do membro do projeto. Cdigo do projeto Cdigo do desenvolvedor. Determina se o membro est ativo no projeto ou no.
TODO Campos CDTDO CDPROJ NMTDO DSCTDO DATATDO CDDES CDRES FIXADO DATAFIX
Descrio Cdigo exclusivo da tarefa. Cdigo do projeto. Nome da tarefa. Descrio completa da tarefa. Data de insero da tarefa. Cdigo do desenvolvedor que inseriu a tarefa. Cdigo do desenvolvedor que executar a tarefa. Indica se a tarefa foi executada. Data em que a tarefa foi terminada.
TIPOBUGS Campos CDTPBUG DSCTPBUG
Descrio Cdigo exclusivo do tipo de bug. Descrio do tipo de bug.
BUGS Campos CDBUG CDPROJ NMBUG CDTPBUG DATABUG DSCBUG CDDES CDRES FIXADO
Descrio Cdigo exclusivo do bug Cdigo do projeto. Nome do bug Descrio completa do bug. Data de insero do bug. Descrio completa do bug. Cdigo do desenvolvedor que inseriu o bug. Cdigo do desenvolvedor que fixar o bug. Indica se o bug foi fixado.
HISTORICO Campos CDHIS CDBUG BUGHIS DATAHIS CDDES
Descrio Cdigo exclusivo do histrico do bug. Cdigo do bug. Nome do histrico do bug. Data de insero do histrico do bug. Cdigo do desenvolvedor que inseriu o histrico do bug.
Utilizando Interbase Express Utilizaremos a Interbase Express como mecanismo de acesso ao dados de nosso banco de dados. Esta escolha baseada principalmente pelo fato de a Interbase Express fornecer o mais rpido mecanismo de acesso a bancos de dados Interbase/Firebird disponvel.
248
Crie um novo projeto e salve-o como o nome Bugs. O formulrio principal pode ser salva com o nome Main.pas. Como sempre ocorre em aplicativos que acessam bancos de dados, importante inserir um mdulo de dados no nosso aplicativo. Para a arquitetura cliente/servidor, ns usamos mdulos de dados comuns, pois grande parte da lgica comercial estar inserida no aplicativo cliente. Assim, toda a lgica de negcio fica concentrada em um nico ponto da aplicao, facilitando sua manuteno e a implementao de novos recursos. Para aplicaes maiores aconselhvel a utilizao de mais de um Mdulo de Dados, o que possibilita a diviso da lgica comercial em partes logicamente distintas. Insira o novo mdulo de dados atravs dos menus File | new | Data Module; renomeie-o para DM e salve a unidade com o nome DataModule.
Componente TIBDatabase Como foi visto anteriormente, o componente TIBDatabase o responsvel pela conexo com o banco de dados. Esse componente possui algumas propriedades que permitem a configurao dessa conexo. Insira um TIBDatabase no nosso mdulo de dados e configure suas propriedades de conexo. A maneira mais fcil de fazer isto atravs do editor de propriedades deste componente. Voc pode acess-l0 dando um duplo clique em cima do TIBDatabase no nosso mdulo de dados. Veja abaixo uma imagem deste editor de propriedades.
Atravs deste editor, possvel configurar as propriedades DatabaseName, LoginPrompt e Params de um TIBDatabase de uma s vez. Insira tambm um componente TIBTransaction e ligue-o ao componente TIBDatabase. Renomeie este componente para TrsDefault. Vamos agora inserir todos os datasets que sero responsveis pela exibio e edio dos dados das tabelas TIPOPROJETO, TIPOBUGS e DESENVOLVEDORES. Devido ao fato de estas tabelas fornecerem informaes ao outras atravs de chaves estrangeiras, elas so genericamente chamadas tabelas de pesquisa. Insira 4 componentes TIBDataset, 1 componente TIBSQL, 5 componentes TIBTransaction e 3 componentes TDataSource. A conexo entre estes componentes feita da seguinte forma:
249
Todos componentesTIBDataset so conectados a um componente de conexo atravs da propriedade Database. So conectados a um componente TIBTransaction atravs da propriedade Transaction. Todos os componentes TIBTransaction so conectados a um componente de conexo atravs da propriedade DefaultDatabase. Todos os componentes TDataSource so ligados a um dataset atravs da sua propriedade Dataset. O componente TIBSQL conectado a um componente de conexo atravs da sua propriedade Database e a um TIBTransaction atravs da sua propriedade Transaction.
Renomeie todos estes objetos, seguindo uma nomenclatura padro que lhe parea razovel. necessrio agora inserir os comando Select para todos os componentes TIBDataset que inserimos. Este componente possui suporte para comandos de seleo, alterao, deleo e atualizao de tabelas Interbase atravs das propriedades SelectSQL, UpdateSQL, DeleteSQL e RefreshSQL, respectivamente. Estas propriedades devem ser preenchidas. A maneira mais fcil de fazer-se isto digitar o comando Select e, em seguida, no menu de contexto que aparece ao clicar-se sobre o componente TIBDataset, escolher o item Dataset Editor para acessar um editor que lhe facilitar sobremaneira esta tarefa. Este editor capaz de gerar comandos SQL para voc a partir de algumas poucas informaes obtidas previamente. Aps fazer tudo isto, voc pode testar seu trabalho alterando a propriedade Active de um TIBDataset para True. O componente TIBSQL inserido ser usado para executar comandos dinamicamente, durante a execuo do aplicativo. Da mesma forma, um componente TIBDataset (que nomeamos DsSearch) ser usado paraexecutar consultas ao banco de forma dinmica. Portanto, as suas propriedades que se referem aos comandos SQL a sererm usados no sero preenchidas agora.
Projeto de interface do software Agora que temos um mdulo de dados minimamente desenvolvido, podemos comear a pensar na interface (GUI) do nosso aplicativo.
Nmero de Tabelas Acessadas Um outro fator relevante na escolha do componente, o nmero de tabelas que devem ser acessadas para buscar as informaes necessrias para o usurio em uma mesma tela. At um certo nmero de tabelas mais interessante utilizar o recurso de joins dos bancos para trazer em um nico comando SQL, todo o conjunto de informaes. Nesse caso um componente TQuery deveria ser utilizado. Quando isso feito atravs de vrios componentes TTable, as vezes necessrio trazer os dados de todas as tabelas para a mquina cliente para que a relao entre elas possa ser feita. No melhor caso, se filtrarmos cada tabela pelo registro selecionado na outra, teramos que executar vrios comandos SELECTs mais simples no servidor contra um nico comando um pouco mais complexo do componente TQuery.
Trabalhando com o TQuery O componente TQuery pode ser ento utilizado para acessar e manipular os dados. Como foi visto, a utilizao desse componente deixa mais flexvel o acesso ao banco, j que trabalha diretamente com a 250
linguagem SQL. Portanto, manutenes evolutivas como acessar mais de uma tabela atravs do mesmo componente podem ser implementadas com mais facilidade. Afim de continuarmos nossa aplicao, devemos colocar um componente TQuery no DataModule DMSistVendas.
Fig 7.3: Componente TQuery
Componente Query1
Propriedade Name DatabaseName SQL Request Live Active
Valor QProduto DBVENDAS Select * from produto order by produto.prod_cd TRUE TRUE
A propriedade Request Live ligada, faz com que o Delphi tente atualizar automaticamente o result set trazido pela query. Desta forma, o componente TQuery se comporta de forma semelhante ao componente TTable. Entretanto, para que isso seja possvel, o comando SQL tem que obedecer algumas restries como por exemplo: Conter apenas uma tabela na clusula From; No possuir agregaes atravs de group by e funes como sum, max, etc.
Aps termos preenchido o DataModule com os componentes responsveis pelo acesso ao banco de dados, podemos construir o form de manuteno da tabela de produto como a figura a seguir:
251
Fig 7.4: Form de Produto. Componente Form1 Panel1 Panel2 DataSource1 DBNavigator1 DBEdit1..DBEdit4 Propriedade Name Caption Align Caption Align Caption Name DataSet DataSource DataSource DataField Valor frmProduto Produtos alTop alClient DSMain DMSistVendas.Qproduto DSMain DSMain pro_cd..pro_estoque
Podemos ento executar a aplicao e verificar que atravs da propriedade Result Live do Qproduto, foi possvel atualizar os dados e acrescentar novas linhas tabela. Entretanto, podemos notar que as linhas inseridas desaparecem do Result Set ao navergarmos para outro registro. Esta uma restrio que existe no componente TQuery quando se utiliza a propriedade Result Live para torn-lo atualizvel automaticamente pelo Delphi. Alm disso, foi visto que para ser possvel tornar o result set atualizvel, existem algumas restries quanto ao comando SQL definido. Por causa desses motivos, talvez seja ento necessrio trabalhar com a propriedade Result Live igual a False e utilizar um outro artifcio para tornar o result live atualizvel sem restries no comando SQL e sem perder as linhas inseridas.
252
APLICAES MULTI-CAMADAS
253
Escrevendo aplicaes distribudas
Modelos de thread e instanciao de objetos
Mdulos de dados remotos
Instanciao nica
Instanciao interna
Instanciao mltipla
Modelo de thread simples
Modelo de thread Apartment
Modelo de thread livre
Modelo de thread neutro
Modelos de thread em CORBA
Modelo de thread simples
Modelo de thread mltiplo
254
255
UMA APLICAO PORTA-ARQUIVOS
256
257
ndice remissivo
.
.NET 16, 18, 19, 73, 156, 157, 158, 189
Palheta de Componentes 26 Console Consulte Aplicaes console CORBA 129, 131, 189, 254
D
Datas Interpretando horas 56 Rotinas de trabalho com 55 Trabalho com 54 Datasets Baseados em BDE 140 Baseados em DBExpress 181 Baseados em Interbase Express 160 Entendendo datasets 134 Eventos de 136 Famlias de 134 Query-type datasets 135 Stored procedure-type datasets 136 Table-type datasets 135 Tipos de 135 DBExpress 17, 20, 79, 80, 119, 120, 121, 123, 134, 145, 180, 181, 182, 183, 186, 205 Arquitetura 181 Datasets unidirecionais 181 Drivers 182 Executando comandos 187 Parmetros de conexo 183 Preparando datasets 186 Usando stored procedures 185 Usando tabelas 185 DCOM Consulte COM Delphi Ambiente de programao 23 Delphi 7.0 18 Delphi.NET 18 Enterprise 18 IDE 23 Janela principal 23 Professional 18 Standard 18
A
ActiveXDataObjetcs Consulte ADO ADO Arquitetura 148 Conectando com uma fonte 151 Conhecendo 149 Framework 147, 148, 150 Interface de programao 149 Modelo de objetos 150 ADOExpress 147, 150, 158 Componentes 150 Conectando com fontes de dados ADO 151 Conhecendo 150 Aplicaes console 17, 30, 77
B
BDE 17, 37, 77, 79, 80, 119, 120, 121, 123, 134, 138, 139, 140, 141, 142, 143, 144, 145, 159, 173, 181, 204, 207 BDE Administrator 140, 144 Cahcing Blob's 142 Database Desktop 145 Datasets Consulte Datasets Drivers 139 Ferramentas BDE 143 Handles 142 Manipulando transaes com 142 Passthrough SQL 143 Recursos avanados 141 Seu futuro 145 SQL Explorer 144 SQL Monitor 144 Transaes locais em 143
E C
C++ 19, 20, 31, 35 Classes Converses implcitas 50 Converss 49 Code Editor 24 Code Insight Consulte IDE COM 148 DCOM 124, 129, 130, 132, 133, 147, 149 COM+ 16, 17, 49, 73, 130, 132 Componentes EOP 35
F
Ferramentas BDE Consulte BDE Firebird 20, 120, 121, 134, 139, 159, 160, 161, 162, 167, 173, 174, 175, 176, 177, 181, 205, 213
258
I
IBX Consulte Interbase Express IDE Appbrowser 32 Code Insight Consulte IDE Encaixe de janelas 31 Navegao entre sees 32 Preenchimento de classes 31 TO-DO List 33 Interbase 17, 20, 78, 88, 120, 121, 134, 136, 138, 139, 147, 149, 152, 159, 160, 161, 162, 163, 167, 168, 173, 174, 175, 176, 177, 178, 181, 183, 204, 205, 213 Generators 162 Interbase Express 20, 159, 160, 161, 162, 173, 175, 177, 204 Arquitetura 161 Conexes com bancos usando 174 Datasets unidirecionais 162 E compatibilidade inter-plataformas 173 Extensibilidade 162 Nveis de isolamento de transaes 175 Transaes com a 174 Usando comandos com 176 InterbaseAdmin 177, 178
Atributos 36 Embutimento 36 Encapsulamento 36 Herana 36 Objeto 35 Polimorfismo 36 Orientao a objetos Consulte OOP
P
Palheta de Componentes 26 Project Manager 28
S
SDI 31 SOAP 18, 129, 189 Strings Concatenando strings 51 Copiando strings 52 Deletando strings 53 Formatando strings 53 Inserindo strings 53 Manipulao de 52
K
Kylix Kylix 3.0 20 O que ? 19 Open Edition 21 usando C++ 20 verses 21
T
TADOCommand 74, 147, 150, 151, 154, 155, 156 TADOConnection 147, 150, 151, 152, 153, 154 Conectando com uma fonte de dados via 151 Connection Editor 152 ConnectionString 151 TADODataset 134, 136, 151, 154, 156 TADOQuery 134, 136, 151, 154 TADOStoredProc 134, 136, 151 TADOTable 134, 135, 151 TBDEClientDataset 136, 140, 204 TClientDataset 136, 189, 191, 195, 202, 205 TCustomADODataset 134 TCustomClientDataset 135 TCustomSQLDataset 134 TDatabase 140, 141, 143 e TSession 140 Mtodos 141 TDataSource 176 TIBBackupService 161, 178 TIBConfigService 161 TIBCustomDataset 134, 161 TIBDatabase Propriedades de 174 Usando o Database Editor 174 TIBDataBase 161 TIBDataBaseInfo 161 TIBDataset 134, 136, 161, 162, 174, 204, 205 TIBDataSet 161 TIBEvents 161 TIBExtract 161 TIBGenerator 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173
M
Microsoft .NET 18 Modelos de interface Consulte SDI e MDI MS Acess 225, 226, 227, 229
O
Object Inspector 24 Object Pascal 34 Arquivos de cdigo-fonte 29 Arquivos do compilador 30 Orientao a objetos 35 Object Repository 27 Object Treeview 25 OLEDB Consulte ADO Componentes da tecnologia 149 Interface de programao 149 Provedores de dados 149 OOP 26, 35, 38 Ao 36
259
TIBInstall 161 TIBLicensingService 161 TIBLogService 161 TIBQuery 74, 134, 136, 161, 165, 166, 172 TIBRestoreService 161, 178 TIBSecurityService 161 TIBServerProperties 161 TIBSQL 161, 163, 164, 165, 166, 168, 169, 170, 171, 176, 177 Comandos com 176 Mtodos de 177 TIBSQLMonitor 161 TIBStaticalService 161 TIBStoredProc 134, 136, 161 TIBTransaction 161, 163, 174, 175, 176 Transaction editor 175 TIBUninstall 161, 178 TIBUpdateSQL 161 TIBValidationService 161 Tipos de dados 43 Arrays 46 Arrays dinmicos 47 Conjuntos 46 Records 47 Tipo boolean 45 Tipo variant 48 Tipos estruturados 45 Tipos real 44 Tipos simples 44 Tipos string 45 Tipos subrange 44 TNestedTable 134 TO-DO List Consulte IDE TQuery 134, 140 Transaes
em BDE 142 Transaes locais com BDE 143 Usando Interbase Express 174 TSession 140, 141 TSQLConnection 182, 183, 187 TSQLDataset 134, 136, 181, 182, 184, 185, 187, 205 TSQLQuery 134, 136, 181, 182, 184, 187 TSQLTable 134, 135, 181, 182, 185 TStoredProc 134, 136, 140, 143 TTable 74, 134, 140, 223
U
UDA 148 Unidades PAS Referncias circulares 40 Seo Finalization 40 Seo Implementation 39 Seo Initialization 39 Seo Interface 39 Universal Data Acess Consulte UDA
V
Visual Basic 31, 35
W
WEBServices 18, 19, 20, 21, 189
260

Curso

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Curso

Caricato da

Copyright:

Formati disponibili

DELPHI6 e tecnologias de bancos de dados

DELPHI6 e tecnologias de bancos de dados

DELPHI6 e tecnologias de bancos de dados

Delphi 6.0 e tecnologias de bancos de dados

DELPHI6 e tecnologias de bancos de dados

DELPHI6 e tecnologias de bancos de dados

DELPHI6 e tecnologias de bancos de dados

DELPHI6 e tecnologias de bancos de dados

DELPHI6 e tecnologias de bancos de dados

DELPHI6 e tecnologias de bancos de dados

DELPHI6 e tecnologias de bancos de dados

DELPHI6 e tecnologias de bancos de dados

DELPHI6 e tecnologias de bancos de dados

SGDB - Sistemas Gerenciadores de Banco de Dados

CURSO I DELPHI 6.0 E TECNOLOGIAS DE BANCOS DE DADOS

SGDB - Sistemas Gerenciadores de Banco de Dados

PARTE I DELPHI, KYLIX E O OBJECT PASCAL

SGDB - Sistemas Gerenciadores de Banco de Dados

CAPTULO 1 - VISO GERAL

SGDB - Sistemas Gerenciadores de Banco de Dados

Voc pode criar qualquer um destes tipos de aplicaes com o Delphi. 16

SGDB - Sistemas Gerenciadores de Banco de Dados

SGDB - Sistemas Gerenciadores de Banco de Dados

SGDB - Sistemas Gerenciadores de Banco de Dados

Figura. Uma viso cortada do Delphi.NET com o projeto ConvertIt.dpr aberto

Escolhendo uma linguagem de desenvolvimento

SGDB - Sistemas Gerenciadores de Banco de Dados

SGDB - Sistemas Gerenciadores de Banco de Dados

SGDB - Sistemas Gerenciadores de Banco de Dados

CAPTULO 2 - O AMBIENTE DELPHI

SGDB - Sistemas Gerenciadores de Banco de Dados

SGDB - Sistemas Gerenciadores de Banco de Dados

O Object Inspector exibindo a pgina de propriedades de um objeto.

O Object Inspector exibindo a pgina de eventos de um objeto.

SGDB - Sistemas Gerenciadores de Banco de Dados

Figura X: O Object TreeView exibindo os objetos em um container (Form1).

SGDB - Sistemas Gerenciadores de Banco de Dados

Figura Um viso cortada da Palheta de Componentes.

SGDB - Sistemas Gerenciadores de Banco de Dados

SGDB - Sistemas Gerenciadores de Banco de Dados

SGDB - Sistemas Gerenciadores de Banco de Dados

SGDB - Sistemas Gerenciadores de Banco de Dados

Alguns recursos importantes da IDE

SGDB - Sistemas Gerenciadores de Banco de Dados

Este o Object TreeView

Este o Object Inspector

FiguraX O Object Inspector encaixado na janela do ObjectTreeView.

SGDB - Sistemas Gerenciadores de Banco de Dados

procedure Teste(I: integer)

procedure Teste(I: integer); begin end;

SGDB - Sistemas Gerenciadores de Banco de Dados

SGDB - Sistemas Gerenciadores de Banco de Dados

SGDB - Sistemas Gerenciadores de Banco de Dados

Programao orientada a objetos

SGDB - Sistemas Gerenciadores de Banco de Dados

SGDB - Sistemas Gerenciadores de Banco de Dados

Type TSomeControl = class (TControl);

SGDB - Sistemas Gerenciadores de Banco de Dados

Programao estruturada e syntax

Unidades estruturadas e syntax

SGDB - Sistemas Gerenciadores de Banco de Dados

unit Unit1; interface uses {List of units goes here }

{Interface section goes here }

{Implementation section goes here }