Banco de Dados ReadOnly (para Delphi 1)
---------------------------------------

Por Gilberto Ferreira da Silva
Rio de Janeiro - Brasil

Verso 1.0
Novembro de 1996

>>>>>>>>>>>>> Use o editor do prprio Delphi para ler este arquivo <<<<<<<<<<<<<


Sumrio
-------

0. Histrico

1. Introduo

2. Instalao

3. Utilizao

4. Interface da Unit RDONLY

--------------------------------------------------------------------------------

0. Histrico
   ---------

Outubro de 1996: Verso Beta 1
Primeira Verso distribuda somente para alguns amigos testarem.

Outubro de 1996: Verso Beta 2
Resoluo de alguns problemas de alocao/liberao de memria.
Continuando ainda em testes preliminares.

Novembro de 1996: Verso 1.0
Mudana dos nomes das propriedades e mtodos.
Primeira Verso distribuda livremente.

--------------------------------------------------------------------------------

1. Introduo
   ----------

O Banco de Dados ReadOnly (abreviadamente RODB)  um conjunto de quatro
Componentes No Visuais Delphi 1 que permite a gravao (uma vez) e posterior
leitura (muitas vezes) de dados. Bem ao estilo de um Banco de Dados, com acesso
ao primeiro registro, ao prximo, ao anterior, ao ltimo, alm de acesso direto
pela chave e acesso direto pela posio fsica do registro (sem ndice), mas sem
capacidade de atualizao. Isto , aps a gravao inicial, os dados podem ser
apenas lidos.

Isto pode ser interessante para voc distribuir, por exemplo, catlogo de
produtos, lista de assinantes, etc. Quaisquer dados que, uma vez gravados, no
sero mais alterados, podem ser armazenados no Banco de Dados ReadOnly.

Tcnicamente, o RODB consiste de uma Unit, j compilada como RDONLY.DCU, que
deve ser usada para se instalar os quatro componentes na paleta Data Access. A
partir da, os componentes podem ser includos em quaisquer Formulrios e usados
como descrito aqui.

Este documento descreve brevemente o Banco de Dados ReadOnly, com nfase nos
procedimentos de Instalao e Utilizao. No so mencionados detalhes tcnicos
da implementao.

A seo 2, a seguir, descreve o processo de instalao dos componentes.

A seo 3 informa as propriedades e os mtodos disponveis em cada componente.

Na seo 4 est um trecho de interface da Unit RDONLY, com as declaraes
necessrias para a declarao dos quatro componentes. A declarao dos
componentes propriamente ditos no  includa.

Veja tambm os dois programas exemplo, um para gravao do Banco (ESRODBP.PAS),
e outro para leitura do Banco (LERODBP.PSD).  importante frisar que os
programas exemplo no esgotam todas as possibilidades de utilizao, nem
pretendem estabelecer padres de boa utilizao do Banco. Em particular, o
programa exemplo de leitura no usa a possibilidade de acesso direto (sem
ndice) aos dados.


Advertncia
-----------

O RODB, Verso 1.0,  fornecido no estado em que se encontra, sem quaisquer
garantias quanto ao funcionamento correto, quanto  performance ou quanto 
adequao s suas necessidades. Use-o por sua prpria conta e risco. O Autor no
aceita responsabilidade alguma em relao a danos ou prejuzos direta ou
indiretamente causados pela utilizao do Banco de Dados ReadOnly. Em
particular, o RODB foi desenvolvido para o Delphi 1. No  garantido que ele
funcione sob o Delphi 2.

O RODB  um produto Shareware. A verso no registrada pode ser distribuda
livremente, contanto que voc no cobre por isto e que a distribuio seja feita
usando o arquivo RODB.ZIP inalterado. No h limitao de tempo para a fase de
testes, nem h mensagens pedindo que voc registre. Entretanto, se voc vai
executar alguma aplicao que use o RODB fora do ambiente de desenvolvimento
Delphi, voc deve registrar.

Registrando, voc ganha:
------------------------
O fonte da Unit (RDONLY.PAS).
O direito de distribuir sua aplicao que use o RODB, sem nus adicionais.
Suporte diretamente do Autor, via e-mail. Usurios no registrados no tem
    suporte.

Entretanto, mesmo registrando, voc no pode:
---------------------------------------------
Redistribuir a unit compilada da verso registrada (RDONLY.DCU).
Redistribuir o fonte da unit (RDONLY.PAS).
Distribuir DLLs ou outras units que disponibilizem direta ou indiretamente os
    mtodos e propriedades dos componentes do RODB.

O Registro custa o equivalente a 25 dlares americanos, que voc deve enviar
para o Autor no endereo postal abaixo, em cheque pagvel no Brasil ou nos
Estados Unidos (nunca mande dinheiro em espcie pelo Correio), acompanhado da
indicao clara do seu Nome e do e-mail para o qual deve ser enviado o arquivo
RODB.ZIP. Presentemente, a nica alternativa de distribuio  atravs da
Internet.


Endereo do Autor
-----------------

Gilberto Ferreira da Silva
e-mail: gilberto.silva@poboxes.com
Endereo Postal:
Caixa Postal 9103
22.272-970 Rio de Janeiro - RJ
Brasil

--------------------------------------------------------------------------------

2. Instalao
   ----------

O procedimento abaixo pode ser usado para se instalar quaisquer componentes no
Delphi 1.

a. Crie um diretrio (por exemplo, C:\READONLY) e descompacte o arquivo de
   distribuio (RODB.ZIP). Isto vai criar os seguintes arquivos:

   esrodbp.dpr         Arquivo de Projeto do programa exemplo para Gravao do
                       Banco.

   esrodbu1.dfm        Arquivos da Unit do programa exemplo para Gravao do
   esrodbu1.pas        Banco.

   file_id.diz         Descrio resumida para BBS's.

   lerodbp.dpr         Arquivo de Projeto do programa exemplo para Leitura do
                       Banco.

   lerodbu1.dfm        Arquivos da Unit do programa exemplo para Leitura do
   lerodbu1.pas        Banco.

   manual_e.txt        Manual em Ingls.

   manual_p.txt        Este documento, manual em Portugus.

   rdonly.dcr          Arquivo com os cones da unit rdonly. Somente na verso
                       registrada.

   rdonly.dcu          Unit rdonly compilada.

   rdonly.pas          Fonte da unit rdonly. Somente na verso registrada.

   u_ordem.pas         Fonte da Unit comum aos dois programas exemplo. Esta unit
                       contm, basicamente, exemplos de rotinas de comparao.

b. Inicie o Delphi.

c. Na Barra de Menu, escolha Options e depois clique sobre Install Components...

d. No dilogo Install Components, clique sobre o boto Add...

e. No dilogo Add Module, clique sobre o boto Browse...

f. No dilogo seguinte, modifique a caixa de edio Listar Arquivos do Tipo para
   permitir arquivos *.DCU. Localize o arquivo rdonly.dcu e clique sobre o boto
   OK para prosseguir.

g. De volta ao dilogo Install Components, clique sobre o boto OK para
   prosseguir. O Delphi ir recompilar a Libray COMPLIB.DCL (isto demora alguns
   minutos...) e incluir os quatro componentes na paleta Data Access. Voc pode
   reconhece-los pelo Hint que aparece quando o indicador do Mouse se detm por
   alguns instantes sobre o cone respectivo. Os nomes dos componentes so os
   seguintes:

   1. TCReadOnlyDB (no Hint, CReadOnlyDB)
      Componente para o Banco de Dados, durante a fase de Gravao do Banco.

   2. TCReadOnlyIndex (no Hint, CReadOnlyIndex)
      Componente para os ndices, durante a fase de Gravao do Banco.

   3. TRReadOnlyDB (no Hint, RReadOnlyDB)
      Componente para o Banco de Dados, durante a fase de Leitura do Banco.

   4. TRReadOnlyIndex (no Hint, RReadOnlyIndex)
      Componente para os ndices, durante a fase de Leitura do Banco.

Para usar os programas exemplo, basta compilar e executar. Sinta-se livre para
estudar e modificar os programas  vontade para adapta-los ao seu gosto.

--------------------------------------------------------------------------------

3. Utilizao
   ----------

O RODB  um Banco de Dados que no tem Tabelas. Isto , voc no define Tables e
grava nelas. Mas voc define os seus records no seu programa e chama o mtodo
de gravao.

Esquema geral de funcionamento:
-------------------------------

A cada registro gravado, a Unit rdonly informa a posio fsica de gravao. A,
voc inclui uma entrada no ndice (ou nos ndices) adequados, passando a posio
e a chave respectivas como parmetros.

O qu, exatamente, est contido no registro, no importa para o RODB. Ele recebe
uma rea de um tamanho definido por voc e grava esta rea na prxima posio
disponvel. H um limite mximo para o tamanho do registro a ser gravado: 65.528
caracteres.

Na leitura, voc passa a chave e a Unit determina a posio e recupera o
registro. Adicionalmente aos ndices que voc houver criado, o RODB cria um
ndice virtual, chamado IndexIndex, que voc pode usar para saber quais so os
ndices que existem. Se voc deseja usar IndeIndex na fase da leitura, crie um
record com os seguintes campos (No necessariamente os mesmos nomes,  claro):

var
    IxIxRec = record
        IndexName: Str10;
        KeyLength: word;
        Population: longint;
        FirstOffset: longint;
        end;

onde
    IndexName representa o nome do ndice; Str10  definido como string [10].
    KeyLength informa o comprimento da chave do ndice, em bytes.
    Population  a quantidade de entradas do ndice.
    FirstOffset  a posio da primeira entrada do ndice no arquivo fsico do
        Banco.


Esqueleto de um programa de Gravao do Banco
---------------------------------------------

...
{ Definio do(s) registro(s) que voc vai gravar }
type
    registro = record
        Campo1: ...
        Campo2: ...
        ...  { Quantos campos voc quiser }
        end;

var
    Banco: TCReadOnlyDB;
    Index1: TCReadOnlyIndex;
    Index2: TCReadOnlyIndex;
    ...   { Quantos ndices voc quiser, tambm. Observe que estas declaraes
            so includas aqui pelo Delphi, a partir do seu desenho do
            Formulrio. }

{$F+} { Se voc quiser definir funes de comparao ou de acompanhamento da
        ordenao dos ndices. }

{ Veja os programas exemplo. Em particular, a unit u-ordem. }

function MinhaComparacao (var Key1, Key2): CompareResult;
begin
...
end; { MinhaComparacao }

{$F-}

procedure CriarBanco;
begin
Banco.CreateFiles;
    { Cria o arquivo do banco e mais dois temporrios.  }
Banco.AddIndex (Index1, @MinhaComparacao, KL1);
    { Aqui, voc vai usar a sua funo de comparao. KL1  o tamanho (fixo) da
      Chave do ndice Index1. }
Banco.AddIndex (index2, nil, KL2);
    { Aqui, voc est usando a comparao default do RODB. }

... { AddIndex para os outros ndices ...}

while not FimDosDados do
begin
Posicao := Banco.DBWrite (Registro, SizeOf (Registro));
Index1.AddEntry (Chave1, SizeOf (Registro), Posicao);
    { Chave1  o campo chave do ndice Index1. Observe que cada Registro pode
      ter um tamanho. O mesmo no ocorre com a chave de um ndice. }
Index2.AddEntry (Chave2, SizeOf (Registro), Posicao);
...
end;

Banco.DBClose (SortWatch);
    { Encerra a gravao do Banco: fecha o arquivo e remove os arquivos
      temporrios. Dependendo da quantidade de ndices e de registros gravados,
      este mtodo pode ser bastante demorado. SortWatch  o ponteiro para uma
      procedure, escrita por voc, que pode ser usada para se acompanhar o
      andamento da Ordenao sobre os ndices. Em particular,  recomendvel que
      voc inclua na sua procedure uma chamada a Application.ProcessMessages
      para permitir ao Windows fazer outras coisas que sejam necessrias
      concorrentemente. SortWatch pode tambm ser nil. }
...
end; { CriarBanco }

... { Outras procedures e functions. }



Esqueleto de um programa de Leitura do Banco
--------------------------------------------

...
{ Definio do(s) registro(s) que voc vai ler. }
type
    registro = record
        Campo1: ...
        Campo2: ...
        ... { os campos que voc gravou }
        end;

var
    Banco: TRReadOnlyDB;
    Index1: TRReadOnlyIndex;
    Index2: TRReadOnlyIndex;
    ... { Aqui, alm dos ndices que voc criou, voc pode tambm definir um
          para ter acesso  tabela de ndices. Basta setar a propriedade
          IndexName (em tempo de execuo ou no Object Inspector) para
          'IndexIndex'. Observe que estas declaraes so colocadas aqui pelo
          Delphi, a partir do seu desenho do Formulrio. }

{$F+} { Aqui voc deve definir exatamente as mesmas funes de comparao
        utilizadas no programa de gravao. }

{ Veja os programas exemplo. Em particular, a unit u_ordem. }

function MinhaComparacao (var Key1, Key2): CompareResult;
begin
...
end; { MinhaComparacao }

{$F-}

procedure AbrirBanco;
begin
Banco.DBOpen;
    { Abre o arquivo do banco e verifica sua integridade. }
Banco.OpenIndex (Index1, @MinhaComparacao);
    { Voc tem que usar A MESMA funo de comparao usada na criao. }
Banco.OpenIndex (Index2, nil);

... { OpenIndex para os outros ndices que voc quiser abrir ... }
end;

procedure FecharBanco;
begin
Index2.IndexClose;
Index1.IndexClose;
    {  bom fechar cada ndice que foi aberto para liberar a memria
      anteriormente alocada em Banco.OpenIndex }
Banco.DBClose;
end;

begin
AbrirBanco;

{ A partir deste ponto, voc passa a usar as rotinas de acesso ao Banco,
  descritas mais abaixo, nesta mesma seo. }

FecharBanco;
end.


Aps cada operao sobre o Banco, voc pode consultar a propriedade
Banco.DBErrorCode, que informa a ocorrncia de algum erro ou excesso no acesso.
Similarmente, aps cada operao sobre algum ndice, voc pode consultar a
propriedade Indice.IndexErrorCode, que informa a ocorrncia de algum erro ou
excesso no acesso ao ndice.

Tanto Banco.DBErrorCode quanto Indice.IndexErrorcode retornam zero para indicar
a ausncia de erro. Veja a tabela de erros completa na seo 4. No programa
exemplo de leitura (lerodbp.pas) h uma function de traduo dos possveis
valores de erro.


Mtodos e propriedades para a Gravao
--------------------------------------

procedure TCReadOnlyDB.CreateFiles
Cria o arquivo para o Banco de Dados e dois arquivos temporrios. Os arquivos
temporrios so removidos ao final da fase de gravao.

procedure TCReadOnlyIndex.AddIndex (var Ix: TCReadOnlyIndex;
                                                 PComp: PCompFunction; KL: word)
Adiciona a definio de um ndice ao Banco. O Banco j deve estar criado e
aberto. O ndice j deve ter recebido um nome vlido. O nome  vlido se  um
identificador Pascal vlido, exceto 'IndexIndex', este ltimo reservado para o
ndice de ndices.
Parmetros:
    IX: Um dos ndices j includos no Form.
    PComp: Ponteiro para uma function de comparao do tipo CompareFunction.
        Voc tambm pode passar "nil", caso em que o RODB fornece uma comparao
        default, equivalente  ordem ASCII crescente. A function apontada por
        Pcomp, se existente, deve ser declarada no modo "far".
        PCompFunction  declarado como ^CompareFunction; CompareFunction 
        declarado como function (var Key1, Key2): CompareResult; Key1 e Key2 so
        as duas chaves a serem comparadas; CompareResult  declarado como -1 ..
        +1 (isto , um sub-range), onde -1 indica que Key1 precede Key2, 0
        indica que Key1  igual a Key2 e +1 indica que Key1 segue Key2.
        Os programas exemplo usam o mecanismo descrito aqui.
    KL: Comprimento da chave, em bytes.

function TCReadOnlyDB.DBWrite (var Buff; Len: word): longint
Grava um registro no Banco.
Parmetros:
    Buff: Registro a ser gravado.
    Len: Comprimento do registro, em bytes.
    Valor de retorno: Posio absoluta de gravao do registro.

procedure TCReadOnlyDB.DBClose (SW: PSortWatchProc)
Faz as "arrumaes" finais, fecha o arquivo do Banco e remove os arquivos
temporrios. Dependendo da quantidade de ndices e de registros gravados, este
mtodo pode ser muito demorado. *** Nota: Sem dvida, este  um dos pontos que
precisa ser melhorado no RODB. A demora no fechamento dos ndices est
excessiva, apesar de no comprometer a performance na fase da leitura. Este
ponto ser cuidadosamente revisto para a prxima verso. Enquanto isso, 
fortemente recomendvel que seja usado o mecanismo da procedure de
acompanhamento (veja o parmetro SW).
Parmetro:
    SW: Ponteiro para uma procedure, escrita por voc, que pode ser usada para
        se acompanhar o andamento do Sort sobre os ndices. Em particular, 
        recomendvel que voc inclua na sua procedure uma chamada a
        Application.ProcessMessages para deixar o Windows fazer outras coisas
        que sejam necessrias concorrentemente. SW pode tambm ser "nil".
        PSortWatchProc  definido como ^SortWatchProc. SortWatchProc  definido
        como procedure (IxName: string; Phase: SortPass; RecNo: longint).
        IxName  o nome do ndice que est sendo ordenado; Phase  a etapa que
        est sendo cumprida; SortPass  definido como (Start, OneMore, Ending)
        (isto , uma enumerao); Start indica o incio da Ordenao, nenhum
        registro ainda lido; OneMore indica que mais um registro vai ser lido;
        Ending indica o fim da ordenao do ndice; por ltimo, RecNo  o nmero
        do registro que vai ser lido, caso SortPass = OneMore.
        A procedure apontada por SW, se existente, deve ser declarada no modo
        "far".
        O programa exemplo de gravao usa o mecanismo descrito aqui.

property TCReadOnlyDB.DBErrorCode: integer (read only, run time)
Cdigo de erro aps qualquer operao sobre o Banco.  zerada ao ser consultada.
Veja a tabela de erros, com as descries, no programa exemplo de leitura.

property TCReadOnlyDB.DBName: Str80 (read/write, design/run time)
Ttulo do arquivo fsico que passa a conter o Banco. Str80  definido como
string [80].

procedure TCReadOnlyIndex.AddEntry (var Key; BufLen: word; Position: longint)
Adiciona uma entrada ao ndice.
Parmetros:
    Key: Chave da entrada.
    BufLen: Comprimento do registro apontado por esta chave.
    Position: Posio absoluta em que o registro foi gravado.

property TCReadOnlyIndex.IndexErrorCode: integer (read only, run time)
Cdigo de erro aps qualquer operao sobre o ndice.  zerada ao ser
consultada.

property TCReadOnlyIndex.DBName: Str80 (read only, run time)
Ttulo do arquivo fsico do Banco. Str80  definido como string [80].

property TCReadOnlyIndex.KeyLength: word (read only, run time)
Comprimento da chave do ndice, em bytes.

property TCReadOnlyIndex.IndexName: Str10 (read/write, design/run time)
Nome do ndice para efeito do Banco. O nome deve ser um identificador Pascal
vlido, exceto 'IndexIndex', este ltimo reservado para o ndice de ndices.
Como no Pascal, maisculas e minsculas no fazem diferena. Str10  definido
como string [10].


Mtodos e propriedades para a Leitura:
--------------------------------------

procedure TRReadOnlyDB.DBOpen
Abre o Banco.

procedure TRReadOnlyDB.DBOpenIndex (var Ix: TRReadOnlyIndex;
                                                           PComp: PCompFunction)
Abre um ndice. A function apontada por PComp deve ser exatamente igual 
utilizada para a gravao do ndice, ou a pesquisa por valor da chave no ir
funcionar.
Parmetros:
    IX: Um dos ndices j includos no Form.
    PComp: Ponteiro para uma function de comparao do tipo CompareFunction.
        Veja o comentrio no mtodo TCReadonlyDB.AddIndex, acima, para maiores
        detalhes. A function fornecida aqui deve ser essencialmente a mesma
        fornecida para a criao do Banco; se no, a pesquisa pela chave no vai
        funcionar.

procedure TRReadOnlyDB.DBClose
Fecha o Banco. Como se trata de um Banco de leitura apenas, no h possibilidade
de perda de dados em disco se o Banco no for fechado. Entretanto, o mtodo
DBClose libera reas na memria antes alocadas pelo mtodo DBOpen.

procedure TRReadOnlyDB.PhysicalRead (CharNo: longint; var Buff; Len: word)
Executa uma leitura fsica sobre o Banco, a partir da posio e transferindo a
quantidade de caracteres indicadas nos parmetros.
Parmetros:
    CharNo: Posio absoluta do incio da leitura. A primeira posio  a
        posio zero.
    Buff: rea a ser preenchida com os dados lidos.
    Len: Quantidade de caracteres a serem lidos.

property TRReadOnlyDB.DBErrorCode: integer (read only)
Cdigo de erro aps qualquer operao sobre o Banco.  zerada ao ser consultada.

property TRReadOnlyDB.DBName: Str80 (read/write)
Ttulo do arquivo fsico do Banco. Str80  definido como string [80].

procedure TRReadOnlyIndex.IndexClose
Fecha o ndice. O ndice deve ser fechado para liberar espao na memria, apesar
de no haver possibilidade de perda de dados em disco.

procedure TRReadOnlyIndex.GetCurrentKey (var Key)
L a chave correspondente  entrada corrente do ndice.
Parmetro:
    Key: rea para conter a chave a ser lida.

procedure TRReadOnlyIndex.GetCurrent (var Buff; InfBufLen: word;
                                                               var BufLen: word)
L o registro correspondente  entrada atual do ndice.
Parmetros:
    Buff: rea para conter o registro a ser lido.
    InfBufLen: Comprimento da rea para o registro, em bytes.
    BufLen: Comprimento do registro efetivamente lido, em bytes.

procedure TRReadOnlyIndex.GoFirstKey (var Key)
L a chave correspondente  primeira entrada do ndice.
Parmetro:
    Key: rea para conter a chave a ser lida.

procedure TRReadOnlyIndex.GoFirst (var Buff; InfBuffLen: word; var BufLen: word)
Posiciona o ndice na primeira entrada e l o registro correspondente.
Parmetros:
    Buff: rea para conter o registro a ser lido.
    InfBufLen: Comprimento da rea para o registro, em bytes.
    BufLen: Comprimento do registro efetivamente lido, em bytes.

procedure TRReadOnlyIndex.GoLastKey (var Key)
L a chave correspondente  ltima entrada do ndice.
Parmetro:
    Key: rea para conter a chave a ser lida.

procedure TRReadOnlyIndex.GoLast (var Buff; InfBuffLen: word; var BufLen: word)
Posiciona o ndice na ltima entrada e l o registro correspondente.
Parmetros:
    Buff: rea para conter o registro a ser lido.
    InfBufLen: Comprimento da rea para o registro, em bytes.
    BufLen: Comprimento do registro efetivamente lido, em bytes.

procedure TRReadOnlyIndex.GoNextKey (var Key)
L a chave correspondente  prxima entrada do ndice.
Parmetro:
    Key: rea para conter a chave a ser lida.

procedure TRReadOnlyIndex.GoNext (var Buff; InfBuffLen: word; var BufLen: word)
Posiciona o ndice na prxima entrada e l o registro correspondente.
Parmetros:
    Buff: rea para conter o registro a ser lido.
    InfBufLen: Comprimento da rea para o registro, em bytes.
    BufLen: Comprimento do registro efetivamente lido, em bytes.

procedure TRReadOnlyIndex.GoPrevKey
L a chave correspondente  entrada anterior do ndice.
Parmetro:
    Key: rea para conter a chave a ser lida.

procedure TRReadOnlyIndex.GoPrev (var Buff; InfBuffLen: word; var BufLen: word)
Posiciona o ndice na entrada anterior e l o registro correspondente.
Parmetros:
    Buff: rea para conter o registro a ser lido.
    InfBufLen: Comprimento da rea para o registro, em bytes.
    BufLen: Comprimento do registro efetivamente lido, em bytes.

procedure TRReadOnlyIndex.FindKey (var KeyIn, KeyOut)
L a chave da entrada correspondente  chave fornecida. A pesquisa recupera uma
entrada com o valor de chave igual  chave fornecida (parametro var KeyIn), se
existente. Se a chave fornecida no estiver presente no ndice, a entrada
imediatamente a seguir  recuperada. Se a chave fornecida for posterior  ltima
entrada do ndice, a pesquisa retorna com IndexErrorCode = esNotFound para
indicar que nenhum registro foi encontrado. Para saber se a entrada retornada
tem ou no a chave exatamente igual  chave fornecida, use a propriedade Match
(veja mais abaixo).
Parmetros:
    KeyIn: Chave fornecida para a pesquisa.
    KeyOut: Chave lida do ndice.

procedure TRReadOnlyIndex.Find (var Key, Buff; InfBuffLen: word;
                                                               var BufLen: word)
Posiciona o ndice na entrada correspondente  chave fornecida e l o registro
associado. Veja o comentrio de TRReadOnlyIndex.FindKey, acima.
Parmetros:
    Key: Chave fornecida para a pesquisa.
    Buff: rea para conter o registro a ser lido.
    InfBufLen: Comprimento da rea para o registro, em bytes.
    BufLen: Comprimento do registro efetivamente lido, em bytes.

property TRReadOnlyIndex.IndexErrorCode: integer (read only, run time)
Cdigo de erro aps qualquer operao sobre o ndice.  zerada ao ser
consultada.

property TRReadOnlyIndex.BOT: boolean (read only, run time)
Indica o posicionamento sobre a primeira entrada existente no ndice.

property TRReadOnlyIndex.EOT: boolean (read only, run time)
Indica o posicionamento sobre a ltima entrada existente no ndice.

property TRReadOnlyIndex.Match: boolean (read only, run time)
Indica igualdade exata da chave fornecida com a entrada selecionada numa busca
pela chave. True: igualdade exata. False: entrada seguinte.

property TRReadOnlyIndex.DBName: Str80 (read only, run time)
Ttulo do arquivo fsico que contm o Banco. Str80  definido como string [80].

property TRReadOnlyIndex.KeyLength: word (read only, run time)
Comprimento da chave do ndice, em bytes.

property TRReadOnlyIndex.EntryNumber: longint (read/write, run time)
Nmero absoluto da entrada corrente do ndice. Para todos os ndices (exceto
para IndexIndex) a primeira entrada  a de nmero 0 (zero). A primeira entrada de
IndexIndex  a de nmero -1 (menos um). Voc pode atribuir um valor a
EntryNumber e depois chamar GetCurrent para recuperar o registro corrente.

property TRReadOnlyIndex.Connected: boolean (read only, run time)
Indica se o ndice j est ou no conectado a um Banco de Dados. H operaes
que exigem que ndice esteja no conectado, e h outras que exigem que ele
esteja conectado.

property TRReadOnlyIndex.IndexName: Str10 (read/write, design/run time)
Nome do ndice para efeito do Banco. O nome deve ser um identificador Pascal
vlido. O nome 'IndexIndex' pode ser usado para se acessar o ndice de ndices.
Como no Pascal, maisculas e minsculas no fazem diferena. Str10  definido
como string [10].

--------------------------------------------------------------------------------

4. Interface da Unit RDONLY
   ------------------------

unit Rdonly;

interface

uses
    SysUtils,
    Classes;

type
    Str10           = string [10];
    Str80           = string [80];
    CompareResult   = -1 .. +1;
        { CompareResult (A, B) = -1 if A precedes B; 0 if A  equals  B; and
                                                            +1 if A follows  B }
    CompareFunction = function (var Key1, Key2): CompareResult;
    PCompFunction   = ^CompareFunction;
    SortPass = (Start, OneMore, Ending);
    SortWatchProc   = procedure (IxName: string; Phase: SortPass;
                                                                RecNo: longint);
    PSortWatchProc  = ^SortWatchProc;

const
    { Tabela de Cdigos de Erro }
    esNoError            =    0; { Nenhum erro }
    esDBNotOpen          =   -1; { Banco no aberto }
    esDBNotClosed        =   -2; { Banco no fechado }
    esFileAccessError    =   -3; { Erro de acesso ao arquivo fsico }
    esFileOpenError      =   -4; { Erro na abertura do arquivo fsico }
    esCorruptDataFile    =   -5; { Arquivo fsico corrompido }
    esNotAssigned        =   -6; { ndice sem nome (IndexName) }
    esBadKeyValue        =   -7; { Valor da chave incorreto }
    esCreateError        =   -8; { Erro durante a criao do Banco }
    esKeysNotSameSize    =   -9; { Chave de tamanho diferente do definido }
    esBadIndexName       =  -10; { Nome do ndice ilegal }
    esSameNameIndex      =  -11; { Nome de ndice duplicado }
    esShortBuffer        =  -12; { Advertncia: Buffer pequeno }
    esNotConnected       =  -13; { ndice no associado ao Banco }
    esAlreadyConnected   =  -14; { ndice j associado ao Banco }
    esOutOfMemory        =  -15; { Memria Insuficiente }
    esMaxIndexesExceeded =  -16; { Quantidade mxima de ndices excedida }
    esInvalidKeyLength   =  -17; { Tamanho invlido para a chave }
    esNoCurrentRecord    =  -18; { No h registro atual }
    esNotFound           =  -19; { Registro no encontrado }
    esInvalidRecLength   =  -20; { Tamanho invlido para o registro }
    esNonRegistered      =  -21; { A verso no registrada exige o Delphi }

{ fim da interface}

--------------------------------------------------------------------------------

Fim de MANUAL.TXT

