view release on metacpan or  search on metacpan

BerkeleyDB.xs  view on Meta::CPAN

    {
        DBT_clear(*data);
        Value = GetRecnoKey(getCurrentDB, SvIV(data_sv)) ;
        data->flags = DB_DBT_APPMALLOC;
        data->size = (int)sizeof(db_recno_t);
        data->data = (char*)safemalloc(data->size);
        memcpy(data->data, &Value, data->size);
    }
    /*Trace(("key is %d -- %.*s\n", skey->size, skey->size, skey->data));*/

    FREETMPS ;
    LEAVE ;

    return (retval) ;
}

#endif /* AT_LEAST_DB_3_3 */

static void
#ifdef AT_LEAST_DB_4_3
db_errcall_cb(const DB_ENV* dbenv, const char * db_errpfx, const char * buffer)
#else
db_errcall_cb(const char * db_errpfx, char * buffer)
#endif
{
#ifdef dTHX
    dTHX;
#endif
    SV * sv;

    Trace(("In errcall_cb \n")) ;
#if 0

    if (db_errpfx == NULL)
	db_errpfx = "" ;
    if (buffer == NULL )
	buffer = "" ;
    ErrBuff[0] = '\0';
    if (strlen(db_errpfx) + strlen(buffer) + 3 <= 1000) {
	if (*db_errpfx != '\0') {
	    strcat(ErrBuff, db_errpfx) ;
	    strcat(ErrBuff, ": ") ;
	}
	strcat(ErrBuff, buffer) ;
    }

#endif

    sv = perl_get_sv(ERR_BUFF, FALSE) ;
    if (sv) {
        if (db_errpfx)
	    sv_setpvf(sv, "%s: %s", db_errpfx, buffer) ;
        else
            sv_setpv(sv, buffer) ;
    }
}

#if defined(AT_LEAST_DB_4_4) && ! defined(_WIN32)

int
db_isalive_cb(DB_ENV *dbenv, pid_t pid, db_threadid_t tid, u_int32_t flags)
{
  bool processAlive = ( kill(pid, 0) == 0 ) || ( errno != ESRCH );
  return processAlive;
}

#endif


static SV *
readHash(HV * hash, char * key)
{
#ifdef dTHX
    dTHX;
#endif
    SV **       svp;
    svp = hv_fetch(hash, key, strlen(key), FALSE);

    if (svp) {
        if (SvGMAGICAL(*svp))
            mg_get(*svp);
        if (SvOK(*svp))
            return *svp;
    }

    return NULL ;
}

static void
hash_delete(char * hash, char * key)
{
#ifdef dTHX
    dTHX;
#endif
    HV * hv = perl_get_hv(hash, TRUE);
    (void) hv_delete(hv, (char*)&key, sizeof(key), G_DISCARD);
}

static void
hash_store_iv(char * hash, char * key, IV value)
{
#ifdef dTHX
    dTHX;
#endif
    HV * hv = perl_get_hv(hash, TRUE);
    (void)hv_store(hv, (char*)&key, sizeof(key), newSViv(value), 0);
    /* printf("hv_store returned %d\n", ret) ; */
}

static void
hv_store_iv(HV * hash, char * key, IV value)
{
#ifdef dTHX
    dTHX;
#endif
    hv_store(hash, key, strlen(key), newSViv(value), 0);
}

#if 0
static void
hv_store_uv(HV * hash, char * key, UV value)

BerkeleyDB.xs  view on Meta::CPAN

#ifndef AT_LEAST_DB_4_3
		softCrash("$env->lock_stat_print needs Berkeley DB 4.3 or better") ;
#else
		RETVAL = env->Status = env->Env->lock_stat_print(env->Env, flags);
#endif
	OUTPUT:
		RETVAL

int
mutex_stat_print(env, flags=0)
	BerkeleyDB::Env  env
	u_int32_t    flags
	INIT:
	  ckActive_Database(env->active) ;
	CODE:
#ifndef AT_LEAST_DB_4_4
		softCrash("$env->mutex_stat_print needs Berkeley DB 4.4 or better") ;
#else
		RETVAL = env->Status = env->Env->mutex_stat_print(env->Env, flags);
#endif
	OUTPUT:
		RETVAL


int
txn_stat_print(env, flags=0)
	BerkeleyDB::Env  env
	u_int32_t    flags
	INIT:
	  ckActive_Database(env->active) ;
	CODE:
#ifndef AT_LEAST_DB_4_3
		softCrash("$env->mutex_stat_print needs Berkeley DB 4.3 or better") ;
#else
		RETVAL = env->Status = env->Env->txn_stat_print(env->Env, flags);
#endif
	OUTPUT:
		RETVAL

int
failchk(env, flags=0)
	BerkeleyDB::Env  env
	u_int32_t    flags
	INIT:
	  ckActive_Database(env->active) ;
	CODE:
#if ! defined(AT_LEAST_DB_4_4) || defined(_WIN32)
#ifndef AT_LEAST_DB_4_4
		softCrash("$env->failchk needs Berkeley DB 4.4 or better") ;
#endif
#ifdef _WIN32
		softCrash("$env->failchk not supported on Windows") ;
#endif
#else
		RETVAL = env->Status = env->Env->failchk(env->Env, flags);
#endif
	OUTPUT:
		RETVAL

int
set_isalive(env)
	BerkeleyDB::Env  env
	INIT:
	  ckActive_Database(env->active) ;
	CODE:
#if ! defined(AT_LEAST_DB_4_4) || defined(_WIN32)
#ifndef AT_LEAST_DB_4_4
		softCrash("$env->set_isalive needs Berkeley DB 4.4 or better") ;
#endif
#ifdef _WIN32
		softCrash("$env->set_isalive not supported on Windows") ;
#endif
#else
		RETVAL = env->Status = env->Env->set_isalive(env->Env, db_isalive_cb);
#endif
	OUTPUT:
		RETVAL


DualType
get_blob_threshold(env, bytes)
	BerkeleyDB::Env	env
	u_int32_t bytes = NO_INIT
	PREINIT:
	  dMY_CXT;
    CODE:
#ifndef AT_LEAST_DB_6_0
	    softCrash("$env->get_blob_threshold needs Berkeley DB 6.0 or better") ;
#else
        RETVAL = env->Env->get_blob_threshold(env->Env, &bytes);
#endif
    OUTPUT:
        RETVAL
        bytes

DualType
get_blob_dir(env, dir)
	BerkeleyDB::Env	env
	char* dir = NO_INIT
	PREINIT:
	  dMY_CXT;
    CODE:
#ifndef AT_LEAST_DB_6_0
	    softCrash("$env->get_blob_dir needs Berkeley DB 6.0 or better") ;
#else
        RETVAL = env->Env->get_blob_dir(env->Env, (const char**)&dir);
#endif
    OUTPUT:
        RETVAL
        dir

DualType
set_region_dir(env, dir)
	BerkeleyDB::Env	env
	const char* dir
	PREINIT:
	  dMY_CXT;
    CODE:
#ifndef AT_LEAST_DB_6_2
	    softCrash("$env->set_region_dir needs Berkeley DB 6.2 or better") ;
#else
        RETVAL = env->Env->set_region_dir(env->Env, dir);
#endif
    OUTPUT:
        RETVAL

DualType
get_region_dir(env, dir)
	BerkeleyDB::Env	env
	char* dir = NO_INIT
	PREINIT:
	  dMY_CXT;
    CODE:
#ifndef AT_LEAST_DB_6_2