bbp.c

一个内存数据库的源代码这是服务器端还有客户端

#line 187 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/bbp.mx"
#include "mal_config.h"
#include "mal_box.h"
#include "mal_client.h"
#include "mal_interpreter.h"
#include "bat5.h"
#include "algebra.h"

#ifdef WIN32
#ifndef LIBBBP
#define bbp_export extern __declspec(dllimport)
#else
#define bbp_export extern __declspec(dllexport)
#endif
#else
#define bbp_export extern
#endif

bbp_export str CMDbbpprelude(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpopen(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpclose(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpdestroy(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpdeposit(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpbindDefinition(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpbind(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpfind2(int *ret, str *hnme, str *tnme);
bbp_export str CMDbbpfind3(int *ret, str *nme);
bbp_export str CMDbbpbindindex(int *ret, int *bid);
bbp_export str CMDbbptake(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbprelease(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpreleaseBAT(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpdestroyBAT(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpdestroyBAT1(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpReleaseAll(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpdiscard(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbptoStr(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpiterator(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpGetObjects(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbbpNames(int *ret);
bbp_export str CMDbbpName(str *ret, int *bid);
bbp_export str CMDbbpRNames(int *ret);
bbp_export str CMDbbpCount(int *ret);
bbp_export str CMDbbpLocation(int *ret);
bbp_export str CMDbbpHeat(int *ret);
bbp_export str CMDbbpDirty(int *ret);
bbp_export str CMDbbpStatus(int *ret);
bbp_export str CMDbbpKind(int *ret);
bbp_export str CMDbbpRefCount(int *ret);
bbp_export str CMDbbpLRefCount(int *ret);
bbp_export str CMDgetBATrefcnt(int *res, int *bid);
bbp_export str CMDgetBATlrefcnt(int *res, int *bid);
bbp_export str CMDbatunpack(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
bbp_export str CMDbatpack(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);



#line 244 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/bbp.mx"
#define OpenBox(X) \
	box= findBox("bbp");\
	if(box == 0 )\
		box= openBox("bbp");\
	if( box ==0) \
		throw(MAL, "bbp." X,"box is not open");


str
CMDbbpprelude(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	(void) mb;
	(void) stk;
	(void) pci;		/* fool compiler */
	if (openBox("bbp"))
		return MAL_SUCCEED;
	throw(MAL, "bbp.prelude", "failed to open box");
}



#line 265 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/bbp.mx"
str
CMDbbpopen(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	(void) mb;
	(void) stk;
	(void) pci;		/* fool compiler */
	if (openBox("bbp") != 0)
		return MAL_SUCCEED;
	throw(MAL, "bbp.open", "failed to open box");
}

str
CMDbbpclose(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	(void) mb;
	(void) stk;
	(void) pci;		/* fool compiler */
	if (closeBox("bbp", TRUE) == 0)
		return MAL_SUCCEED;
	throw(MAL, "bbp.close", "failed to close 'bbp' box");
}

str
CMDbbpdestroy(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Box box;

	(void) mb;
	(void) stk;
	(void) pci;		/* fool compiler */
	OpenBox("destroy");
	if (MCgetClient() != mal_clients)
		throw(MAL, "bbp.destroy", "not allowed to destroy 'bbp' box");
	destroyBox("bbp");
	return MAL_SUCCEED;
}



#line 307 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/bbp.mx"
str
CMDbbpdeposit(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	str name;
	ValPtr v;
	Box box;
	int flg;

	(void) mb;		/* fool compiler */

	OpenBox("deposit");
	name = (str) getArgValue(stk, pci, 1);
	if (isIdentifier(name) < 0 )
		throw(MAL, "bbp.deposit", "identifier expected");
	v = &stk->stk[getArg(pci, 2)];
	flg = findVariable(box->sym, name) >= 0;
	if (depositBox(box, name, v))
		throw(MAL, "bbp.deposit", "failed to deposit into box");
	if (!flg)
		BBPincref(v->val.bval, TRUE);
	return MAL_SUCCEED;
}

str
CMDbbpbindDefinition(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	str name, loc;
	Box box;

	(void) mb;		/* fool compiler */
	OpenBox("bind");
	name = (str) getArgValue(stk, pci, 1);
	loc = (str) getArgValue(stk, pci, 2);
	if (isIdentifier(name) < 0)
		throw(MAL, "bbp.bind", "identifier expected");
	if (bindBAT(box, name, loc))
		throw(MAL, "bbp.bind", "failed to bind name ");
	return MAL_SUCCEED;
}

str
CMDbbpbind(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	str name;
	Box box;
	ValPtr lhs, rhs;
	int i = -1;
	BAT *b;

	(void) mb;		/* fool compiler */
	lhs = &stk->stk[getArg(pci, 0)];
	name = (str) getArgValue(stk, pci, 1);
	if (isIdentifier(name) < 0)
		throw(MAL, "bbp.bind", "identifier expected");
	box = findBox("bbp");
	if (box && (i = findVariable(box->sym, name)) >= 0) {
		rhs = &box->val->stk[i];
		VALcopy(lhs, rhs);
		if (lhs->vtype == TYPE_bat) {
			BAT *b;

			b = (BAT *) BBPgetdesc(lhs->val.bval);
			if (b == NULL)
				throw(MAL, "bbp.bind", "can not access descriptor");
			BBPincref(b->batCacheid, TRUE);
		}
		return MAL_SUCCEED;
	}
	i = BBPindex(name);
	if (i == 0)
		throw(MAL, "bbp.bind", "failed to locate object in box");
	/* make sure you load the descriptors and heaps */
	b = (BAT *) BATdescriptor(i);
	if (b == 0)
		/* Simple ignore the binding if you can;t find the bat */
		throw(MAL, "bbp.bind", "failed to find object in box");
	/* make sure we are not dealing with an about to be deleted bat */
	if( BBP_refs(b->batCacheid) == 1 &&
		BBP_lrefs(b->batCacheid) == 0){
		BBPunfix(i);
		throw(MAL, "bbp.bind", "failed to find object in box");
	}

	BBPincref(b->batCacheid, TRUE);
	BBPunfix(i);
	lhs->vtype = TYPE_bat;
	lhs->val.bval = i;
	return MAL_SUCCEED;
}

str
CMDbbpfind3(int *ret, str *nme)
{
	int i;
	/* find a specific BAT in the buffer pool */
	BBPlock("CMDbbpfind3");
	for (i = 1; i < BBPsize; i++)
	if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
		if( strcmp(BBP_logical(i),*nme)==0 ){
			BBPkeepref(i);
			*ret = i;
			BBPunlock("CMDbbpfind3");
			return MAL_SUCCEED;
		}
	}
	BBPunlock("CMDbbpfind3");
	throw(MAL, "bbp.find","BAT not found");
}
str
CMDbbpfind2(int *ret, str *hnme, str *tnme)
{
	int i;
	/* find a specific BAT in the buffer pool */
	BBPlock("CMDbbpfind2");
	for (i = 1; i < BBPsize; i++)
	if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
		BAT *b = (BAT *) BATdescriptor(i);
		if( b == 0 ) 
			continue;
		if( strcmp(b->hident,*hnme)==0 &&
			strcmp(b->tident,*tnme)==0 ){
			BBPkeepref(i);
			*ret = i;
			BBPunlock("CMDbbpfind2");
			return MAL_SUCCEED;
		}
		BBPreleaseref(i);
	}
	BBPunlock("CMDbbpfind2");
	throw(MAL, "bbp.find","BAT not found");
}
str
CMDbbpbindindex(int *ret, int *bid)
{
	BAT *b;

	if ( *bid  == bat_nil)
		throw(MAL, "bbp.bind", "can not access descriptor");
	b = (BAT *) BATdescriptor(*bid);
	if (b == 0)
		throw(MAL, "bbp.bind", "can not access descriptor");
	*ret = b->batCacheid;
	BBPkeepref(*ret);
	return MAL_SUCCEED;
}



#line 460 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/bbp.mx"
str
CMDbbptake(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	str name;
	Box box;
	ValPtr v;

	(void) mb;		/* fool compiler */
	OpenBox("take");
	name = (str) getArgValue(stk, pci, 1);
	if (isIdentifier(name)< 0)
		throw(MAL, "bbp.take", "identifier expected");
	if (strstr(name, "M5system_auth") == name)
		throw(MAL, "bbp.take", "access denied");
	v = &stk->stk[getArg(pci, 0)];
	if (takeBox(box, name, v, (int) getArgType(mb, pci, 0))) {
		int bid = BBPindex(name);

		if (bid > 0 && (v->vtype == TYPE_any || v->vtype == TYPE_bat)) {
			/* adjust the types as well */
			v->vtype = TYPE_bat;
			v->val.ival = bid;
			BBPincref(bid, TRUE);
		} else
			throw(MAL, "bbp.take", "failed to take object from box");
	}
	/* make a private copy for this client session */
	/* use the cheapest copy method */
	/* printf("bbp.take not yet fully implemented\n"); */
	return MAL_SUCCEED;
}

str
CMDbbprelease(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	str name;
	Box box;

	(void) mb;		/* fool compiler */
	OpenBox("release");
	name = (str) getArgValue(stk, pci, 1);
	releaseBox(box, name);
	/* merge the updates of this BAT with the master copy */
	/* printf("bbp.release not yet fully implemented\n"); */
	return MAL_SUCCEED;
}



#line 512 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/bbp.mx"
str
CMDbbpreleaseBAT(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	int *bid;
	Box box;

	OpenBox("release");
	bid = (int *) getArgValue(stk, pci, 1);
	BBPdecref(*bid, TRUE);
	releaseBAT(mb, stk, *bid);
	*bid = 0;
	return MAL_SUCCEED;
}



#line 533 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/bbp.mx"
str
CMDbbpgarbage(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	int *bid;
	Box box;
	BAT *b;

	(void) mb;
	OpenBox("release");
	bid = (int *) getArgValue(stk, pci, 1);
	if ((b = BATdescriptor(*bid)) == NULL) {
		throw(MAL, "bbp.garbage", "Cannot access descriptor");
	}

	b->batDirty= FALSE;
	if (BBP_lrefs(*bid) == 0) {
		BBPunfix(b->batCacheid);
		throw(MAL, "bbp.garbage", "Bat already gone");
	}
	if (BBP_lrefs(*bid) == 2 && b->batPersistence == PERSISTENT) {
		/* release BAT from pool altogether */
		BBPunfix(b->batCacheid);
		BBPdecref(*bid, TRUE);
		*bid = 0;
		return MAL_SUCCEED;
	}
	BBPunfix(b->batCacheid);
	if (*bid)
		/* while( BBP_lrefs(*bid) > 1 ) */
		BBPdecref(*bid, TRUE);
	*bid = 0;
	return MAL_SUCCEED;
}



#line 572 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/bbp.mx"
str
CMDbbpdestroyBAT(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	bit ret = 0;
	int *bid;
	bit *immediate;
	str msg;

	bid = (int *) getArgValue(stk, pci, 1);
	immediate = (bit *) getArgValue(stk, pci, 2);
	msg = CMDbbpreleaseBAT(mb, stk, pci);
	if( *immediate) 
		msg = BKCdestroyImmediate(&ret, bid);
	else 
		msg = BKCdestroy(&ret, bid);
	*(int *) getArgValue(stk, pci, 1)  = 0;
	return msg;
}

str
CMDbbpdestroyBAT1(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	bit ret = 0;
	int *bid;
	(void) mb;

	bid = (int *) getArgValue(stk, pci, 1);
	*(int *) getArgValue(stk, pci, 1)  = 0;
	return BKCdestroyImmediate(&ret, bid);
}

str
CMDbbpReleaseAll(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Box box;

	(void) mb;
	(void) stk;
	(void) pci;		/* fool compiler */
	OpenBox("releaseAll");
	releaseAllBox(box);
	/* merge the updates with the master copies */
	/* printf("bbp.releaseAll not yet fully implemented\n"); */
	throw(MAL, "bbp.commit","Not yet available");
}

str
CMDbbpdiscard(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	str name;
	Box box;

	(void) mb;		/* fool compiler */
	OpenBox("discard");
	name = (str) getArgValue(stk, pci, 1);
	if (discardBox(box, name))
		throw(MAL, "bbp.discard", "failed to discard object ");
	/*printf("bbp.discard not yet fully implemented\n"); */
	return MAL_SUCCEED;
}

str
CMDbbptoStr(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Box box;
	int i;
	ValPtr v;
	str nme;

	(void) mb;		/* fool compiler */
	OpenBox("toString");
	nme = (str) getArgValue(stk, pci, 1);
	i = findVariable(box->sym, nme);
	if (i < 0)
		throw(MAL, "bbp.toString", "failed to take value from box");
	v = &box->val->stk[i];
	garbageElement(&stk->stk[getArg(pci, 0)]);
	if (VALconvert(TYPE_str, v) == ILLEGALVALUE)
		throw(MAL, "bbp.toString", "illegal value conversion");
	VALcopy(&stk->stk[getArg(pci, 0)], v);
	return MAL_SUCCEED;
}

str
CMDbbpiterator(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Box box;
	lng *cursor;
	ValPtr v;

	(void) mb;		/* fool compiler */
	OpenBox("iterator");
	cursor = (lng *) getArgValue(stk, pci, 0);
	v = &stk->stk[getArg(pci, 1)];
	if (nextBoxElement(box, cursor, v))
		throw(MAL, "bbp.iterator", "failed");
	return MAL_SUCCEED;
}





#line 691 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/bbp.mx"
str
CMDbbpGetObjects(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	BAT *b;
	int i;
	ValPtr v;
	Box box;
	int *ret;

	(void) mb;		/* fool compiler */
	OpenBox("getObjects");
	b = BATnew(TYPE_int, TYPE_str, BBPsize);
	if (b == 0)
		throw(MAL, "bbp.getObjects", "Cannot create BAT");
	for (i = 0; i < box->sym->vtop; i++) {
		v = &box->val->stk[i];
		BUNins(b, &v->val.bval, getVarName(box->sym, i), FALSE);
	}

	ret = (int *) getArgReference(stk, pci, 0);
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	
#line 683 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/bbp.mx"
	if (BBPindex("bbp_objects") > 0) 
		BATdelete(BBPdescriptor(BBPindex("bbp_objects")));
	BATroles(b,"bbp","objects");
	BATmode(b,TRANSIENT);
	BATfakeCommit(b);
	*ret = b->batCacheid;
	BBPkeepref(*ret);


#line 712 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/bbp.mx"

	return MAL_SUCCEED;
}

str
CMDbbpNames(int *ret)
{
	BAT *b;
	int i;

	b = BATnew(TYPE_int, TYPE_str, BBPsize);
	if (b == 0)
		throw(MAL, "catalog.bbpNames", "failed to create BAT");

	BBPlock("CMDbbpNames");
	for (i = 1; i < BBPsize; i++)
		if (i != b->batCacheid) {
			if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i)) ) {
				BUNins(b, &i, BBP_logical(i), FALSE);
				if (BBP_logical(-i) && (BBP_refs(-i) || BBP_lrefs(-i))) {
					int j = -i;

					BUNins(b, &j, BBP_logical(j), FALSE);
				}