batextensions.c

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

#line 85 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/batExtensions.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 LIBBATEXTENSIONS
#define be_export extern __declspec(dllimport)
#else
#define be_export extern __declspec(dllexport)
#endif
#else
#define be_export extern
#endif

be_export str CMDBATsetGarbage(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
be_export str CMDBATflush(int *res, int *bid);
be_export str CMDBATreduce(int *ret, int *bid);
be_export str CMDBATclone(MalBlkPtr m, MalStkPtr s, InstrPtr p);
be_export str CMDBATnew(MalBlkPtr m, MalStkPtr s, InstrPtr p);
be_export str CMDBATnewDerived(MalBlkPtr m, MalStkPtr s, InstrPtr p);
be_export str CMDBATderivedByName(int *ret, str *nme);
be_export str CMDBATnewint(MalBlkPtr m, MalStkPtr s, InstrPtr p);
be_export str CMDBBPproject(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
be_export str CMDBBPprojectNil(int *ret, int *bid);
be_export str CMDbatunpack(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
be_export str CMDbatpack(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);



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




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

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

	b->batDirty= FALSE;
	BBPunfix(b->batCacheid);
	if (*bid)
		BBPdecref(*bid,TRUE);
	*bid = 0;
	return MAL_SUCCEED;
}

str
CMDBATflush(int *ret, int *bid)
{
	BAT *b;

	if ((b = BATdescriptor(*bid)) == NULL) 
		throw(MAL, "bbp.flush", "Cannot access descriptor");

	/* use memory advice to release the BAT */
	/* TO BE PROVIDED */
	BBPunfix(b->batCacheid);
	if (*bid)
		BBPdecref(*bid,TRUE);
	*ret = 0;
	return MAL_SUCCEED;
}

str
CMDBATreduce(int *ret, int *bid)
{
	BAT *b;
	int old= GDKdebug;

	if ((b = BATdescriptor(*bid)) == NULL) 
		throw(MAL, "bbp.reduce", "Cannot access descriptor");

	/* reduce memory footprint by dropping hashes 
	of non-persistent bats */
	if( !VIEWparent(b) && b->batSharecnt==0){
#ifdef TRACE_ADVICE
		if(b->hhash)
			printf("found hhash %s %d\n",BBP_logical(b->batCacheid), (int)(BATcount(b) * sizeof(hash_t)));
		if(b->thash)
			printf("found thash %s %d\n",BBP_logical(b->batCacheid), (int)(BATcount(b) * sizeof(hash_t)));
#endif
		/* disable DeadBeef production */
		GDKdebug &= ~33554432;
		HASHdestroy(b);
	}
	BBPkeepref(*ret=b->batCacheid);
	GDKdebug = old;
	return MAL_SUCCEED;
}



#line 200 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/batExtensions.mx"
str
CMDBATclone(MalBlkPtr m, MalStkPtr s, InstrPtr p)
{
	BAT *b;
	int bid = 0, cap, ht, tt;
	int *res;

	(void) m;

	bid = *(int *) getArgReference(s, p, 3);
	if ((b = BATdescriptor(bid)) == NULL) {
		throw(MAL, "bbp.new", "Cannot access descriptor");
	}
	res = (int *) getArgReference(s, p, 0);
	ht = getArgType(m, p, 1);
	tt = getArgType(m, p, 2);
	cap = BATcount(b) + 64;
	BBPunfix(b->batCacheid);
	return (str) BKCnewBATint(res, &ht, &tt, &cap);
}

str
CMDBATnew(MalBlkPtr m, MalStkPtr s, InstrPtr p)
{
	int ht, tt;
	lng cap = 0;
	int *res;

	res = (int *) getArgReference(s, p, 0);
	ht = getArgType(m, p, 1);
	tt = getArgType(m, p, 2);
	if (p->argc > 3)
		cap = *(lng*) getArgReference(s, p, 3);

	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;
	return (str) BKCnewBATlng(res, &ht, &tt, &cap);
}

str
CMDBATnewDerived(MalBlkPtr m, MalStkPtr s, InstrPtr p)
{
	int bid, ht, tt;
	int cap = 0;
	int *res;
	BAT *b;
	str msg;
	oid o;

	(void) m;
	res = (int *) getArgReference(s, p, 0);
	bid = *(int *) getArgReference(s, p, 1);
	if ((b = BATdescriptor(bid)) == NULL) {
		throw(MAL, "bbp.new", "Cannot access descriptor");
	}

	if (bid > 0) {
		ht = b->htype;
		tt = b->ttype;
	} else {
		tt = b->htype;
		ht = b->ttype;
	}

	if (p->argc > 2)
		cap = *(int *) getArgReference(s, p, 2);
	else
		cap = BATcount(b);
	o = b->hseqbase;
	BBPunfix(b->batCacheid);

	res = (int *) getArgReference(s, p, 0);
	msg = (str) BKCnewBATint(res, &ht, &tt, &cap);
	if (msg == MAL_SUCCEED && ht == TYPE_void) {
		b = BATdescriptor(*res);
		BATseqbase(b, o);
		BBPunfix(b->batCacheid);
	}

	return msg;
}

str
CMDBATderivedByName(int *ret, str *nme)
{
	BAT *bn;
	int bid;

	bid = BBPindex(*nme);
	if (bid <= 0 || (bn = BATdescriptor(bid)) == 0)
		throw(MAL, "bbp.new", "Referenced BAT not found");
	BBPincref(*ret = bn->batCacheid, TRUE);
	BBPunfix(bid);
	return MAL_SUCCEED;
}

str
CMDBATnewint(MalBlkPtr m, MalStkPtr s, InstrPtr p)
{
	int ht, tt;
	int cap = 0;
	int *res;

	res = (int *) getArgReference(s, p, 0);
	ht = getArgType(m, p, 1);
	tt = getArgType(m, p, 2);
	cap = *(int *) getArgReference(s, p, 3);
	res = (int *) getArgReference(s, p, 0);

	return (str) BKCnewBATint(res, &ht, &tt, &cap);
}

str
CMDBBPproject(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	int *result, *bid, tt;
	ptr *p;
	BAT *b, *bn;

	result = (int *) getArgReference(stk, pci, 0);
	bid = (int *) getArgReference(stk, pci, 1);
	p = (ptr *) getArgReference(stk, pci, 2);
	tt = getArgType(mb, pci, 2);
	if ((b = BATdescriptor(*bid)) == NULL) {
		throw(MAL, "bbp.project", "Cannot access descriptor");
	}

	if (tt >= TYPE_str) {
		if (p == 0 || *(str *) p == 0)
			p = (ptr *) str_nil;
		else
			p = *(ptr **) p;
	}
	bn = BATconst(b, tt, p);
	BBPunfix(b->batCacheid);
	if (bn) {
		*result = bn->batCacheid;
		BBPkeepref(bn->batCacheid);
		return MAL_SUCCEED;
	}
	throw(MAL, "bbp.project", "Cannot create the constant BAT");
}

str
CMDBBPprojectNil(int *ret, int *bid)
{
	BAT *b, *bn;

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

	bn = BATconst(b, TYPE_void, (ptr) &int_nil);
	BBPunfix(b->batCacheid);
	if (bn) {
		*ret = bn->batCacheid;
		BBPkeepref(bn->batCacheid);
		return MAL_SUCCEED;
	}
	throw(MAL, "bbp.project", "Cannot create the constant BAT");
}

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