bat5.mx

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

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) {
		HASHinfo(bn, b->hhash, "hhash->");
	}
	if (b->thash) {
		HASHinfo(bn, b->thash, "thash->");
	}
	return GDK_SUCCEED;
}

#define ROUND_UP(x,y) ((y)*(((x)+(y)-1)/(y)))

int
CMDbatsize(lng *tot, BAT *b)
{
	size_t blksize = MT_pagesize();
	size_t size = ROUND_UP(sizeof(BATstore), blksize);

	if (!VIEWparent(b)) {
		size_t cnt = BATcapacity(b);

		size += ROUND_UP(b->batBuns->size, blksize);
		if (b->hheap)
			size += ROUND_UP(b->hheap->size, blksize);
		if (b->theap)
			size += ROUND_UP(b->theap->size, blksize);
		if (b->hhash)
			size += ROUND_UP(sizeof(hash_t) * cnt, blksize);
		if (b->thash)
			size += ROUND_UP(sizeof(hash_t) * cnt, blksize);
	}
	*tot = size;
	return GDK_SUCCEED;
}

int
CMDbatsize_str(lng *tot, str batname)
{
	bat bid = BBPindex(batname);
	BAT *b = bid ? (BAT *) BBPgetdesc(bid) : NULL;

	if (b == NULL) {
		GDKerror("CMDbatsize_str: %s no such bat.\n", batname);
		return GDK_FAIL;
	}
	return CMDbatsize(tot, b);
}

@+ Synced BATs
@c
int
CMDsynced(bit *ret, BAT *b1, BAT *b2)
{
	*ret = ALIGNsynced(b1, b2) ? 1 : 0;
	return GDK_SUCCEED;
}

@+ BBP Management, IO
@c
int
CMDroles(BAT **r, BAT *b, str hname, str tname)
{
	BATroles(*r = b, hname, tname);
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDcol_name(BAT **r, BAT *b, str tname)
{
	BATcol_name(*r = b, tname);
	BBPfix(b->batCacheid);
	return GDK_SUCCEED;
}

int
CMDrename(bit *retval, BAT *b, str s)
{
	int ret;
	int c;
	char *t = s;

	for ( ; (c = *t) != 0; t++) {
		if (c != '_' && !GDKisalnum(c)) {
			GDKerror("CMDrename: identifier expected: %s\n", s);
			return GDK_FAIL;
		}
	}

	ret = BATname(b, s);
	*retval = FALSE;
	if (ret == 1) {
		GDKerror("CMDrename: identifier expected: %s\n", s);
		return GDK_FAIL;
	} else if (ret == BBPRENAME_ILLEGAL) {
		GDKerror("CMDrename: illegal temporary name: '%s'\n", s);
		return GDK_FAIL;
	} else if (ret == BBPRENAME_LONG) {
		GDKerror("CMDrename: name too long: '%s'\n", s);
		return GDK_FAIL;
	} else if (ret != BBPRENAME_ALREADY) {
		*retval = TRUE;
	}
	return GDK_SUCCEED;
}

int
CMDname(str *retval, BAT *b)
{
	*retval = GDKstrdup(BBPname(b->batCacheid));
	return GDK_SUCCEED;
}

int
CMDunload(bit *res, str input)
{
	bat bid = ABS(BBPindex(input));

	*res = FALSE;
	if (bid > 0) {
		BAT *b;

		BBPfix(bid);
		b = BBP_cache(bid);
		if (b) {
			if (b->batPersistence == SESSION)
				BATmode(b, TRANSIENT);
			BBPcold(bid);	/* will trigger unload of also persistent bats */
		}
		*res = BBPunfix(bid) == 0;
	}
	return GDK_SUCCEED;
}

int
CMDhot(str input)
{
	BBPhot(BBPindex(input));
	return GDK_SUCCEED;
}

int
CMDcold(str input)
{
	BBPcold(BBPindex(input));
	return GDK_SUCCEED;
}

int
CMDheat(int *res, str input)
{