bbp.mx

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

	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;
}

@-
A BAT can be removed forever immediately or at the end of
a session. The references within the current frame
should also be zapped.
@c
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;
}



@+ BBP status
The BAT buffer pool datastructures describe the memory resident information
on the whereabouts of the BATs. The three predominant tables are made accessible
for inspection. 

The most interesting system bat for end-users is the BID-> NAME mapping,
because it provides access to the system guaranteed persistent BAT identifier.
It may be the case that the user already introduced a BAT with this name,
it is simply removed first
@= Pseudo2
	if (BBPindex("@1_@2") > 0) 
		BATdelete(BBPdescriptor(BBPindex("@1_@2")));
	BATroles(b,"@1","@2");
	BATmode(b,TRANSIENT);
	BATfakeCommit(b);
	*ret = b->batCacheid;
	BBPkeepref(*ret);
@c
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);
	@:Pseudo2(bbp,objects)@
	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);
				}
			}
		}
	BBPunlock("CMDbbpNames");
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	@:Pseudo2(bbp,name)@
	return MAL_SUCCEED;
}

str
CMDbbpName(str *ret, int *bid)
{
	*ret = (str) GDKstrdup(BBP_logical(*bid));
	return MAL_SUCCEED;
}

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

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

	BBPlock("CMDbbpRNames");
	for (i = 1; i < BBPsize; i++)
		if (i != b->batCacheid && BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
			if (BBP_logical(-i)) {
				BUNins(b, &i, BBP_logical(-i), FALSE);
			} else
				BUNins(b, &i, BBP_logical(i), FALSE);
		}
	BBPunlock("CMDbbpRNames");
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	@:Pseudo2(bbp,revname)@
	return MAL_SUCCEED;
}

str
CMDbbpCount(int *ret)
{
	BAT *b, *bn;
	int i;
	lng l;

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

	for (i = 1; i < BBPsize; i++)
		if (i != b->batCacheid) {
			if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
				bn = BATdescriptor(i);
				if (bn) {
					l = BATcount(bn);
					BUNins(b, &i, &l, FALSE);
					BBPunfix(bn->batCacheid);
				}
			}
		}
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	@:Pseudo2(bbp,count)@
	return MAL_SUCCEED;
}

@-
The BAT status is redundantly stored in CMDbat_info.
@c
str
CMDbbpLocation(int *ret)
{
	BAT *b;
	int i;

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

	BBPlock("CMDbbpLocation");
	for (i = 1; i < BBPsize; i++)
		if (i != b->batCacheid) {
			if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i)))
				BUNins(b, &i, BBP_physical(i), FALSE);
		}
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	BBPunlock("CMDbbpLocation");
	@:Pseudo2(bbp,location)@
	return MAL_SUCCEED;
}


#define monet_modulesilent (GDKdebug&4096)


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

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

	BBPlock("CMDbbpHeat");
	for (i = 1; i < BBPsize; i++)
		if (i != b->batCacheid) {
			if (BBP_cache(i) && !monet_modulesilent) {
				int heat = BBP_lastused(i);

				BUNins(b, &i, &heat, FALSE);
			} else if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
				int zero = 0;

				BUNins(b, &i, &zero, FALSE);
			}
		}
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	BBPunlock("CMDbbpHeat");
	@:Pseudo2(bbp,heat)@
	return MAL_SUCCEED;
}

@-
The BAT dirty status:dirty => (mem != disk); diffs = not-committed
@c
str
CMDbbpDirty(int *ret)
{
	BAT *b;
	int i;

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

	BBPlock("CMDbbpDirty");
	for (i = 1; i < BBPsize; i++)
		if (i != b->batCacheid)
			if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
				BAT *bn = BBP_cache(i);

				BUNins(b, &i, bn ? BATdirty(bn) ? "dirty" : DELTAdirty(bn) ? "diffs" : "clean" : (BBP_status(i) & BBPSWAPPED) ? "diffs" : "clean", FALSE);
			}
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	BBPunlock("CMDbbpDirty");
	@:Pseudo2(bbp,status)@
	return MAL_SUCCEED;
}

@-
The BAT status is redundantly stored in CMDbat_info.
@c
str
CMDbbpStatus(int *ret)
{
	BAT *b;
	int i;

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

	BBPlock("CMDbbpStatus");
	for (i = 1; i < BBPsize; i++)
		if (i != b->batCacheid)
			if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
				char *loc = BBP_cache(i) ? "load" : "disk";

				BUNins(b, &i, loc, FALSE);
			}
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	BBPunlock("CMDbbpStatus");
	@:Pseudo2(bbp,status)@
	return MAL_SUCCEED;
}

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

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

	BBPlock("CMDbbpKind");
	for (i = 1; i < BBPsize; i++)
		if (i != b->batCacheid)
			if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
				char *mode = NULL;

				if ((BBP_status(i) & BBPDELETED) || !(BBP_status(i) & BBPPERSISTENT))
					mode = "transient";
				else
					mode = "persistent";
				if (mode)
					BUNins(b, &i, mode, FALSE);
			}
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	BBPunlock("CMDbbpKind");
	@:Pseudo2(bbp,kind)@
	return MAL_SUCCEED;
}

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

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

	BBPlock("CMDbbpRefCount");
	for (i = 1; i < BBPsize; i++)
		if (i != b->batCacheid && BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
			int refs = BBP_refs(i);

			BUNins(b, &i, &refs, FALSE);
		}
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	BBPunlock("CMDbbpRefCount");
	@:Pseudo2(bbp,refcnt)@
	return MAL_SUCCEED;
}

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

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

	BBPlock("CMDbbpLRefCount");
	for (i = 1; i < BBPsize; i++)
		if (i != b->batCacheid && BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
			int refs = BBP_lrefs(i);

			BUNins(b, &i, &refs, FALSE);
		}
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	BBPunlock("CMDbbpLRefCount");
	@:Pseudo2(bbp,lrefcnt)@
	return MAL_SUCCEED;
}

str
CMDgetBATrefcnt(int *res, int *bid)
{
	BAT *b;

	if ((b = BATdescriptor(*bid)) == NULL) {
		throw(MAL, "bbp.getRefCount", "Cannot access descriptor");
	}
	*res = BBP_refs(b->batCacheid);
	BBPunfix(b->batCacheid);
	return MAL_SUCCEED;
}

str
CMDgetBATlrefcnt(int *res, int *bid)
{
	BAT *b;

	if ((b = BATdescriptor(*bid)) == NULL) {
		throw(MAL, "bbp.getLRefCount", "Cannot access descriptor");
	}
	*res = BBP_lrefs(b->batCacheid);
	BBPunfix(b->batCacheid);
	return MAL_SUCCEED;
}


@-
@= headtailProperty
bbp_export str CMDbbp@2( int *ret);
str CMDbbp@2( int *ret){
	BAT	*b,*bn;
	int	i;

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

	for(i=1; i < BBPsize; i++) if (i != b->batCacheid) 
	if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
		bn= BATdescriptor(i);
		if(bn) BUNins(b, &i, BATatoms[BAT@1(bn)].name, FALSE);
		BBPunfix(bn->batCacheid);
	}
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	@:Pseudo2(bbp,@2)@
	return MAL_SUCCEED;
}

@c
@:headtailProperty(htype,HeadType)@
@:headtailProperty(ttype,TailType)@

str
CMDbatunpack(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	BAT *b;
	int bid;
	ptr p;
	ValPtr head, tail;

	bid = *(int *) getArgValue(stk, pci, 2);

	if ((b = BATdescriptor(bid)) == NULL) {
		throw(MAL, "bbp.unpack", "Cannot access descriptor");
	}

	head = &stk->stk[pci->argv[0]];
	tail = &stk->stk[pci->argv[1]];
	p = BUNfirst(b);
	if (p) {
		VALinit(head, getArgType(mb, pci, 0), BUNhead(b, p));
		VALinit(tail, getArgType(mb, pci, 1), BUNtail(b, p));
	}

	BBPunfix(b->batCacheid);
	return MAL_SUCCEED;
}

str
CMDbatpack(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	BAT *b;
	int *ret;
	int ht, tt;
	size_t cap = 0;

	ht = getArgType(mb, pci, 1);
	tt = getArgType(mb, pci, 2);
	ret = (int *) getArgReference(stk, pci, 0);

	if (ht == TYPE_any || tt == TYPE_any)
		throw(MAL, "bbp.new", "Explicit type required");
	if (isaBatType(ht))
		ht = TYPE_bat;
	if (isaBatType(tt))
		tt = TYPE_bat;
	b = BATnew(ht, tt, cap);
	BUNins(b, (ptr) getArgValue(stk, pci, 1), getArgValue(stk, pci, 2), FALSE);
	if (!(b->batDirty&2)) b = BATsetaccess(b, BAT_READ);
	*ret = b->batCacheid;
	BBPkeepref(*ret);
	return MAL_SUCCEED;
}