bat5.c

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

#line 727 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
#include "mal_config.h"
#include "bat5.h"
#include <stream.h>
#include "mal_exception.h"


#line 737 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"

int
CMDnew_lng(BAT **ret, int *ht, int *tt, lng *cap)
{
	if (*cap < 0)
		*cap = 0;
	*ret = BATnew(*ht, *tt, (size_t) * cap);
	if (*ret)
		(*ret)->batDirty |= 2;
	return (*ret) ? GDK_SUCCEED : GDK_FAIL;
}

int
CMDnew(BAT **ret, int *ht, int *tt, int *cap)
{
	if (*cap < 0)
		*cap = 0;
	*ret = BATnew(*ht, *tt, (size_t) * cap);
	if (*ret)
		(*ret)->batDirty |= 2;
	return (*ret) ? GDK_SUCCEED : GDK_FAIL;
}

int
CMDnew_default(BAT **ret, int *ht, int *tt)
{
	int default_size = 0;

	return CMDnew(ret, ht, tt, &default_size);
}

int
CMDreverse(BAT **ret, BAT *b)
{
	*ret = BATmirror(b);
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDmirror(BAT **ret, BAT *b)
{
	BAT *v = *ret = VIEWcombine(b);

	if (b->batRestricted == BAT_WRITE) {
		*ret = BATcopy(v, v->htype, v->ttype, FALSE);
		BBPreclaim(v);
	}
	return (*ret) ? GDK_SUCCEED : GDK_FAIL;
}

int
CMDconvert(BAT **ret, BAT *b)
{
	if (BATconvert(*ret = b, CONV_HTON) == NULL)
		BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDrevert(BAT **ret, BAT *b)
{
	if (BATrevert(*ret = b) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDorder(BAT **ret, BAT *b)
{
	if (BATorder(*ret = b) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDorder_rev(BAT **ret, BAT *b)
{
	if (BATorder_rev(*ret = b) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDinsert_bun(BAT **r, BAT *b, ptr h, ptr t)
{
	if (BUNins(*r = b, 
#line 733 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
	(BAThtype(b) == TYPE_bat)?(BUN)&((BAT*)h)->batCacheid:(BUN)h



#line 826 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
, 
#line 733 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
	(BATttype(b) == TYPE_bat)?(BUN)&((BAT*)t)->batCacheid:(BUN)t



#line 826 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
,FALSE) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDinsert_bat(BAT **r, BAT *b, BAT *s)
{
	if (BATins(*r = b, s, FALSE) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDreplace_bun(BAT **r, BAT *b, ptr h, ptr t)
{
	if (BUNreplace(*r = b, 
#line 733 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
	(BAThtype(b) == TYPE_bat)?(BUN)&((BAT*)h)->batCacheid:(BUN)h



#line 844 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
, 
#line 733 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
	(BATttype(b) == TYPE_bat)?(BUN)&((BAT*)t)->batCacheid:(BUN)t



#line 844 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
, 0) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDreplace_bat(BAT **r, BAT *b, BAT *s)
{
	if (BATreplace(*r = b, s, 0) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDdelete_bun(BAT **r, BAT *b, ptr h, ptr t)
{
	if (BUNdel(*r = b, h, t, FALSE) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDdelete_head(BAT **r, BAT *b, ptr h)
{
	if (BUNdelHead(*r = b, 
#line 733 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
	(BAThtype(b) == TYPE_bat)?(BUN)&((BAT*)h)->batCacheid:(BUN)h



#line 871 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
, FALSE) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDdelete_all(BAT **r, BAT *b)
{
	if (BATclear(*r = b) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDdelete_bat_bun(BAT **r, BAT *b, BAT *s)
{
	if (BATdel(*r = b, s, FALSE) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDdelete_bat_head(BAT **r, BAT *b, BAT *s)
{
	if (BATdelHead(*r = b, s, FALSE) == NULL)
		return GDK_FAIL;
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}




#line 909 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/bat5.mx"
int
void_inplace5(BAT *b, oid id, ptr val, bit force)
{
	int res = GDK_SUCCEED;
	BUN p = NULL;
	BUN oldInserted = b->batInserted;

	assert(b->htype == TYPE_void);
	assert(b->hseqbase != oid_nil);
	assert(BATcount(b) > (id -b->hseqbase));

	b->batInserted = NULL;
	BUNfndVOID(p, b, (ptr) &id);

	assert(p >= b->batInserted);	/* we don't want delete/ins */
	assert(force || !b->batRestricted);
	if (!BUNinplace(b, p, (ptr) &id, val, force))
		 res = GDK_FAIL;

	b->batInserted = oldInserted;
	return res;
}

int
bun_inplace(BAT **res, BAT *b, oid *id, ptr val )
{
	int ret = void_inplace5(b,*id,val,FALSE);
	*res = b;
	BBPfix(b->batCacheid);
	return ret;
}

int
bun_inplace_force(BAT **res, BAT *b, oid *id, ptr val, bit *force )
{
	int ret = void_inplace5(b,*id,val,*force);
	*res = b;
	BBPfix(b->batCacheid);
	return ret;
}

ssize_t
void_replace_bat5(BAT *b, BAT *u, bit force)
{
	size_t nr = 0;
	BUN r, s;

	BATloop(u, r, s) {
		oid updid = *(oid *) BUNhead(u, r);
		ptr val = BUNtail(u, r);

		if (void_inplace5(b, updid, val, force) == GDK_FAIL)
			return -1;
		nr++;
	}
	return nr;
}

int
bat_inplace(BAT **res, BAT *o, BAT *d)
{
	*res = o;
	if (void_replace_bat5(o, d, FALSE) < 0)
		return GDK_FAIL;
	BBPfix(o->batCacheid);
	return GDK_SUCCEED;
}

int
bat_inplace_force(BAT **res, BAT *o, BAT *d, bit *force)
{
	*res = o;
	if (void_replace_bat5(o, d, *force) < 0)
		return GDK_FAIL;
	BBPfix(o->batCacheid);
	return GDK_SUCCEED;
}

/* descriptors may be unloaded by BBPtrim, so secure them with a hotfix while in use */
static BAT *
lock_desc(bat bid)
{
	BBPfix(bid);
	return (BAT *) BBPgetdesc(bid);
}

static void
unlock_desc(bat bid)
{
	BBPunfix(bid);
}

int
CMDcapacity(lng *res, int *bid)
{
	if (BBPcheck((bat) *bid, "CMDcapacity")) {
		BAT *b = lock_desc((bat) *bid);

		if (b == NULL) {
			*res = lng_nil;
		} else {
			*res = (lng) BATcapacity(b);
		}
		unlock_desc(*bid);
	}
	return GDK_SUCCEED;
}

int
CMDhead(str *res, int *bid)
{
	if (BBPcheck((bat) *bid, "CMDhead")) {
		str ret = (str)str_nil;
		BAT *b = lock_desc((bat) *bid);

		if (b) {
			ret = *bid > 0 ? ATOMname(b->htype) : ATOMname(b->ttype);
		}
		*res = GDKstrdup(ret);
		unlock_desc(*bid);
	} else {
		*res = GDKstrdup(str_nil);
	}
	return GDK_SUCCEED;
}

int
CMDtail(str *res, int *bid)
{
	if (BBPcheck((bat) *bid, "CMDtail")) {
		str ret = (str)str_nil;
		BAT *b = lock_desc((bat) *bid);

		if (b) {
			ret = *bid > 0 ? ATOMname(b->ttype) : ATOMname(b->htype);
		}
		*res = GDKstrdup(ret);
		unlock_desc(*bid);
	} else {
		*res = GDKstrdup(str_nil);
	}
	return GDK_SUCCEED;
}

int
CMDsetkey(BAT **result, BAT *input, bit *param)
{
	BATkey(*result = input, *param ? BOUND2BTRUE : FALSE);
	BBPfix(input->batCacheid);
	return GDK_SUCCEED;
}

int
CMDsetset(BAT **result, BAT *input, bit *param)
{
	BATset(*result = input, *param ? BOUND2BTRUE : FALSE);
	BBPfix(input->batCacheid);
	return GDK_SUCCEED;
}

int
CMDordered(bit *result, BAT *input)
{
	*result = BATordered(input) ? 1 : 0;
	return GDK_SUCCEED;
}

int
CMDordered_rev(bit *result, BAT *input)
{
	*result = BATordered_rev(input) ? 1 : 0;
	return GDK_SUCCEED;
}

int
CMDgetkey(bit *ret, BAT *b)
{
	/* we must take care of the special case of a nil column (TYPE_void,seqbase=nil)
	 * such nil columns never set hkey (and BUNins will never invalidate it if set) yet
	 * a nil column of a BAT with <= 1 entries does not contain doubles => return TRUE.
	 */
	if (BATcount(b) <= 1) {
		*ret = TRUE;
	} else {
		if (!b->hkey) {
			BATpropcheck(b, BATPROPS_ALL);
		}
		*ret = b->hkey ? TRUE : FALSE;
	}
	return GDK_SUCCEED;
}

int
CMDpersists(BAT **r, BAT *input, bit *param)
{
	BATmode(*r = input, (*param == TRUE) ? PERSISTENT : (*param == FALSE) ? TRANSIENT : SESSION);
	BBPfix(input->batCacheid);
	return GDK_SUCCEED;
}

int
CMDdestroy(bit *res, str input )
{
	int bid = BBPindex(input);

	*res = FALSE;
	if (bid) {
		BBPfix(bid);
		if (BBPindex(input) == bid) {
			BAT *b = (BAT*)BBPgetdesc(ABS(bid));

			BATmode(b, TRANSIENT);
			*res = TRUE;
		}
		BBPunfix(bid);
	}
	return GDK_SUCCEED;
}

int
CMDsetaccess(BAT **r, BAT *input, int *param)
{
	bat oldCacheid = input->batCacheid;

	*r = BATsetaccess(input, *param);
	if ((*r)->batCacheid == oldCacheid) {
		BBPfix(oldCacheid);
	}
	return GDK_SUCCEED;
}

int
CMDgetaccess(int *r, BAT *input)
{
	*r = BATgetaccess(input);
	return GDK_SUCCEED;
}

static char *
pre(str s1, str s2)
{
	static char buf[64]="";

	snprintf(buf, 64, "%s%s", s1, s2);
	return buf;
}
static char *
local_itoa(ssize_t i)
{
	static char buf[32]="";

	snprintf(buf, 32, SSZFMT, i);
	return buf;
}
static char *
local_utoa(size_t i)
{
	static char buf[32]="";

	snprintf(buf, 32, SZFMT, i);
	return buf;
}

#define COLLISION 6

void
HASHinfo(BAT *bn, Hash *h, str s)
{
	hash_t i;
	hash_t j;
	size_t cnt[COLLISION + 2];
	size_t largebuckets = 0;
	size_t largetot = 0;
	char buf[32];

	BUNins(bn, pre(s, "type"), ATOMname(h->type),FALSE);
	BUNins(bn, pre(s, "mask"), local_utoa(h->mask),FALSE);
	BUNins(bn, pre(s, "lim"), local_utoa(h->lim),FALSE);

	for (i = 0; i <= COLLISION + 1; i++) {
		cnt[i] = 0;
	}
	for (i = 0; i <= h->mask; i++) {
		if (h->hash[i] == HASH_MAX) {
			cnt[0]++;
		} else if (h->hash[i] > h->lim) {
			GDKerror("HASHinfo: hash consistency problem %d\n", i);
		} else if ((j = HASHlist(h, h->hash[i])) <= COLLISION + 1) {
			cnt[j]++;
		} else {
			largebuckets++;
			largetot += j;
		}
	}

	for (i = 0; i <= COLLISION + 1; i++)
		if (cnt[i]) {
			BUNins(bn, pre(s, local_utoa(i)), local_utoa(cnt[i]),FALSE);
		}
	snprintf(buf, 32, SZFMT " on " SZFMT, largetot, largebuckets);
	BUNins(bn, pre(s, "collision"), buf,FALSE);
}

static void
infoHeap(BAT *bn, Heap *hp, str nme)
{
	char buf[1024], *p = buf;

	if (!hp)
		return;
	while (*nme)
		*p++ = *nme++;
	strcpy(p, "free");
	BUNins(bn, buf, local_utoa(hp->free),FALSE);
	strcpy(p, "size");
	BUNins(bn, buf, local_utoa(hp->size),FALSE);
	strcpy(p, "maxsize");
	BUNins(bn, buf, local_utoa(hp->maxsize),FALSE);
	strcpy(p, "storage");
	BUNins(bn, buf, (hp->base == NULL || hp->base == (char*)1) ? "absent" : (hp->storage == STORE_MMAP) ? (hp->filename ? "memory mapped" : "anonymous vm") : (hp->storage & STORE_PRIV) ? "private map" : "malloced",FALSE);
	strcpy(p, "filename");
	BUNins(bn, buf, hp->filename ? hp->filename : "no file",FALSE);
}

static char *
oidtostr(oid i)
{
	int len = 48;
	static char bf[48];
	char *p = bf;

	(void) OIDtoStr(&p, &len, &i);
	return bf;
}

int
CMDinfo(BAT **retval, BAT *b)
{
	BAT *bn;
	char mode[1024], *access;

	if (!(bn = BATnew(TYPE_str, TYPE_str, 128)))
		return GDK_FAIL;
	*retval = bn;

	if (b->batPersistence == PERSISTENT) {
		strcpy(mode, "persistent");
	} else if (b->batPersistence == SESSION) {
		strcpy(mode, "session");
	} else if (b->batPersistence == TRANSIENT) {
		strcpy(mode, "transient");
	} else {
		strcpy(mode, "unknown");
	}

	switch (b->batRestricted) {
	case BAT_READ:
		access = "read-only";
		break;
	case BAT_WRITE:
		access = "updatable";
		break;
	case BAT_APPEND:
		access = "append-only";
		break;
	default:
		access = "unknown";
	}

	BUNins(bn, "version", local_itoa(b->GDKversion),FALSE);
	BUNins(bn, "batId", BATgetId(b),FALSE);
	BUNins(bn, "batCacheid", local_itoa(b->batCacheid),FALSE);
	BUNins(bn, "batParentid", local_itoa(b->batParentid),FALSE);
	BUNins(bn, "batSharecnt", local_itoa(b->batSharecnt),FALSE);
	BUNins(bn, "head", ATOMname(b->htype),FALSE);
	BUNins(bn, "tail", ATOMname(b->ttype),FALSE);
	BUNins(bn, "batPersistence", mode,FALSE);
	BUNins(bn, "batRestricted", access,FALSE);
	BUNins(bn, "batRefcnt", local_itoa(BBP_refs(b->batCacheid)),FALSE);
	BUNins(bn, "batLRefcnt", local_itoa(BBP_lrefs(b->batCacheid)),FALSE);
	BUNins(bn, "batDirty", BATdirty(b) ? "dirty" : "clean",FALSE);
	BUNins(bn, "batSet", local_itoa(b->batSet),FALSE);
	BUNins(bn, "void_tid", local_itoa(b->void_tid),FALSE);
	BUNins(bn, "void_cnt", local_itoa(b->void_cnt),FALSE);

	BUNins(bn, "hsorted", local_itoa(BAThordered(b)),FALSE);
	BUNins(bn, "hident", b->hident,FALSE);
	BUNins(bn, "hdense", local_itoa(BAThdense(b)),FALSE);
	BUNins(bn, "hseqbase", oidtostr(b->hseqbase),FALSE);
	BUNins(bn, "hkey", local_itoa(b->hkey),FALSE);
	BUNins(bn, "hloc", local_itoa(b->hloc),FALSE);
	BUNins(bn, "hvarsized", local_itoa(b->hvarsized),FALSE);
	BUNins(bn, "halign", local_utoa(b->halign),FALSE);
	BUNins(bn, "hnosorted", local_utoa(b->H->nosorted),FALSE);
	BUNins(bn, "hnosorted_rev", local_utoa(b->H->nosorted_rev),FALSE);
	BUNins(bn, "hnodense", local_utoa(b->H->nodense),FALSE);
	BUNins(bn, "hnokey[0]", local_utoa(b->H->nokey[0]),FALSE);
	BUNins(bn, "hnokey[1]", local_utoa(b->H->nokey[1]),FALSE);

	BUNins(bn, "tident", b->tident,FALSE);
	BUNins(bn, "tdense", local_itoa(BATtdense(b)),FALSE);
	BUNins(bn, "tseqbase", oidtostr(b->tseqbase),FALSE);
	BUNins(bn, "tsorted", local_itoa(BATtordered(b)),FALSE);
	BUNins(bn, "tkey", local_itoa(b->tkey),FALSE);
	BUNins(bn, "tloc", local_itoa(b->tloc),FALSE);
	BUNins(bn, "tvarsized", local_itoa(b->tvarsized),FALSE);
	BUNins(bn, "talign", local_utoa(b->talign),FALSE);
	BUNins(bn, "tnosorted", local_utoa(b->T->nosorted),FALSE);
	BUNins(bn, "tnosorted_rev", local_utoa(b->T->nosorted_rev),FALSE);
	BUNins(bn, "tnodense", local_utoa(b->T->nodense),FALSE);
	BUNins(bn, "tnokey[0]", local_utoa(b->T->nokey[0]),FALSE);
	BUNins(bn, "tnokey[1]", local_utoa(b->T->nokey[1]),FALSE);

	BUNins(bn, "batInserted", local_utoa(BUNindex(b, b->batInserted)),FALSE);
	BUNins(bn, "batDeleted", local_utoa(BUNindex(b, b->batDeleted)),FALSE);
	BUNins(bn, "batFirst", local_utoa(BUNindex(b, b->batFirst)),FALSE);
	BUNins(bn, "top", local_utoa(BUNindex(b, (BUN) ((char *) Bunbase(b) + b->batBuns->free))),FALSE);
	BUNins(bn, "batStamp", local_itoa(b->batStamp),FALSE);
	BUNins(bn, "lastUsed", local_itoa(BBP_lastused(b->batCacheid)),FALSE);
	BUNins(bn, "curStamp", local_itoa(BBPcurstamp()),FALSE);
	BUNins(bn, "batCopiedtodisk", local_itoa(b->batCopiedtodisk),FALSE);
	BUNins(bn, "batDirtydesc", b->batDirtydesc ? "dirty" : "clean",FALSE);

	BUNins(bn, "batDirtybuns", b->batDirtybuns ? "dirty" : "clean",FALSE);
	infoHeap(bn, b->batBuns, "batBuns.");

	BUNins(bn, "hheapdirty", b->hheapdirty ? "dirty" : "clean",FALSE);
	infoHeap(bn, b->hheap, "hheap.");

	BUNins(bn, "theapdirty", b->theapdirty ? "dirty" : "clean",FALSE);
	infoHeap(bn, b->theap, "theap.");

	/* dump index information */
	if (b->hhash) {