Club Builder

[Adrián]

Hola a todos.


Alguien sabe como poder utilizar las bases de datos btrieve de Novell.

Estos son bases con archivos .btr .Necesito poder leerlas para poder migrar los datos que estas contienen a otro motor de base de datos.


Gracias.

[bosoft]

sobre btrieve o pervasive, lo que quieras, pero tendras que saber la estructura de datos.

Si la conoces te puedo hacer una pequeña aplicacion para convertir los datos en txt e importarlos con acces o algo parecido

Saludos, Bosoft

[Adrián]

Desde ya muhas gracias por tu respuesta.

Esta es manejada por un sistema hecho en Visual Basic para DOS el cual necesito hacerle una interface para modificarle datos masivamente y luego ingresarlos nuevamente.
Lo que no se es como poder llegar a manejar este tipo de base ya que no encuentro nada para poder trabajar con esta, es decir no se con que conectarme para poder trabajarla.

Te paso el archivo .edt que seria la estructura de una de las bases de las que tengo que trabajar.

Si me podes pasar un ejemplo reducido de código y de que necesito para implementarlo te agradecería.

Saludos, Q100.

[bosoft]

para trabajar con btrieve (dos o win) debes tener el enlace. Si es para win deberas ademas tener instalado el pervasive sql.

lo que me imagino que quieres es alterar algun campo y dejar la misma base de datos. Para eso te haré un pequeño programa en Dos con turboc 2 desde donde enlazaras a btrieve. Si coneces el turbo C no creo que tengas problemas.

Por cierto, pasame la struct del archivo ( se te ha olvidado) y necesitaria saber lo siguiente:
Desde comados DOS: BUTIL -STAT (nombre fichero)

saludos bosoft.

[Adrián]

OK, si es verdad se me paso mandarte el archivo de la estructura.

Te paso el link con un .zip que tiene todo lo de la base que seria una de todas las que tengo que trabajar.

http://www.geocities.com/adrian_tnh/btr_dsc_edt_stat.zip

Si podes pasarme un ejemplo en turbo C de como trabajar esta base para leer y escribir seria espectacular.

Te agradesco mucho la ayuda que me estas prestando.

Gracias. Q100

[bosoft]

lo que te voy a pasar seran varios ficheros .C y .H para que compiles con turbo C. Te pasare un ejemplo de leer y escribir en el archivo. Desde ahi tu solito.

Para mañana o pasado, porque hoy voy liadillo

Saludos, Bosoft.

PD: pasame el resultado del "butil" en una copia txt.

[bosoft]

upsss
estaba en el zip. Lo que no entiendo es la structura. Yo de ese lenguaje ni idea. ¿podrias pasarla en C de toa la vida?

saludos bosoft.

Edito para decirte que el archivo que me has mandado no tiene datos. Si es posible mandame alguno con datos para hacer yo las pruebas del programita. Para saberlo con el butil -stat te lo pone en total records. Busca el que menos tenga y ocupe poco.

Saludos Bosoft.

[Adrián]

Sobre la estructura yo tampoco se como verla porque no tengo el codigo fuente ni algo que pueda ver la estructura de la base, lo unico que tenia es el archivo .edt que creo es la estructura de la base.

Te paso otro .zip con una base con algunos datos.



http://www.geocities.com/adrian_tnh/lgastock.zip


Igualmente si tenes algun ejemplo con lo que necesito para poder leer y escribir sobre una base de este tipo estaria perfecto, yo luego me fijo como trabajarla.


Muchas gracias.

[TOÑO]

Hace mucho tiempo, te voy a lanzar un monton de codigo para que los estudies, esta sacado de varios trozos de programa, espero que valga para algo


necesitas btrieve.exe
inicializa el motor de base de datos.

BTRIEVE /M:30 /P:1024 /F:50


#include "btrieve.h"

Algo de codigo:

class CBtrrxxxx // creaba una clase para manejarlo mejor
{
public:
CBtrvPlnPro();
CBtrvPlnPro(char *dir);

void open(char *dir);
int btrv (int opCode, BTRV_xxxxx & reg, int nkey);
void close();

BTRV_xxxx reg; // la estructura de datos
char *fcb;
};

en el constructor abria el fichero,
en el destructor cerra

Lo gordo:
int CBtrrxxxx ::btrv(int opCode, BTRV_A& reg, int nkey)
{
int len = sizeof (BTRV_A);
int status;

if (opCode == BF_STAT)
{
char buf[300];
char key[100];

len = 300;
status = BTRV (opCode, fcb, buf, &len, key, 0);
if (!status)
memcpy (&reg, (buf+6), 4);
return (status);
}

if ((opCode == BF_DIRECT) || (opCode == BF_POSITION))
{
char clave[80];
status = BTRV (opCode, fcb, (char *) &reg, &len, clave, nkey);
return (status);
}

switch (nkey) // las claves
{
case 0:
int key0;
key0 = reg.codigo;
status = BTRV (opCode, fcb, (char *) &reg, &len, (char *)&key0, 0);
break;
}
return (status);
} /* End Cbtrvxxxxx::btrv () ***
**************************/




abrir;
int ret;
char fileP[60];
sprintf (fileP, "%s\\fichero.DAT", dir);
ret = BTRV (BF_OPEN, fcb, NULL, NULL, fileP, 0);
//if (ret == error)


Leer un fichero

memset(&btrvc ->reg,EOS,sizeof(btrvc ->reg));
btrvc ->reg.codigo = codigo;

int ret = btrvc ->btrv(BF_GETEQ,btrvc->reg,0);
while (ret == 0 )
{
ret = btrvc ->btrv(BF_GETNEXT,btrvc->reg,0);
}

delete(btrvc);




ir directo a un registro

Cbtrvxxxxx *btrvc = new Cbtrvxxxxx

memset(&btrvc ->reg,EOS,sizeof(btrvc ->reg));
memcpy(&btrvc ->reg,&posItem,4);
int ret = btrvc ->btrv(BF_DIRECT,btrvc->reg,0);
long codigo = btrvc ->reg.codigo;













el codigo fuente de btrv

/* */
/* Borland's Turbo C Version 2 interface to the */
/* Btrieve Record Manager, version 4, 5, 5.1 */
/* */

#include <dos.h>
#define BTR_ERR 20 /* record manager not started */
#define BTR_INT 0x7B /* Btrieve interrupt vector */
#define BTR2_INT 0x2F /* multi-user interrupt vector */
#define BTR_VECTOR BTR_INT * 4 /* offset for interrupt */
#define BTR_OFFSET 0x33 /* Btrieve offset within segment */
#define VARIABLE_ID 0x6176 /* id for variable length records - 'va' */
#define _2FCODE 0xAB00 /* function code for int 2F to btrieve */



/* For Compact, Large, and Huge memory models */
/* LMODEL means 32-bit pointers in use */

#if defined(__COMPACT__) || defined(__LARGE__) || defined(__HUGE__)
#define LMODEL 1
#endif



/* ProcId is used for communicating with the Multi Tasking Version of */
/* Btrieve. It contains the process id returned from BMulti and should */
/* not be changed once it has been set. */
/* */

static unsigned ProcId = 0; /* initialize to no process id */
static char MULTI = 0; /* flag set to true if MultiUser */
static char VSet = 0; /* flag set to true if checked version */

int BTRV (int OP, char *POS_BLK, char *DATA_BUF, int *DATA_LEN,
char *KEY_BUF, int KEY_NUM)
{
union REGS b_regs; /* define registers */

struct SREGS b_sregs; /* define segment registers */

struct BTRIEVE_PARMS /* structure passed to Btrieve Record Manager */
{
char *BUF_OFFSET; /* callers data buffer offset */
#ifndef LMODEL
int BUF_SEG; /* callers data buffer segment */
#endif
int BUF_LEN; /* length of data buffer */
char *CUR_OFFSET; /* user position block offset */
#ifndef LMODEL
int CUR_SEG; /* user position block segment */
#endif
char *FCB_OFFSET; /* offset of disk FCB */
#ifndef LMODEL
int FCB_SEG; /* segment of disk FCB */
#endif
int FUNCTION; /* requested function */
char *KEY_OFFSET; /* offset of user's key buffer */
#ifndef LMODEL
int KEY_SEG; /* segment of user's key buffer */
#endif
char KEY_LENGTH; /* length of user's key buffer */
char KEY_NUMBER; /* key of reference for request */
int *STAT_OFFSET; /* offset of status word */
#ifndef LMODEL
int STAT_SEG; /* segment of status word */
#endif
int XFACE_ID; /* language identifier */
} XDATA;

int STAT = 0; /* status of Btrieve call */

/* */
/* Check to see that the Btrieve Record Manager has been started. */
/* */

if (!VSet) /* if we don't know version of Btrieve yet */
{
VSet = 1;
b_regs.x.ax = 0x3000; /* check dos version */
int86x (0x21, &b_regs, &b_regs, &b_sregs);

if ((b_regs.x.ax & 0x00FF) >= 3) /* if DOS version 3 or later */
{
b_regs.x.ax = _2FCODE;
int86x (BTR2_INT, &b_regs, &b_regs, &b_sregs);
MULTI = ((b_regs.x.ax & 0xFF) == 'M');/* if al is M, bmulti is loaded */
}
}

if (!MULTI)
{ /* if bmulti not loaded */
b_regs.x.ax = 0x3500 + BTR_INT;
int86x (0x21, &b_regs, &b_regs, &b_sregs);
if (b_regs.x.bx != BTR_OFFSET)
return (BTR_ERR);
}

/* Read segment registers and initialize segment part of addresses to */
/* user's data segment. */
/* */

segread (&b_sregs);
#ifndef LMODEL
XDATA.BUF_SEG = XDATA.CUR_SEG = XDATA.FCB_SEG =
XDATA.KEY_SEG = XDATA.STAT_SEG = b_sregs.ss;
#endif

/* */
/* Move user parameters to XDATA, the block where Btrieve expects them.*/
/* */

XDATA.FUNCTION = OP;
XDATA.STAT_OFFSET = &STAT;
XDATA.FCB_OFFSET = POS_BLK;
XDATA.CUR_OFFSET = POS_BLK + 38;
XDATA.BUF_OFFSET = DATA_BUF;
XDATA.BUF_LEN = *DATA_LEN;
XDATA.KEY_OFFSET = KEY_BUF;
XDATA.KEY_LENGTH = 255; /* use max since we don't know */
XDATA.KEY_NUMBER = KEY_NUM;
XDATA.XFACE_ID = VARIABLE_ID;

/* */
/* Make call to the Btrieve Record Manager. */
/* */


b_regs.x.dx = (int) &XDATA; /* parameter block is expected to be in DX */
b_sregs.ds = b_sregs.ss;
if (!MULTI)
int86x (BTR_INT, &b_regs, &b_regs, &b_sregs);
else
{ /* call bmulti */
while (1)
{
b_regs.x.ax = 1; /* assume no proc id obtained yet */
if ((b_regs.x.bx = ProcId) != 0) /* if we have a proc id */
b_regs.x.ax = 2; /* tell bmulti that */
b_regs.x.ax += _2FCODE;
int86x (BTR2_INT, &b_regs, &b_regs, &b_sregs);
if ((b_regs.x.ax & 0x00FF) == 0) break; /* if call was processed */
/* by bmulti, leave loop */
b_regs.x.ax = 0x0200; /* if multilink advanced is loaded, it will */
int86x (0x7F, &b_regs, &b_regs, &b_sregs); /* it will switch processes */
}
if (ProcId == 0) ProcId = b_regs.x.bx;
}

*DATA_LEN = XDATA.BUF_LEN;
return (STAT); /* return status */
}

[Adrián]

Gracias voy a estudiar lo que me pasastes y cualquier cosa te digo.

[bosoft]

Muy bien. con lo que me has pasado voy a intentar hacerte el programita. Espero aclararme con la estructura.En un par de dias (no por lo que cuesta, si no por el tiempo libre que me queda) lo tienes

Saludos, Bosoft.

[bosoft]

Bueno, he estado inspeccionando los datos. mira tu messenger y agregame y te explico. Lo hago por no publicar datos de la base de datos que me has mandado.

Saludos Bosoft.