Demora no RegisterAutoMapping com base grande

[Jose Abilio]

boa tarde amigos,
estou com uma dificuldade na inicialização de um sistema que eu estou
fazendo utilizando o tiOPF,
Acontece que quando a base de dados estava com poucos dados, de teste
apenas, o sistema fazia a rotina de fazer o mapping das classes nas
tabelas rapidinho, ai eu fiz um aumento de informações nas tabelas,
chegando a ter tabelas com mais de 1 milhão de registros, ai acontece
que quando se vai fazer o mapping das classe com essa situação o
sistema demora muito para fazer isso, parece que além de fazer o
mapping ele carrega todos esses dados na memória.
Não teria como deixar esse procedimento mais rapido no inicio?
se ele além de fazer o mapping ele não carregar os dados na memoria,
se é isso o que está ocorrendo.

se sim como fazer isso?

ainda não peguei muito bem essa framework mas estou gostando dela, só
isso é que está me deixando com o pé atraz.

[edregis]

Olá.
No modo AutoMapping realmente o tiOPF vai trazer todos os registros
pra memória, o que deve estar ocasionando a lentidão no seu sistema.
Para resolver isso, somente utilizando o modo HardCoded, pois aí voce
poderá trazer do banco somente o que interessa.

Edelson.

[Jose Abilio]

Amigo, obrigado pela resposta,
mas me perdoe pela falta de conhecimento nesta framework, mmas como
fazer esse automapping utilizando o modo HardCoded?
o que eu devo fazer para que eu consiga esta performace desejada no
inicio de minhas aplicações?

[edregis]

José, acho que voce está confundindo as coisas...
Você tem que escolher ou AutoMapping, ou HardCoded... e existe ainda
uma terceira opção que seria o DBIndependet, que é uma mescla das duas
primeiras opções.
Aqui mesmo no forum tem um post do Diogo Augusto que exemplifica um
HardCoded básico, acho que voce pode dar uma olhada.
O link para o post é:
http://groups.google.com/group/tiopf_br/browse_thread/thread/53d0e1dab884895b/f15d02cdfe65a225?lnk=gst&q=crud#f15d02cdfe65a225
Uma boa maneira de voce entender tambem é dar uma olhada nos Demos do
tiOPF. Acho que a maioria dos Demos tem as tres maneiras de persistir
dados implementadas.
Mas sinceramente, eu já estou fazendo testes a 3 meses com o tiOPF, e
a conclusão que chegamos aqui na empresa é: iremos abandonar o mesmo!
É muito confuso, e trabalhoso de se implementar. (opnião minha)

Edelson.

[Jose Abilio]

Muito obrigado amigo,
vou olhar com certeza os demos, estou fazendo essas perguntas pois
estou engatinhando nesta FrameWork.
Mas com certeza vou verificar a experiencia do máximo de programadores
possiveis que utilizem esta frame antes
de desenvolver algum sistema com ela.

On 23 jun, 13:41, edregis <edre...@gmail.com> wrote:
> José, acho que voce está confundindo as coisas...
> Você tem que escolher ou AutoMapping, ou HardCoded... e existe ainda
> uma terceira opção que seria o DBIndependet, que é uma mescla das duas
> primeiras opções.
> Aqui mesmo no forum tem um post do Diogo Augusto que exemplifica um
> HardCoded básico, acho que voce pode dar uma olhada.

> O link para o post é:http://groups.google.com/group/tiopf_br/browse_thread/thread/53d0e1da...

[Rafael Vieira]

José poderia me ajudar com automapping

Consegui fazer as classes lerem os dados do banco mas não consigo
gravar
os dados segue abaixo a minha unit...script das tabelas e o
autommaping que fiz



CREATE TABLE TBPESSOAS(
OID INTEGER NOT NULL,
NOME VARCHAR(20),
SOBRENOME VARCHAR(60),
CONSTRAINT PK_TBPESSOAS PRIMARY KEY(OID)
);


CREATE TABLE TBTELEFONES(
OID INTEGER NOT NULL,
TBPESSOAS_OID INTEGER NOT NULL,
NUMERO VARCHAR(25),
CONSTRAINT PK_TBTELEFONES PRIMARY KEY(OID)
);




ALTER TABLE TBTELEFONES ADD CONSTRAINT FK_TBTELEFONES_CODPESSOA
FOREIGN KEY (TBPESSOAS_OID) REFERENCES TBPESSOAS(OID) ON DELETE
CASCADE ;


TMapeamento = class
public
class procedure RegistrarMapeamentos;
end;
{ Classe para listar os telefones }
TTelefones = class(TtiObjectList)
private
function getItems(i : Integer): TTelefone; reintroduce;
procedure SetItems(i: Integer; const value :
TTelefone);reintroduce;
public
property Items[i:Integer]: TTelefone read getItems write
SetItems;
procedure Add(AObject : TTelefone);reintroduce;
procedure Clear;override;
procedure Read;override;
procedure Save;override;
function Find(str : String): TTelefone; reintroduce;
end;

TTelefone = class(TtiObject)
private
FNumero : String;
procedure setNumero(const strNumero : String);
function getNumero : String;
protected
procedure SetOwner(const value : TTelefones); reintroduce;
function GetOwner: TTelefones; reintroduce;
public
constructor create; override;
destructor destroy; override;
property Owner: TTelefones read getOwner write SetOwner;
published
property Numero: String read getNumero write SetNumero;
end;

{ Classe para listar as Pessoas }
TPessoas = class(TtiObjectList)
private
function getItems(i : Integer): TPessoa; reintroduce;
procedure SetItems(i: Integer; const value :
TPessoa);reintroduce;
public
property Items[i:Integer]: TPessoa read getItems write
SetItems;
procedure Add(AObject : TPessoa);reintroduce;
procedure Clear;override;
procedure Read;override;
procedure Save;override;
function Find(str : String): TPessoa; reintroduce;
end;

TPessoa = class(TtiObject)
private
FNome : String;
procedure setNome(const strNome : String);
function getNome : String;
protected
procedure SetOwner(const value : TPessoas); reintroduce;
function GetOwner: TPessoas; reintroduce;
public
constructor create; override;
destructor destroy; override;
property Owner: TPessoas read getOwner write SetOwner;
published
property Nome: String read getNome write SetNome;
end;


implementation

{ TMapeamento }

class procedure TMapeamento.RegistrarMapeamentos;
begin
with GTIOPFManager.ClassDBMappingMgr do
begin
{ Telefones }
RegisterMapping( TTelefone, 'TBTELEFONES', 'OID', 'OID',
[pktDB] );
RegisterMapping( TTelefone, 'TBTELEFONES', 'Numero', 'NUMERO' );
RegisterCollection( TTelefones, TTelefone );

{ Pessoas }
RegisterMapping( TPessoa, 'TBPESSOAS', 'OID', 'OID', [pktDB] );
RegisterMapping( TPessoa, 'TBPESSOAS', 'Nome', 'Nome' );
RegisterCollection( TPessoas, TPessoa );

end;
end;

{ TTelefones }

procedure TTelefones.Add(AObject: TTelefone);
begin
{chama método herdado Add}
inherited Add(AObject);
end;

procedure TTelefones.Clear;
begin
inherited;
//
end;

function TTelefones.Find(str: String): TTelefone;
begin
//
end;

function TTelefones.getItems(i: Integer): TTelefone;
begin
//
end;

procedure TTelefones.Read;
begin
inherited;
//
end;

procedure TTelefones.Save;
begin
inherited;
//
end;

procedure TTelefones.SetItems(i: Integer; const value: TTelefone);
begin
//
end;

{ TTelefone }

constructor TTelefone.create;
begin
inherited;
//
end;

destructor TTelefone.destroy;
begin
//
inherited;
end;

function TTelefone.getNumero: String;
begin
//
end;

function TTelefone.GetOwner: TTelefones;
begin
//
end;

procedure TTelefone.setNumero(const strNumero: String);
begin
//
end;

procedure TTelefone.SetOwner(const value: TTelefones);
begin
//
end;

{ TPessoa }

constructor TPessoa.create;
begin
inherited;
//
end;

destructor TPessoa.destroy;
begin
//
inherited;
end;

function TPessoa.getNome: String;
begin
//
end;

function TPessoa.GetOwner: TPessoas;
begin
//
end;

procedure TPessoa.setNome(const strNome: String);
begin
//
end;

procedure TPessoa.SetOwner(const value: TPessoas);
begin
//
end;

{ TPessoas }

procedure TPessoas.Add(AObject: TPessoa);
begin
inherited Add(AObject);
end;

procedure TPessoas.Clear;
begin
inherited;
//
end;

function TPessoas.Find(str: String): TPessoa;
begin
//
end;

function TPessoas.getItems(i: Integer): TPessoa;
begin
//
end;

procedure TPessoas.Read;
begin
inherited;
//
end;

procedure TPessoas.Save;
begin
inherited;
//
end;

procedure TPessoas.SetItems(i: Integer; const value: TPessoa);
begin
//
end;

[Rafael Vieira]

esqueci de dizer uma coisa...quando faço um TPessoas.Read se eu for
tentar a propriedade count em seguida vai me mostrar a quantidade de
resgistros do banco blz, ms se eu tentar acessar os campos dos
objetos...estes sempre estão vazios...creio que o mapeamento tá
incorreto