自学教程：C++ BBPkeepref函数代码示例

strDCsliceStrict(int *ret, bat *bid, lng *start, lng *end){	BAT *b, *bn = NULL;	if ((b = BATdescriptor(*bid)) == NULL) {		throw(MAL, "dcoperator.sliceStrict", "Cannot access descriptor");	}	assert(*start >= 0);	assert(*end >= 0);	assert(*start <= (lng) BUN_MAX);	assert(*end < (lng) BUN_MAX);	assert(*start <= *end);	if ((BUN) ((*end - *start) + 1) > BATcount(b)) {		bn = BATnew(b->htype, b->ttype, 0);		BATsetcount(bn, 0);		*ret = bn->batCacheid;		BBPkeepref(*ret);		return MAL_SUCCEED;	}	bn = BATslice(b, (BUN) *start, (BUN) *end + 1);	BBPreleaseref(b->batCacheid);	if (bn != NULL) {		if (!(bn->batDirty & 2))			bn = BATsetaccess(bn, BAT_READ);		*ret = bn->batCacheid;		BBPkeepref(*ret);		return MAL_SUCCEED;	}	throw(MAL, "dcoperator.sliceStrict", "GDKerror");}

/* * Enable incremental packing. The SQL front-end requires * fixed oid sequences. */strMATpackIncrement(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p){	bat *ret = getArgReference_bat(stk,p,0);	int	pieces;	BAT *b, *bb, *bn;	size_t newsize;	(void) cntxt;	b = BATdescriptor( stk->stk[getArg(p,1)].val.ival);	if ( b == NULL)		throw(MAL, "mat.pack", RUNTIME_OBJECT_MISSING);	if ( getArgType(mb,p,2) == TYPE_int){		/* first step, estimate with some slack */		pieces = stk->stk[getArg(p,2)].val.ival;		bn = BATnew(TYPE_void, b->ttype?b->ttype:TYPE_oid, (BUN)(1.2 * BATcount(b) * pieces), TRANSIENT);		if (bn == NULL)			throw(MAL, "mat.pack", MAL_MALLOC_FAIL);		/* allocate enough space for the vheap, but not for strings,		 * since BATappend does clever things for strings */		if ( b->T->vheap && bn->T->vheap && ATOMstorage(b->ttype) != TYPE_str){			newsize =  b->T->vheap->size * pieces;			if (HEAPextend(bn->T->vheap, newsize, TRUE) != GDK_SUCCEED)				throw(MAL, "mat.pack", MAL_MALLOC_FAIL);		}		BATseqbase(bn, b->H->seq);		BATseqbase(BATmirror(bn), b->T->seq);		BATappend(bn,b,FALSE);		assert(!bn->H->nil || !bn->H->nonil);		assert(!bn->T->nil || !bn->T->nonil);		bn->H->align = (pieces-1);		BBPkeepref(*ret = bn->batCacheid);		BBPunfix(b->batCacheid);	} else {		/* remaining steps */		bb = BATdescriptor(stk->stk[getArg(p,2)].val.ival);		if ( bb ){			if (BATcount(b) == 0)				BATseqbase(b, bb->H->seq);			if (BATcount(b) == 0)				BATseqbase(BATmirror(b), bb->T->seq);			BATappend(b,bb,FALSE);		}		b->H->align--;		if(b->H->align == 0)			BATsetaccess(b, BAT_READ);		assert(!b->H->nil || !b->H->nonil);		assert(!b->T->nil || !b->T->nonil);		BBPkeepref(*ret = b->batCacheid);		if( bb) 			BBPunfix(bb->batCacheid);	}	return MAL_SUCCEED;}

/* * The nextChunk version advances the reader, * which also means that the view descriptor is already available. * The granule size may differ in each call. */strITRnextChunk(lng *res, int *vid, int *bid, lng *granule){	BAT *b, *view;	BUN i;	if ((b = BATdescriptor(*bid)) == NULL) {			throw(MAL, "iterator.nextChunk", INTERNAL_BAT_ACCESS);	}	if ((view = BATdescriptor(*vid)) == NULL) {		BBPunfix(b->batCacheid);		throw(MAL, "iterator.nextChunk", INTERNAL_BAT_ACCESS);	}	i = (BUN) (*res + BATcount(view));	if (i >= BUNlast(b)) {		*res = lng_nil;		*vid = 0;		BBPunfix(view->batCacheid);		BBPunfix(b->batCacheid);		return MAL_SUCCEED;	}	/* printf("set bat chunk bound to " BUNFMT " - " BUNFMT " /n",	   i, i+(BUN) *granule-1); */	VIEWbounds(b, view, i, i + (BUN) * granule);	BATseqbase(view, b->hseqbase == oid_nil ? oid_nil : b->hseqbase + i - BUNfirst(b));	BBPkeepref(*vid = view->batCacheid);	BBPunfix(b->batCacheid);	*res = i;	return MAL_SUCCEED;}

strAGGRsubmin_val(bat *retval, bat *bid, bat *gid, bat *eid, bit *skip_nils){	BAT *a, *b, *r;	str res;	bat ret;	if ((res = AGGRsubgrouped(&ret, NULL, bid, gid, eid, NULL, *skip_nils,						  0, TYPE_oid, BATgroupmin, NULL, "aggr.submin")) != MAL_SUCCEED)		return res;	b = BATdescriptor(*bid);	if( b == NULL)		throw(MAL,"aggr.submax", INTERNAL_BAT_ACCESS);	a = BATdescriptor(ret);	if( a == NULL){		BBPreleaseref(b->batCacheid);		throw(MAL,"aggr.submax", INTERNAL_BAT_ACCESS);	}	r = BATproject(a, b);	BBPreleaseref(b->batCacheid);	BBPreleaseref(a->batCacheid);	BBPdecref(ret, TRUE);	BBPkeepref(*retval = r->batCacheid);	return MAL_SUCCEED;}

static strCMDbatUNARY1(MalStkPtr stk, InstrPtr pci, int abort_on_error,			 BAT *(*batfunc)(BAT *, BAT *, int), const char *malfunc){	bat *bid;	BAT *bn, *b, *s = NULL;	bid = getArgReference_bat(stk, pci, 1);	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);	if (pci->argc == 3) {		bat *sid = getArgReference_bat(stk, pci, 2);		if (*sid && (s = BATdescriptor(*sid)) == NULL) {			BBPunfix(b->batCacheid);			throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);		}	}	bn = (*batfunc)(b, s, abort_on_error);	BBPunfix(b->batCacheid);	if (s)		BBPunfix(s->batCacheid);	if (bn == NULL) {		return mythrow(MAL, malfunc, OPERATION_FAILED);	}	bid = getArgReference_bat(stk, pci, 0);	BBPkeepref(*bid = bn->batCacheid);	return MAL_SUCCEED;}

strBKCsetAccess(bat *res, const bat *bid, const char * const *param){	BAT *b;	int m;	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "bat.setAccess", RUNTIME_OBJECT_MISSING);	switch (*param[0]) {	case 'r':		m = BAT_READ;		break;	case 'a':		m = BAT_APPEND;		break;	case 'w':		m = BAT_WRITE;		break;	default:		*res = 0;		throw(MAL, "bat.setAccess", ILLEGAL_ARGUMENT " Got %c" " expected 'r','a', or 'w'", *param[0]);	}	if ((b = setaccess(b, m)) == NULL)		throw(MAL, "bat.setAccess", OPERATION_FAILED);	BBPkeepref(*res = b->batCacheid);	return MAL_SUCCEED;}

static strCMDconvertbat(MalStkPtr stk, InstrPtr pci, int tp, int abort_on_error){	bat *bid;	BAT *b, *bn, *s = NULL;	bid = getArgReference_bat(stk, pci, 1);	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "batcalc.convert", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);	if (pci->argc == 3) {		bat *sid = getArgReference_bat(stk, pci, 2);		if (*sid && (s = BATdescriptor(*sid)) == NULL) {			BBPunfix(b->batCacheid);			throw(MAL, "batcalc.convert", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);		}	}	bn = BATconvert(b, s, tp, abort_on_error);	BBPunfix(b->batCacheid);	if (s)		BBPunfix(s->batCacheid);	if (bn == NULL) {		char buf[20];		snprintf(buf, sizeof(buf), "batcalc.%s", ATOMname(tp));		return mythrow(MAL, buf, OPERATION_FAILED);	}	bid = getArgReference_bat(stk, pci, 0);	BBPkeepref(*bid = bn->batCacheid);	return MAL_SUCCEED;}

strAGGRsubmaxcand_val(bat *retval, bat *bid, bat *gid, bat *eid, bat *sid, bit *skip_nils){	BAT *a, *b, *r;	str res;	bat ret;	if ((res = AGGRsubgrouped(&ret, NULL, bid, gid, eid, sid, *skip_nils,						  0, TYPE_oid, BATgroupmax, NULL, "aggr.submax")) != MAL_SUCCEED)		return res;	b = BATdescriptor(*bid);	if ( b == NULL)		throw(MAL,"aggr.max",RUNTIME_OBJECT_MISSING);	a = BATdescriptor(ret);	if ( a == NULL){		BBPreleaseref(b->batCacheid);		throw(MAL,"aggr.max",RUNTIME_OBJECT_MISSING);	}		r = BATproject(a, b);	BBPreleaseref(b->batCacheid);	BBPreleaseref(a->batCacheid);	BBPdecref(ret, TRUE);	BBPkeepref(*retval = r->batCacheid);	return MAL_SUCCEED;}

strJSONvalueTable(bat *ret, json *js){	BAT *bn;	char *r;	int i;	JSON *jt;	jt = JSONparse(*js, FALSE);	// already validated	CHECK_JSON(jt);	bn = BATnew(TYPE_void, TYPE_json, 64, TRANSIENT);	if (bn == NULL)		throw(MAL, "json.values", MAL_MALLOC_FAIL);	BATseqbase(bn, 0);	bn->hsorted = 1;	bn->hrevsorted = 0;	bn->H->nonil = 1;	bn->tsorted = 1;	bn->trevsorted = 0;	bn->T->nonil = 1;	for (i = jt->elm[0].next; i; i = jt->elm[i].next) {		if (jt->elm[i].kind == JSON_ELEMENT)			r = JSONgetValue(jt, jt->elm[i].child);		else			r = JSONgetValue(jt, i);		BUNappend(bn, r, FALSE);		GDKfree(r);	}	BBPkeepref(*ret = bn->batCacheid);	return MAL_SUCCEED;}

strMseedLoadSQL(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci){	int *ret = (int*) getArgReference(stk,pci,0);	str *targetfile = (str*) getArgReference(stk,pci,1);	str msg = MAL_SUCCEED;	BAT *btime, *bdata, *table;	(void) cntxt;	(void) mb;/* XXX: BATs of BATs are no longer allowed and this code hasn't worked * for quite some time anyway */	table = BATnew(TYPE_str,TYPE_bat,0);	if ( table == NULL)		throw(MAL, "mseed.load", MAL_MALLOC_FAIL);	msg = MseedLoadIntern(&btime, &bdata, *targetfile);	if ( msg == MAL_SUCCEED){		BUNins(table, (ptr)"time", (ptr)&btime->batCacheid, FALSE);		BUNins(table, (ptr)"data", (ptr)&bdata->batCacheid, FALSE);		BBPreleaseref(btime->batCacheid);		BBPreleaseref(bdata->batCacheid);		BBPkeepref(*ret= table->batCacheid);	}	return msg;}

strMATpackValues(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p){	int i,*ret, type, first = 1;	BAT *bn;	(void) cntxt;	type = getArgType(mb,p,first);	bn = BATnew(TYPE_void, type, p->argc, TRANSIENT);	if( bn == NULL)		throw(MAL, "mat.pack", MAL_MALLOC_FAIL);	if (ATOMvarsized(type)) {		for(i = first; i < p->argc; i++)			BUNappend(bn, stk->stk[getArg(p,i)].val.sval, TRUE);	} else {		for(i = first; i < p->argc; i++)			BUNappend(bn, getArgReference(stk, p, i), TRUE);	}    BATsettrivprop(bn);    BATderiveProps(bn,FALSE);	ret= (int*) getArgReference(stk,p,0);	BBPkeepref(*ret = bn->batCacheid);	return MAL_SUCCEED;}

strBKCbat_inplace_force(bat *r, const bat *bid, const bat *rid, const bat *uid, const bit *force){	BAT *b, *p, *u;	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "bat.inplace", RUNTIME_OBJECT_MISSING);	if ((p = BATdescriptor(*rid)) == NULL) {		BBPunfix(b->batCacheid);		throw(MAL, "bat.inplace", RUNTIME_OBJECT_MISSING);	}	if ((u = BATdescriptor(*uid)) == NULL) {		BBPunfix(b->batCacheid);		BBPunfix(p->batCacheid);		throw(MAL, "bat.inplace", RUNTIME_OBJECT_MISSING);	}	if (void_replace_bat(b, p, u, *force) == BUN_NONE) {		BBPunfix(b->batCacheid);		BBPunfix(p->batCacheid);		BBPunfix(u->batCacheid);		throw(MAL, "bat.inplace", GDK_EXCEPTION);	}	BBPkeepref(*r = b->batCacheid);	BBPunfix(p->batCacheid);	BBPunfix(u->batCacheid);	return MAL_SUCCEED;}

char *BKCappend_force_wrap(bat *r, const bat *bid, const bat *uid, const bit *force){	BAT *b, *u;	gdk_return ret;	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "bat.append", RUNTIME_OBJECT_MISSING);	if ((u = BATdescriptor(*uid)) == NULL) {		BBPunfix(b->batCacheid);		throw(MAL, "bat.append", RUNTIME_OBJECT_MISSING);	}	if (BATcount(u) == 0) {		ret = GDK_SUCCEED;	} else {		if ((b = setaccess(b, BAT_WRITE)) == NULL)			throw(MAL, "bat.append", OPERATION_FAILED);		ret = BATappend(b, u, *force);	}	BBPunfix(u->batCacheid);	if (ret != GDK_SUCCEED) {		BBPunfix(b->batCacheid);		throw(MAL, "bat.append", GDK_EXCEPTION);	}	if( b->batPersistence == PERSISTENT)		BATmsync(b);	BBPkeepref(*r = b->batCacheid);	return MAL_SUCCEED;}

strBKCdelete_bat_bun(bat *r, const bat *bid, const bat *sid){	BAT *b, *s;	gdk_return ret;	if (*bid == *sid)		return BKCdelete_all(r, bid);	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "bat.delete", RUNTIME_OBJECT_MISSING);	if ((s = BATdescriptor(*sid)) == NULL) {		BBPunfix(b->batCacheid);		throw(MAL, "bat.delete", RUNTIME_OBJECT_MISSING);	}	ret = BATdel(b, s, FALSE);	BBPunfix(s->batCacheid);	if (ret != GDK_SUCCEED) {		BBPunfix(b->batCacheid);		 throw(MAL, "bat.delete_bat_bun", GDK_EXCEPTION);	}	if( b->batPersistence == PERSISTENT)		BATmsync(b);	BBPkeepref(*r = b->batCacheid);	return MAL_SUCCEED;}

strBKCmirror(bat *ret, const bat *bid){	BAT *b, *bn;	if ((b = BATdescriptor(*bid)) == NULL) {		throw(MAL, "bat.mirror", RUNTIME_OBJECT_MISSING);	}	bn = VIEWcombine(b);	if (bn != NULL) {		if (b->batRestricted == BAT_WRITE) {			BAT *bn1;			bn1 = BATcopy(bn, bn->htype, bn->ttype, FALSE, TRANSIENT);			BBPreclaim(bn);			bn = bn1;		}		if (bn != NULL) {			*ret = bn->batCacheid;			BBPkeepref(*ret);			BBPunfix(b->batCacheid);			return MAL_SUCCEED;		}	}	*ret = 0;	BBPunfix(b->batCacheid);	throw(MAL, "bat.mirror", GDK_EXCEPTION);}

strMATpackValues(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p){	int i, type, first = 1;	bat *ret;	BAT *bn;	(void) cntxt;	type = getArgType(mb,p,first);	bn = BATnew(TYPE_void, type, p->argc, TRANSIENT);	if( bn == NULL)		throw(MAL, "mat.pack", MAL_MALLOC_FAIL);	if (ATOMextern(type)) {		for(i = first; i < p->argc; i++)			BUNappend(bn, stk->stk[getArg(p,i)].val.pval, TRUE);	} else {		for(i = first; i < p->argc; i++)			BUNappend(bn, getArgReference(stk, p, i), TRUE);	}	BATseqbase(bn, 0);	ret= getArgReference_bat(stk,p,0);	BBPkeepref(*ret = bn->batCacheid);	return MAL_SUCCEED;}

strMseedLoad(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci){	int *ret0 = (int*) getArgReference(stk,pci,0);	int *ret1 = (int*) getArgReference(stk,pci,1);	str *targetfile = (str*) getArgReference(stk,pci,2);	str msg;	BAT *btime, *bdata;	(void) cntxt;	(void) mb;	msg = MseedLoadIntern(&btime, &bdata, *targetfile);	if ( msg == MAL_SUCCEED){		BBPkeepref(*ret0 = btime->batCacheid);		BBPkeepref(*ret1 = bdata->batCacheid);	}	return msg;}

/* * Property management * All property operators should ensure exclusive access to the BAT * descriptor. * Where necessary use the primary view to access the properties */strBKCinfo(bat *ret1, bat *ret2, const bat *bid){	BAT *bk = NULL, *bv= NULL, *b;	if ((b = BATdescriptor(*bid)) == NULL) {		throw(MAL, "bat.getInfo", RUNTIME_OBJECT_MISSING);	}	if (CMDinfo(&bk, &bv, b) == GDK_SUCCEED) {		*ret1 = bk->batCacheid;		*ret2 = bv->batCacheid;		BBPkeepref(bk->batCacheid);		BBPkeepref(bv->batCacheid);		BBPunfix(*bid);		return MAL_SUCCEED;	}	BBPunfix(*bid);	throw(MAL, "BKCinfo", GDK_EXCEPTION);}

strCMDmodules(bat *bid){	BAT *b = TBL_getdir();	if (b) {		*bid = b->batCacheid;		BBPkeepref(*bid);	}	return MAL_SUCCEED;}

static voidpseudo(bat *ret, BAT *b, str X1,str X2) {	char buf[BUFSIZ];	snprintf(buf,BUFSIZ,"%s_%s", X1,X2);	if (BBPindex(buf) <= 0)		BATname(b,buf);	BATroles(b,X1,X2);	BATmode(b,TRANSIENT);	BATfakeCommit(b);	*ret = b->batCacheid;	BBPkeepref(*ret);}

strTRNtrans_prev(int *ret, int *bid){	BAT *b,*bn= NULL;	b= BATdescriptor(*bid);	if (b  == NULL)		throw(MAL, "transaction.prev", RUNTIME_OBJECT_MISSING);	bn = BATprev(b);	BBPkeepref(*ret = bn->batCacheid);	BBPunfix(b->batCacheid);	return MAL_SUCCEED;}

/* * The pack is an ordinary multi BAT insert. Oid synchronistion * between pieces should be ensured by the code generators. * The pack operation could be quite expensive, because it * may create a really large BAT. * The slice over a mat helps to avoid constructing intermediates * that are subsequently reduced. * Contrary to most operations, NIL arguments are skipped and * do not produce RUNTIME_OBJECT_MISSING. */static strMATpackInternal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p){	int i, *ret = (int*) getArgReference(stk,p,0);	BAT *b, *bn;	BUN cap = 0;	int tt = TYPE_any;	(void) cntxt;	(void) mb;	for (i = 1; i < p->argc; i++) {		int bid = stk->stk[getArg(p,i)].val.ival;		b = BBPquickdesc(abs(bid),FALSE);		if (b && bid < 0)			b = BATmirror(b);		if( b ){			assert(BAThdense(b));			if (tt == TYPE_any){				tt = b->ttype;			}			if (!tt && tt != b->ttype)				tt = b->ttype;			cap += BATcount(b);		}	}	if (tt == TYPE_any){		*ret = 0;		return MAL_SUCCEED;	}	bn = BATnew(TYPE_void, tt, cap, TRANSIENT);	if (bn == NULL)		throw(MAL, "mat.pack", MAL_MALLOC_FAIL);	for (i = 1; i < p->argc; i++) {		b = BATdescriptor(stk->stk[getArg(p,i)].val.ival);		if( b ){			if (BATcount(bn) == 0)				BATseqbase(bn, b->H->seq);			if (BATcount(bn) == 0)				BATseqbase(BATmirror(bn), b->T->seq);			BATappend(bn,b,FALSE);			BBPunfix(b->batCacheid);		}	}	assert(!bn->H->nil || !bn->H->nonil);	assert(!bn->T->nil || !bn->T->nonil);	BATsettrivprop(bn);	BATderiveProps(bn,FALSE);	BBPkeepref(*ret = bn->batCacheid);	return MAL_SUCCEED;}

strBKCsetkey(bat *res, const bat *bid, const bit *param){	BAT *b;	if ((b = BATdescriptor(*bid)) == NULL) {		throw(MAL, "bat.setKey", RUNTIME_OBJECT_MISSING);	}	BATkey(BATmirror(b), *param ? BOUND2BTRUE :FALSE);	*res = b->batCacheid;	BBPkeepref(b->batCacheid);	return MAL_SUCCEED;}

strCMDgetTrace(bat *res, str *ev){	BAT *bn;	(void) res;		/* fool compiler */	bn = getTrace(*ev);	if (bn) {		BBPkeepref(*res = bn->batCacheid);		return MAL_SUCCEED;	}	throw(MAL, "getTrace", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING  "%s",*ev);}

strGRPsubgroup4(bat *ngid, bat *next, bat *nhis, bat *bid, bat *gid, bat *eid, bat *hid){	BAT *b, *g, *e, *h, *gn, *en, *hn;	gdk_return r;	b = BATdescriptor(*bid);	g = gid ? BATdescriptor(*gid) : NULL;	e = eid ? BATdescriptor(*eid) : NULL;	h = hid ? BATdescriptor(*hid) : NULL;	if (b == NULL ||		(gid != NULL && g == NULL) ||		(eid != NULL && e == NULL) ||		(hid != NULL && h == NULL)) {		if (g)			BBPreleaseref(g->batCacheid);		if (e)			BBPreleaseref(e->batCacheid);		if (h)			BBPreleaseref(h->batCacheid);		throw(MAL, "group.subgroup", RUNTIME_OBJECT_MISSING);	}	if ((r = BATgroup(&gn, &en, &hn, b, g, e, h)) == GDK_SUCCEED) {		*ngid = gn->batCacheid;		*next = en->batCacheid;		*nhis = hn->batCacheid;		BBPkeepref(*ngid);		BBPkeepref(*next);		BBPkeepref(*nhis);	}	BBPreleaseref(b->batCacheid);	if (g)		BBPreleaseref(g->batCacheid);	if (e)		BBPreleaseref(e->batCacheid);	if (h)		BBPreleaseref(h->batCacheid);	return r == GDK_SUCCEED ? MAL_SUCCEED : createException(MAL, "group.subgroup", GDK_EXCEPTION);}

strBKCnewBAT(bat *res, const int *ht, const int *tt, const BUN *cap, int role){	BAT *bn;	bn = BATnew(*ht == TYPE_oid ? TYPE_void : *ht, *tt, *cap, role);	if (bn == NULL)		throw(MAL, "bat.new", GDK_EXCEPTION);	if (*ht == TYPE_oid)		BATseqbase(bn, 0);	*res = bn->batCacheid;	BBPkeepref(*res);	return MAL_SUCCEED;}

strBKCattach(bat *ret, const int *tt, const char * const *heapfile){	BAT *bn;	bn = BATattach(*tt, *heapfile, TRANSIENT);	if (bn == NULL)		throw(MAL, "bat.attach", GDK_EXCEPTION);	if( bn->batPersistence == PERSISTENT)		BATmsync(bn);	*ret = bn->batCacheid;	BBPkeepref(*ret);	return MAL_SUCCEED;}

strBKCreverse(bat *ret, const bat *bid){	BAT *b, *bn = NULL;	if ((b = BATdescriptor(*bid)) == NULL) {		throw(MAL, "bat.reverse", RUNTIME_OBJECT_MISSING);	}	bn = BATmirror(b);			/* bn inherits ref from b */	assert(bn != NULL);	*ret = bn->batCacheid;	BBPkeepref(bn->batCacheid);	return MAL_SUCCEED;}

strBKCbun_inplace_force(bat *r, const bat *bid, const oid *id, const void *t, const bit *force){	BAT *b;	(void) r;	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "bat.inplace", RUNTIME_OBJECT_MISSING);	if (void_inplace(b, *id, t, *force) != GDK_SUCCEED) {		BBPunfix(b->batCacheid);		throw(MAL, "bat.inplace", GDK_EXCEPTION);	}	BBPkeepref(*r = b->batCacheid);	return MAL_SUCCEED;}

strdb_users_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci){	bat *r = getArgReference_bat(stk, pci, 0);	BAT *uid, *nme;	str err;	(void) mb;	if ((err = AUTHgetUsers(&uid, &nme, cntxt)) != MAL_SUCCEED)		return err;	BBPunfix(uid->batCacheid);	*r = nme->batCacheid;	BBPkeepref(*r);	return MAL_SUCCEED;}