Hb_CreateTemp() com SQLRDD

[oribeiro]

Pessoal,

Uso muito o hb_createtemp() no meu sistema e com DBFCDX eu não tenho problema, mas quando migrei para SQLRDD passou a dar erro:

No hb_createtemp eu inclui o parâmetro "DBFCDX" e funcionou, mas o dbDrop() trava a aplicação.

Uso assim:

   /////////////////////////////////////////////////
   // Arquivo Temporário, no xHarbour 1.2 Somente //
   // Cria o Arquivo na memória (não usa o Disco) //
   /////////////////////////////////////////////////
   Hb_DbCreateTemp("Clientes",{{ "Nombre",    "C", 40, 0 },;
                               { "Direccion", "C", 50, 0 },;
                               { "Telefono",  "C", 12, 0 },;
                               { "Edad",      "N",  2, 0 },;
                               { "Productos", "C", 10, 0 },;
                               { "Nivel",     "N",  2, 0 }}, "DBFCDX")

   // Seleciona o Arquivo criado na memória e usa os comandos comuns de tratamento dos registros //
   Select("Clientes")
   OADbAppend()
   replace nombre    with "Oscar Ribeiro"
   replace Direccion with "RUA MARCIA PIERRONI, 999"
   replace Telefono  with "55 11 4025-1234"
   OADbAppend()
   replace nombre    with "Marco Ribeiro"
   replace Direccion with "RUA MARCIA PIERRONI, 999"
   replace Telefono  with "55 11 4025-1234"
   OADbAppend()
   replace nombre    with "Oscar Ribeiro Neto"
   replace Direccion with "RUA MARCIA PIERRONI, 999"
   replace Telefono  with "55 11 4025-1234"
   browse()

   // Cria o indice do arquivo também na memória //
   index on nombre to clientes
   Seek "Marco Ribeiro"
   browse()

   // Fecha o arquivo na memória //
   Clientes->(DBCLOSEAREA())

   // Apaga o arquivo da memória //
   dbdrop("MEM:Clientes")

 

[sistem]

Function CriDbfTempRomi()
Local aCampos

   aCampos := {}
   aAdd( aCampos , { "cod_romi"  , "C" , 10 , 0 } )
   aAdd( aCampos , { "dat_romi"  , "D" , 08 , 0 } )
   aAdd( aCampos , { "dmv_romi"  , "D" , 10 , 0 } )
   aAdd( aCampos , { "ven_romi"  , "C" , 03 , 0 } )
   aAdd( aCampos , { "rot_romi"  , "C" , 03 , 0 } )
   aAdd( aCampos , { "tra_romi"  , "C" , 03 , 0 } )
   aAdd( aCampos , { "sta_romi"  , "C" , 01 , 0 } )
   aAdd( aCampos , { "cli_romi"  , "C" , 04 , 0 } )
   aAdd( aCampos , { "fam_romi"  , "C" , 02 , 0 } )
   aAdd( aCampos , { "pro_romi"  , "C" , 04 , 0 } )
   aAdd( aCampos , { "ser_romi"  , "C" , 02 , 0 } )
   aAdd( aCampos , { "prm_romi"  , "C" , 10 , 0 } )
   aAdd( aCampos , { "qtd_romi"  , "N" , 09 , 3 } )
   aAdd( aCampos , { "prc_romi"  , "N" , 11 , 2 } )
   aAdd( aCampos , { "com_romi"  , "N" , 09 , 3 } )
   aAdd( aCampos , { "des_romi"  , "N" , 09 , 3 } )
   aAdd( aCampos , { "seg_romi"  , "C" , 05 , 0 } )
   aAdd( aCampos , { "obs_romi"  , "C" , 99 , 0 } )
   aAdd( aCampos , { "usu_romi"  , "C" , 08 , 0 } )
   aAdd( aCampos , { "tim_romi"  , "C" , 16 , 0 } )
   Hb_DbCreateTemp("tempromi", aCampos, "DBFCDX")

   INDE ON tempromi->cli_romi+tempromi->ven_romi+tempromi->rot_romi TAG "temprom1" TO ("tempromi") Memory Additive
   INDE ON tempromi->cod_romi+tempromi->seg_romi+tempromi->cli_romi TAG "temprom2" TO ("tempromi") Memory Additive
   INDE ON tempromi->seg_romi+tempromi->cli_romi+tempromi->fam_romi+tempromi->pro_romi TAG "temprom3" TO ("tempromi") Memory Additive

Return nil

faço assim, quer dizer fazia e dava tudo certo, obs: uso sqlrdd

[oribeiro]

Valeu Sputnik,

Em vez de "Index on ... memory", eu uso "Index on... temporary" mas acho que o resultado é o mesmo.

Mas como você apaga o arquivo da memória depois de usá-lo?

Eu utilizo o dbdrop("mem:arquivo") mas com SQLRDD o sistema está travando justamente nesse comando.

 

[sistem]

sim

[oribeiro]

Notei que você está utilizando em vários pontos do seu sistema, porque será que o meu está travando quando utilizo o SQLRDD ?

O mesmo programa, sem SQLRDD, vai que vai.

Tem alguma idéia?

[sistem]

oribeiro, aqui nao trava por este motivo não tenho ideia, uso da mesma maneira que vc.

tentei ate fazer travar aqui(test) e nao consegui

[miragerr]

Ola... Bom dia

 

Oscar, porque você não usa comandos em SQL mesmo, criando a tabela temporaria em SQL, é muito mais pratico e muito mais seguro.

 

//apaga a tabela caso ela já exista
Array_SQL( "DROP TABLE IF EXISTS tempo2;" )

TEXT INTO cCmd

				CREATE TEMPORARY TABLE IF NOT EXISTS `tempo2` ( ::**::
				  `sequencia`   char(6) DEFAULT NULL, ::**::
				  `registro`    char(10) DEFAULT NULL, ::**::
				  `dados_1`     varchar(2000) DEFAULT NULL, ::**::
				  `chave_bloco` varchar(2000) DEFAULT NULL, ::**::
				  `dbf_recno`   bigint(15) NOT NULL DEFAULT 0, ::**::
				  `sr_recno`    bigint(15) NOT NULL AUTO_INCREMENT, ::**::
				  UNIQUE KEY `sr_recno` (`sr_recno`), ::**::
				  KEY `_001` (`registro`,`sr_recno`) ::**::
				) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;

		ENDTEXT

//Cria a TABELA ja com os INDICES
		Array_SQL( cCmd, "_TABELA_TEMPO2" )

//apaga a tabela
Array_SQL( "DROP TABLE IF EXISTS tempo2;" )

 

Prático e rápido, e não precisa se preocupar, se você criar em varias estações, o SGDB cria a partir da sua instância

 

Espero ter ajudado.

 

[emotta]

Não vejo vantagem em criar arquivo temporario em bases SQL. Se é temporario crie na própria máquina na pasta TEMP do computador e sendo DBF mesmo... Vc vai evitar trafego na rede e ganhar um enorme tempo.

Porem o melhor caminho é fazer como foi falado acima, usar SELECTs e trazer tudo em memória e trabalhar com isso... 

Vai por mim, não tem sentido nenhum (e nem vantagem) trabalhar com tabelas temporarias no SQL, vc só vai sobrecarregar o banco e criar trafego desnecessário.

[oribeiro]

Obrigado a todos pela ajuda.

Estou ainda tentando descobrir porque o meu dbdrop() trava o sistema.

Vocês sabem se o comando FErase("MEM:Clientes")  faz a mesma função do  dbDrop("MEM:Clientes") ?

O comando FErase() não trava, mas eu não sei se ele está mesmo apagando o arquivo na memória.

Tentei fazer um teste, mas depois que eu fecho o arquivo de memória  Clientes->(DBCLOSEAREA()) não sei mais como reabrí-lo para ver se ele ainda está lá.

 

[kapiaba]

	IF USED()
	

[oribeiro]

João,

Valeu pela sugestão, mas eu quero um comando para reabrir um arquivo de memória para ver verificar se o comando FErase() o apagou mesmo da memória ou não.