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

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

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

strITRbunNext(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci){	BATiter bi;	BAT *b;	oid *head;	bat *bid;	ValPtr tail;	(void) cntxt;	(void) mb;	head = (oid *) getArgReference(stk, pci, 0);	tail = getArgReference(stk,pci,1);	bid = (bat *) getArgReference(stk, pci, 2);	if ((b = BATdescriptor(*bid)) == NULL) {		throw(MAL, "iterator.nextChunk", INTERNAL_BAT_ACCESS);	}	*head = (BUN)*head + 1;	if (*head >= BUNlast(b)) {		*head = oid_nil;		BBPunfix(b->batCacheid);		return MAL_SUCCEED;	} 	bi = bat_iterator(b);	VALinit(tail, b->ttype, BUNtail(bi, *(BUN*) head));	BBPunfix(b->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;}

strCMDcalcavg(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci){	dbl avg;	BUN vals;	bat *bid;	BAT *b, *s = NULL;	gdk_return ret;	(void) cntxt;	(void) mb;	bid = getArgReference_bat(stk, pci, pci->retc + 0);	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "aggr.avg", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);	if (pci->retc == pci->retc + 2) {		bat *sid = getArgReference_bat(stk, pci, pci->retc + 1);		if (*sid && (s = BATdescriptor(*sid)) == NULL) {			BBPunfix(b->batCacheid);			throw(MAL, "aggr.avg", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);		}	}	ret = BATcalcavg(b, s, &avg, &vals);	BBPunfix(b->batCacheid);	if (s)		BBPunfix(s->batCacheid);	if (ret != GDK_SUCCEED)		return mythrow(MAL, "aggr.avg", OPERATION_FAILED);	* getArgReference_dbl(stk, pci, 0) = avg;	if (pci->retc == 2)		* getArgReference_lng(stk, pci, 1) = vals;	return MAL_SUCCEED;}

/* * @- * The BUN- and BAT-stream manipulate a long handle, i.e. * the destination variable. It assumes it has been set to * zero as part of runtime stack initialization. Subsequently, * it fetches a bun and returns the increment to the control * variable. If it returns zero the control variable has been reset * to zero and end of stream has been reached. */strITRbunIterator(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci){	BATiter bi;	BAT *b;	oid *head;	bat *bid;	ValPtr tail;	(void) cntxt;	(void) mb;	head = getArgReference_oid(stk, pci, 0);	tail = &stk->stk[pci->argv[1]];	bid = getArgReference_bat(stk, pci, 2);	if ((b = BATdescriptor(*bid)) == NULL) {		throw(MAL, "iterator.nextChunk", INTERNAL_BAT_ACCESS);	}	if (BATcount(b) == 0) {		*head = oid_nil;		BBPunfix(b->batCacheid);		return MAL_SUCCEED;	}	*head = BUNfirst(b); 	bi = bat_iterator(b);	VALinit(tail, b->ttype, BUNtail(bi, *(BUN*) head));	BBPunfix(b->batCacheid);	return MAL_SUCCEED;}

strdb_password_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci){	(void) mb;	if (stk->stk[pci->argv[0]].vtype == TYPE_bat) {		BAT *b = BATdescriptor(*getArgReference_bat(stk, pci, 1));		if (b == NULL)			throw(SQL, "sql.password", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);		BAT *bn = COLnew(b->hseqbase, TYPE_str, BATcount(b), TRANSIENT);		if (bn == NULL) {			BBPunfix(b->batCacheid);			throw(SQL, "sql.password", SQLSTATE(HY001) MAL_MALLOC_FAIL);		}		BATiter bi = bat_iterator(b);		BUN p, q;		BATloop(b, p, q) {			char *hash, *msg;			msg = AUTHgetPasswordHash(&hash, cntxt, BUNtvar(bi, p));			if (msg != MAL_SUCCEED) {				BBPunfix(b->batCacheid);				BBPreclaim(bn);				return msg;			}			if (BUNappend(bn, hash, false) != GDK_SUCCEED) {				BBPunfix(b->batCacheid);				BBPreclaim(bn);				throw(SQL, "sql.password", SQLSTATE(HY001) MAL_MALLOC_FAIL);			}			GDKfree(hash);		}

strBATXMLxml2str(bat *ret, const bat *bid){	BAT *b, *bn;	BUN p, q;	BATiter bi;	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "xml.str", INTERNAL_BAT_ACCESS);	prepareResult(bn, b, TYPE_str, "str", (void) 0);	bi = bat_iterator(b);	BATloop(b, p, q) {		const char *t = (const char *) BUNtail(bi, p);		if (strNil(t)) {			bunfastapp(bn, t);			bn->T->nonil = 0;		} else {			assert(*t == 'A' || *t == 'C' || *t == 'D');			bunfastapp(bn, t + 1);		}	}	finalizeResult(ret, bn, b);	return MAL_SUCCEED;  bunins_failed:	BBPunfix(b->batCacheid);	BBPunfix(bn->batCacheid);	throw(MAL, "xml.str", OPERATION_FAILED " during bulk coercion");}

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

/* calculate the footprint for optimizer pipe line choices * and identify empty columns upfront for just in time optimizers. */static lngSQLgetColumnSize(sql_trans *tr, sql_column *c, int access){	lng size = 0;	BAT *b;	switch(access){	case 0:		b= store_funcs.bind_col(tr, c, RDONLY);		if (b) {			size += getBatSpace(b);			BBPunfix(b->batCacheid);		}		break;	case 1:		b = store_funcs.bind_col(tr, c, RD_INS);		if (b) {			size+= getBatSpace(b);			BBPunfix(b->batCacheid);		}		break;	case 2:		b = store_funcs.bind_col(tr, c, RD_UPD_VAL);		if (b) {			size += getBatSpace(b);			BBPunfix(b->batCacheid);		}		b = store_funcs.bind_col(tr, c, RD_UPD_ID);		if (b) {			size+= getBatSpace(b);			BBPunfix(b->batCacheid);		}	}	return size;}

strbatstr_2time_timestamptz(bat *res, const bat *bid, const int *digits, int *tz){	BAT *b, *dst;	BATiter bi;	BUN p, q;	char *msg = NULL;	if ((b = BATdescriptor(*bid)) == NULL) {		throw(SQL, "batcalc.str_2time_timestamp", "Cannot access descriptor");	}	bi = bat_iterator(b);	dst = BATnew(TYPE_void, TYPE_timestamp, BATcount(b), TRANSIENT);	if (dst == NULL) {		BBPunfix(b->batCacheid);		throw(SQL, "sql.timestamp", MAL_MALLOC_FAIL);	}	BATseqbase(dst, b->hseqbase);	BATloop(b, p, q) {		char *v = (char *) BUNtail(bi, p);		union {			lng l;			timestamp r;		} u;		msg = str_2time_timestamptz(&u.r, &v, digits, tz);		if (msg) {			BBPunfix(dst->batCacheid);			BBPunfix(b->batCacheid);			return msg;		}		BUNappend(dst, &u.r, FALSE);	}

strBATXMLdocument(bat *ret, const bat *bid){	BAT *b, *bn;	BUN p, q;	BATiter bi;	size_t size = BUFSIZ;	str buf = GDKmalloc(size);	const char *err = OPERATION_FAILED;	if (buf == NULL)		throw(MAL,"xml.document",MAL_MALLOC_FAIL);	if ((b = BATdescriptor(*bid)) == NULL) {		GDKfree(buf);		throw(MAL, "xml.document", INTERNAL_BAT_ACCESS);	}	prepareResult(bn, b, TYPE_xml, "document", GDKfree(buf));	bi = bat_iterator(b);	BATloop(b, p, q) {		const char *t = (const char *) BUNtail(bi, p);		xmlDocPtr doc;		int len;		xmlChar *s;		if (strNil(t)) {			bunfastapp(bn, str_nil);			bn->T->nonil = 0;			continue;		}		len = (int) strlen(t);		doc = xmlParseMemory(t, len);		if (doc == NULL) {			err = OPERATION_FAILED XML_PARSE_ERROR;			goto bunins_failed;		}		xmlDocDumpMemory(doc, &s, &len);		xmlFreeDoc(doc);		if ((size_t) len + 2 >= size) {			GDKfree(buf);			size = (size_t) len + 128;			buf = GDKmalloc(size);			if (buf == NULL) {				err= MAL_MALLOC_FAIL;				goto bunins_failed;			}		}		buf[0] = 'D';		strcpy(buf + 1, (char *) s);		bunfastapp(bn, buf);	}	GDKfree(buf);	finalizeResult(ret, bn, b);	return MAL_SUCCEED;  bunins_failed:	GDKfree(buf);	BBPunfix(b->batCacheid);	BBPunfix(bn->batCacheid);	throw(MAL, "xml.document", "%s", err);}

strBATXMLcomment(bat *ret, const bat *bid){	BAT *b, *bn;	BUN p, q;	size_t size = BUFSIZ;	str buf = GDKmalloc(size);	BATiter bi;	const char *err= OPERATION_FAILED;	if (buf == NULL)		throw(MAL, "xml.comment", MAL_MALLOC_FAIL);	if ((b = BATdescriptor(*bid)) == NULL) {		GDKfree(buf);		throw(MAL, "xml.comment", INTERNAL_BAT_ACCESS);	}	prepareResult(bn, b, TYPE_xml, "comment", GDKfree(buf));	bi = bat_iterator(b);	BATloop(b, p, q) {		const char *t = (const char *) BUNtail(bi, p);		size_t len;		if (strNil(t)) {			bunfastapp(bn, str_nil);			bn->T->nonil = 0;			continue;		}		if (strstr(t, "--") != NULL) {			err = XML_COMMENT_ERROR;			goto bunins_failed;		}		len = strlen(t);		if (len + 9 >= size) {			/* make sure there is enough space */			size = len + 128;			/* free/malloc so we don't copy */			GDKfree(buf);			buf = GDKmalloc(size);			if (buf == NULL) {				err = MAL_MALLOC_FAIL;				goto bunins_failed;			}		}		snprintf(buf, size, "C<!--%s-->", t);		bunfastapp(bn, buf);	}	GDKfree(buf);	finalizeResult(ret, bn, b);	return MAL_SUCCEED;  bunins_failed:	BBPunfix(b->batCacheid);	BBPunfix(bn->batCacheid);	if (buf != NULL)		GDKfree(buf);	throw(MAL, "xml.comment", "%s", err);}

static AGGRtask*GROUPcollect( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci){	AGGRtask *a;	int i;	BAT *b, *bs, *bh = NULL;	BUN sample;	(void) mb;	(void) cntxt;	a= (AGGRtask *) GDKzalloc(sizeof(*a));	if ( a == NULL)		return NULL;	a->bid = (bat*) GDKzalloc(pci->argc * sizeof(bat));	a->cols = (BAT**) GDKzalloc(pci->argc * sizeof(BAT*));	a->unique = (BUN *) GDKzalloc(pci->argc * sizeof(BUN));	if ( a->cols == NULL || a->bid == NULL || a->unique == NULL){		if(a->cols) GDKfree(a->cols);		if(a->bid) GDKfree(a->bid);		if(a->unique) GDKfree(a->unique);		GDKfree(a);		return NULL;	}	for ( i= pci->retc; i< pci->argc; i++, a->last++) {		a->bid[a->last] = *getArgReference_bat(stk,pci,i);		b = a->cols[a->last]= BATdescriptor(a->bid[a->last]);		if ( a->cols[a->last] == NULL){			for(a->last--; a->last>=0; a->last--)				BBPunfix(a->cols[a->last]->batCacheid);			GDKfree(a->cols);			GDKfree(a->bid);			GDKfree(a->unique);			GDKfree(a);			return NULL;		}		sample = BATcount(b) < 1000 ? BATcount(b): 1000;		bs = BATsample( b, sample);		if (bs) {			bh = BATunique(b, bs);			if (bh) {				a->unique[a->last] = BATcount(bh);				BBPunfix(bh->batCacheid);			}			BBPunfix(bs->batCacheid);		}		if ( b->tsorted)			a->unique[a->last] = 1000; /* sorting helps grouping */		a->size = BATcount(b);	}#ifdef _DEBUG_GROUPBY_	for(i=0; i<a->last; i++)		fprintf(stderr,"#group %d unique "BUNFMT "/n", i, a->unique[i]);#endif	return a;}

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

str DCselectInsert(int *ret, int *res, int *bid, lng *low, lng *hgh){	BAT *b, *r;	lng *readerH, *writerH;	lng *readerT, *writerT;	BUN size, i;	(void) ret;	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "dc.selectInsert", "Cannot access input BAT");	if ((r = BATdescriptor(*res)) == NULL)		throw(MAL, "dc.selectInsert", "Cannot access result BAT");	size = BATcount(b);	if (size > BATcapacity(r) - BATcount(r)) {		BUN ncap;		BUN grows;		BUN needed = size - (BATcapacity(r) - BATcount(r));		ncap = BATcapacity(r) + needed;		grows = BATgrows(r);		if (ncap > grows)			grows = ncap;		if (BATextend(r, grows) == NULL)			throw(MAL, "dc.selectInsert", "Failed to make room for the new values");	}/*printf("in dc.selectInsert size is "OIDFMT,size);*/	writerH = (lng *) Hloc(r, BUNfirst(r));	writerT = (lng *) Tloc(r, BUNfirst(r));	readerH = (lng *) Hloc(b, BUNfirst(b));	readerT = (lng *) Tloc(b, BUNfirst(b));	for (i = 0; i < size; i++) {		if (*readerT >= *low && *readerT <= *hgh) {			*writerH = *readerH;			*writerT = *readerT;			writerH++;			writerT++;		}		readerH++;		readerT++;	}	BATsetcount(r, (BUN) (writerT - (lng *) Tloc(r, BUNfirst(r))));	BBPunfix(*bid);	BBPunfix(*res);	return MAL_SUCCEED;}

/* * @- * The operator below is only working for a very limited cases. */str DCreplaceTailBasedOnHead(int *ret, int *res, int *bid){	BAT *b, *r;	oid *readerH_b;	int *writerT_r, *readerT_b;	BUN size_b, size_r, i;	(void) ret;	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "dc.replaceTailBasedOnHead", "Cannot access input BAT");	/* check for a failure */	assert(b != NULL);	if ((r = BATdescriptor(*res)) == NULL)		throw(MAL, "dc.replaceTailBasedOnHead", "Cannot access result BAT");	/* check for a failure */	assert(r != NULL);	/* remove Hashes etc */	if (r->H->hash)		HASHremove(r);	if (r->T->hash)		HASHremove(BATmirror(r));	size_r = BATcount(r);	size_b = BATcount(b);	if ((b->htype == TYPE_void) && (size_b == size_r)) {		writerT_r = (int *) Tloc(r, BUNfirst(r));		readerT_b = (int *) Tloc(b, BUNfirst(b));		for (i = 0; i < size_r; i++) {			*writerT_r = *readerT_b;			writerT_r++;			readerT_b++;		}	} else if ((b->htype != TYPE_void) && (size_b < size_r)) {		readerH_b = (oid *) Hloc(b, BUNfirst(b));		readerT_b = (int *) Tloc(b, BUNfirst(b));		for (i = 0; i < size_b; i++) {			writerT_r = (int *) Tloc(r, BUNfirst(r)) + *readerH_b;			*writerT_r = *readerT_b;			readerH_b++;			readerT_b++;		}	}	BBPunfix(*bid);	BBPunfix(*res);	r->batDirty = TRUE;	return MAL_SUCCEED;}

/* * The core of the activity is str2xml, where the actual strings * are constructed. * To avoid repetitive copying we make sure that the garbage * collector does not remove the xml intermediates. * This way, we know that as long as the xml-variables are not * reused, the complete structure of the xml document(s) are available. * We merely have to collect the pieces. * [FOR LATER, FIRST GO FOR THE EASY IMPLEMENTATION] * XML values are represented by strings already. */strBATXMLstr2xml(bat *ret, const bat *bid){	BAT *b, *bn;	BUN p, q;	size_t size = BUFSIZ;	str buf;	const char *err= OPERATION_FAILED;	BATiter bi;	buf = GDKmalloc(size);	if (buf == NULL)		throw(MAL,"xml.str2xml",MAL_MALLOC_FAIL);	if ((b = BATdescriptor(*bid)) == NULL) {		GDKfree(buf);		throw(MAL, "xml.xml", INTERNAL_BAT_ACCESS);	}	prepareResult(bn, b, TYPE_xml, "xml", GDKfree(buf));	bi = bat_iterator(b);	BATloop(b, p, q) {		const char *t = (const char *) BUNtail(bi, p);		size_t len;		if (strNil(t)) {			bunfastapp(bn, str_nil);			bn->T->nonil = 0;			continue;		}		len = strlen(t) * 6 + 1;		if (size < len) {			size = len + 128;			GDKfree(buf);			buf = GDKmalloc(size);			if (buf == NULL) {				err = MAL_MALLOC_FAIL;				goto bunins_failed;			}		}		buf[0] = 'C';		XMLquotestring(t, buf + 1, size - 1);		bunfastapp(bn, buf);	}	GDKfree(buf);	finalizeResult(ret, bn, b);	return MAL_SUCCEED;  bunins_failed:	BBPunfix(b->batCacheid);	BBPunfix(bn->batCacheid);	if (buf != NULL)		GDKfree(buf);	throw(MAL, "xml.xml", "%s", err);}

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

static lng SQLgetSpace(mvc *m, MalBlkPtr mb){	sql_trans *tr = m->session->tr;	lng space = 0, i; 	for (i = 0; i < mb->stop; i++) {		InstrPtr p = mb->stmt[i];		char *f = getFunctionId(p);		if (getModuleId(p) == sqlRef && (f == bindRef || f == bindidxRef)) {			int upd = (p->argc == 7 || p->argc == 9), mode = 0;			char *sname = getVarConstant(mb, getArg(p, 2 + upd)).val.sval;			char *tname = getVarConstant(mb, getArg(p, 3 + upd)).val.sval;			char *cname = NULL;			sql_schema *s = mvc_bind_schema(m, sname);			if (!s || strcmp(s->base.name, dt_schema) == 0) 				continue;			cname = getVarConstant(mb, getArg(p, 4 + upd)).val.sval;			mode = getVarConstant(mb, getArg(p, 5 + upd)).val.ival;			if (mode != 0 || !cname || !s)				continue;			if (f == bindidxRef) {				sql_idx *i = mvc_bind_idx(m, s, cname);				if (i && (!isRemote(i->t) && !isMergeTable(i->t))) {					BAT *b = store_funcs.bind_idx(tr, i, RDONLY);					if (b) {						space += getBatSpace(b);						BBPunfix(b->batCacheid);					}				}			} else if (f == bindRef) {				sql_table *t = mvc_bind_table(m, s, tname);				sql_column *c = mvc_bind_column(m, t, cname);				if (c && (!isRemote(c->t) && !isMergeTable(c->t))) {					BAT *b = store_funcs.bind_col(tr, c, RDONLY);					if (b) {						space += getBatSpace(b);						BBPunfix(b->batCacheid);					}				}			}		}	}	return space;}

/** * Function returns the highest file id that currently exists in the * bam.files table and stores this number + 1 in the next_file_id * variable. Function doesn't use a mutex to guarantee that the * returned value is up to date at return time. If this is required, * the calling function should activate a mutex. */strnext_file_id(mvc * m, sql_table * files, lng * next_file_id){	sql_column *c;	BAT *b = NULL;	BATiter li;	BUN p = 0, q = 0;	lng max_file_id = 0;	sht i;	assert(m != NULL);	assert(files != NULL);	/* Try to bind the file_id column of the bam.files table */	if ((c = mvc_bind_column(m, files, "file_id")) == NULL) {		throw(MAL, "next_file_id",			  "Could not retrieve the next file id: Error binding file_id column of 'files' table");	}	/* Loop through BATs for this column and find the maximum file_id */	for(i=0; i<3; ++i) {		b = store_funcs.bind_col(m->session->tr, c, i);		li = bat_iterator(b);		BATloop(b, p, q) {			lng t = *(lng *) BUNtail(li, p);			max_file_id = MAX(max_file_id, t);		}		BBPunfix(b->batCacheid);	}

/* * @- * The operator below is only working for a very limited * case. It also re-uses oids, which may become a semantic * problem quickly. */str DCdeleteUpperSlice(int *ret, int *bid, int *pos){	BAT *b;	int *readerT, *writerT;	BUN size, i;	(void) ret;	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "dc.deleteUpperSlice", "Cannot access input BAT");	/* check for a failure */	assert(b != NULL);	/* remove Hashes etc */	if (b->H->hash)		HASHremove(b);	if (b->T->hash)		HASHremove(BATmirror(b));	size = BATcount(b);	writerT = (int *) Tloc(b, BUNfirst(b));	readerT = (int *) Tloc(b, BUNfirst(b)) + *pos;	for (i = *pos; i < size; i++)		*writerT++ = *readerT++;	b->batInserted -= *pos;	BATsetcount(b, (BUN) (writerT - (int *) Tloc(b, BUNfirst(b))));	BBPunfix(*bid);	b->batDirty = TRUE;	return MAL_SUCCEED;}

strBKCpersists(void *r, const bat *bid, const bit *flg){	BAT *b;	(void) r;	if ((b = BATdescriptor(*bid)) == NULL) {		throw(MAL, "bat.setPersistence", RUNTIME_OBJECT_MISSING);	}	if (BATmode(b, (*flg == TRUE) ? PERSISTENT : TRANSIENT) != GDK_SUCCEED) {		BBPunfix(b->batCacheid);		throw(MAL, "bat.setPersistence", ILLEGAL_ARGUMENT);	}	BBPunfix(b->batCacheid);	return MAL_SUCCEED;}

static strgsl_bat_chisqprob_cst(bat * retval, bat chi2, dbl datapoints) {	BAT *b, *bn;	BATiter bi;	BUN p,q;	dbl r;	char *msg = NULL;	if (datapoints == dbl_nil) {		throw(MAL, "GSLbat_chisqprob_cst", "Parameter datapoints should not be nil");	}	if (datapoints < 0)		throw(MAL, "gsl.chi2prob", "Wrong value for datapoints");	if ((b = BATdescriptor(chi2)) == NULL) {		throw(MAL, "chisqprob", "Cannot access descriptor");	}	bi = bat_iterator(b);	bn = BATnew(TYPE_void, TYPE_dbl, BATcount(b), TRANSIENT);	if (bn == NULL){		BBPunfix(b->batCacheid);		throw(MAL, "gsl.chisqprob", MAL_MALLOC_FAIL);	}	BATseqbase(bn, b->hseqbase);	BATloop(b,p,q) {		dbl d = *(dbl*)BUNtail(bi,p);		if ((d == dbl_nil) || (d < 0))			throw(MAL, "gsl.chi2prob", "Wrong value for chi2");		r = gsl_cdf_chisq_Q(d, datapoints);		BUNappend(bn, &r, FALSE);	}

strCMDbbpCount(bat *ret){	BAT *b, *bn;	int i;	lng l;	b = BATnew(TYPE_void, TYPE_lng, getBBPsize(), TRANSIENT);	if (b == 0)		throw(MAL, "catalog.bbpCount", MAL_MALLOC_FAIL);	BATseqbase(b,0);	for (i = 1; i < getBBPsize(); i++)		if (i != b->batCacheid) {			if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {				bn = BATdescriptor(i);				if (bn) {					l = BATcount(bn);					BUNappend(b,  &l, FALSE);					BBPunfix(bn->batCacheid);				}			}		}	if (!(b->batDirty&2)) BATsetaccess(b, BAT_READ);	pseudo(ret,b,"bbp","count");	return MAL_SUCCEED;}

strBKCgetSize(lng *tot, const bat *bid){	BAT *b;	lng size = 0;	lng blksize = (lng) MT_pagesize();	if ((b = BATdescriptor(*bid)) == NULL) {		throw(MAL, "bat.getDiskSize", RUNTIME_OBJECT_MISSING);	}	size = sizeof (bat);	if ( !isVIEW(b)) {		BUN cnt = BATcapacity(b);		size += ROUND_UP(b->H->heap.free, blksize);		size += ROUND_UP(b->T->heap.free, blksize);		if (b->H->vheap)			size += ROUND_UP(b->H->vheap->free, blksize);		if (b->T->vheap)			size += ROUND_UP(b->T->vheap->free, blksize);		if (b->H->hash)			size += ROUND_UP(sizeof(BUN) * cnt, blksize);		if (b->T->hash)			size += ROUND_UP(sizeof(BUN) * cnt, blksize);		size += IMPSimprintsize(b);	} 	*tot = size;	BBPunfix(*bid);	return MAL_SUCCEED;}

strMDBgetStackFrameN(Client cntxt, MalBlkPtr m, MalStkPtr s, InstrPtr p){	int n;	bat *ret = getArgReference_bat(s, p, 0);	bat *ret2 = getArgReference_bat(s, p, 1);	BAT *b = BATnew(TYPE_void, TYPE_str, 256, TRANSIENT);	BAT *bn = BATnew(TYPE_void, TYPE_str, 256, TRANSIENT);		if (b == 0 || bn == 0) {		BBPreclaim(b);		BBPreclaim(bn);		throw(MAL, "mdb.getStackFrame", MAL_MALLOC_FAIL);	}	BATseqbase(b,0);	BATseqbase(bn,0);	n = *getArgReference_int(s, p, 2);	if (n < 0 || n >= getStkDepth(s)){		BBPunfix(b->batCacheid);		throw(MAL, "mdb.getStackFrame", ILLEGAL_ARGUMENT " Illegal depth.");	}	pseudo(ret,b,"view","stk","frame");	pseudo(ret2,bn,"view","stk","frameB");	return MDBgetFrame(b, bn, cntxt, m, s, n);}

strBKCgetAccess(str *res, const bat *bid){	BAT *b;	if ((b = BATdescriptor(*bid)) == NULL)		throw(MAL, "bat.getAccess", RUNTIME_OBJECT_MISSING);	switch (BATgetaccess(b)) {	case BAT_READ:		*res = GDKstrdup("read");		break;	case BAT_APPEND:		*res = GDKstrdup("append");		break;	case BAT_WRITE:		*res = GDKstrdup("write");		break;	default:		/* cannot happen, just here to help analysis tools */		*res = GDKstrdup(str_nil);		break;	}	BBPunfix(b->batCacheid);	return MAL_SUCCEED;}