batstr.c

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

batstr_export str STRcstConcatbat(int *ret, str *cst, int *r);
str STRcstConcatbat(int *ret, str *cst, int *r)
{   BAT *bn, *right;
	BUN p,q;
	int xx;
	str v, *vp= &v;

	prepareOperand(right,r,"+");
	prepareResult(bn,right,TYPE_str,"+");

	p = BUNfirst(right);
	q = BUNlast(right);
	xx = BUNsize(right);
	while(p<q) {
		ptr h = BUNhead(right,p);
		str tr = (str) BUNtail(right,p);
		STRConcat(vp, cst, &tr);
		bunfastins(bn, h, v);
		p += xx;
	}
	finalizeResult(ret,bn,right);
	return MAL_SUCCEED;

bunins_failed:
	BBPreleaseref(right->batCacheid);
	BBPunfix(*ret);
	throw(MAL, "batstr""+", "bunins failed");
}


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


#line 386 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/batstr.mx"
batstr_export str STRbatTail(int *ret, int *l, int *r);
str STRbatTail(int *ret, int *l, int *r)
{   BAT *bn, *left, *right;
	BUN o,p,q;
	int xx,yy;
	str v, *vp= &v;

	prepareOperand2(left,l,right,r,"tail");
	
#line 337 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/batstr.mx"
	if( BATcount(left) != BATcount(right) )
	throw(MAL, "batcalc.CMDcompareTail", "requires bats of identical size");


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

	prepareResult2(bn,left,right,TYPE_str,"tail");

	o = BUNfirst(left);
	p = BUNfirst(right);
	q = BUNlast(right);
	xx = BUNsize(left);
	yy = BUNsize(right);
	while(p<q) {
		ptr h = BUNhead(left,o);
		ptr tl = BUNtail(left,o);
		ptr tr = BUNtail(right,p);
		strTail(vp, tl, tr);
		bunfastins(bn, h, vp);
		o += xx;
		p += yy;
	}
	BBPreleaseref(right->batCacheid);
	finalizeResult(ret,bn,left);
	return MAL_SUCCEED;

bunins_failed:
	BBPreleaseref(left->batCacheid);
	BBPreleaseref(right->batCacheid);
	BBPunfix(*ret);
	throw(MAL, "batstr." "tail", "bunins failed");
}

batstr_export str STRbatTailcst(int *ret, int *l, int *cst);
str STRbatTailcst(int *ret, int *l, int *cst)
{   BAT *bn, *left;
	BUN p,q;
	int xx;
	str v, *vp= &v;

	prepareOperand(left,l,"tail");
	prepareResult(bn,left,TYPE_str,"tail");

	p = BUNfirst(left);
	q = BUNlast(left);
	xx = BUNsize(left);
	while(p<q) {
		ptr h = BUNhead(left,p);
		ptr tl = BUNtail(left,p);
		strTail(vp, tl, cst);
		bunfastins(bn, h, vp);
		p += xx;
	}
	finalizeResult(ret,bn,left);
	return MAL_SUCCEED;

bunins_failed:
	BBPreleaseref(left->batCacheid);
	BBPreleaseref(*ret);
	throw(MAL, "batstr""tail", "bunins failed");
}


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


#line 386 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/batstr.mx"
batstr_export str STRbatWChrAt(int *ret, int *l, int *r);
str STRbatWChrAt(int *ret, int *l, int *r)
{   BAT *bn, *left, *right;
	BUN o,p,q;
	int xx,yy;
	int v, *vp= &v;

	prepareOperand2(left,l,right,r,"chrAt");
	
#line 337 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/batstr.mx"
	if( BATcount(left) != BATcount(right) )
	throw(MAL, "batcalc.CMDcompareWChrAt", "requires bats of identical size");


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

	prepareResult2(bn,left,right,TYPE_int,"chrAt");

	o = BUNfirst(left);
	p = BUNfirst(right);
	q = BUNlast(right);
	xx = BUNsize(left);
	yy = BUNsize(right);
	while(p<q) {
		ptr h = BUNhead(left,o);
		ptr tl = BUNtail(left,o);
		ptr tr = BUNtail(right,p);
		strWChrAt(vp, tl, tr);
		bunfastins(bn, h, vp);
		o += xx;
		p += yy;
	}
	BBPreleaseref(right->batCacheid);
	finalizeResult(ret,bn,left);
	return MAL_SUCCEED;

bunins_failed:
	BBPreleaseref(left->batCacheid);
	BBPreleaseref(right->batCacheid);
	BBPunfix(*ret);
	throw(MAL, "batstr." "chrAt", "bunins failed");
}

batstr_export str STRbatWChrAtcst(int *ret, int *l, int *cst);
str STRbatWChrAtcst(int *ret, int *l, int *cst)
{   BAT *bn, *left;
	BUN p,q;
	int xx;
	int v, *vp= &v;

	prepareOperand(left,l,"chrAt");
	prepareResult(bn,left,TYPE_int,"chrAt");

	p = BUNfirst(left);
	q = BUNlast(left);
	xx = BUNsize(left);
	while(p<q) {
		ptr h = BUNhead(left,p);
		ptr tl = BUNtail(left,p);
		strWChrAt(vp, tl, cst);
		bunfastins(bn, h, vp);
		p += xx;
	}
	finalizeResult(ret,bn,left);
	return MAL_SUCCEED;

bunins_failed:
	BBPreleaseref(left->batCacheid);
	BBPreleaseref(*ret);
	throw(MAL, "batstr""chrAt", "bunins failed");
}


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


#line 386 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/batstr.mx"
batstr_export str STRbatChrAt(int *ret, int *l, int *r);
str STRbatChrAt(int *ret, int *l, int *r)
{   BAT *bn, *left, *right;
	BUN o,p,q;
	int xx,yy;
	chr v, *vp= &v;

	prepareOperand2(left,l,right,r,"chrAt");
	
#line 337 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/batstr.mx"
	if( BATcount(left) != BATcount(right) )
	throw(MAL, "batcalc.CMDcompareChrAt", "requires bats of identical size");


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

	prepareResult2(bn,left,right,TYPE_chr,"chrAt");

	o = BUNfirst(left);
	p = BUNfirst(right);
	q = BUNlast(right);
	xx = BUNsize(left);
	yy = BUNsize(right);
	while(p<q) {
		ptr h = BUNhead(left,o);
		ptr tl = BUNtail(left,o);
		ptr tr = BUNtail(right,p);
		strChrAt(vp, tl, tr);
		bunfastins(bn, h, vp);
		o += xx;
		p += yy;
	}
	BBPreleaseref(right->batCacheid);
	finalizeResult(ret,bn,left);
	return MAL_SUCCEED;

bunins_failed:
	BBPreleaseref(left->batCacheid);
	BBPreleaseref(right->batCacheid);
	BBPunfix(*ret);
	throw(MAL, "batstr." "chrAt", "bunins failed");
}

batstr_export str STRbatChrAtcst(int *ret, int *l, int *cst);
str STRbatChrAtcst(int *ret, int *l, int *cst)
{   BAT *bn, *left;
	BUN p,q;
	int xx;
	chr v, *vp= &v;

	prepareOperand(left,l,"chrAt");
	prepareResult(bn,left,TYPE_chr,"chrAt");

	p = BUNfirst(left);
	q = BUNlast(left);
	xx = BUNsize(left);
	while(p<q) {
		ptr h = BUNhead(left,p);
		ptr tl = BUNtail(left,p);
		strChrAt(vp, tl, cst);
		bunfastins(bn, h, vp);
		p += xx;
	}
	finalizeResult(ret,bn,left);
	return MAL_SUCCEED;

bunins_failed:
	BBPreleaseref(left->batCacheid);
	BBPreleaseref(*ret);
	throw(MAL, "batstr""chrAt", "bunins failed");
}


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


batstr_export str STRbatSubstitutecst(int *ret, int *l, str *arg2, str *arg3, bit *rep);
str
STRbatSubstitutecst(int *ret, int *l, str *arg2, str *arg3, bit *rep)
{
	BAT *bn, *b;
	BUN p, q;
	int xx;
	str x, *xp = &x;
	str y, *yp = &y;

	prepareOperand(b, l, "subString");
	prepareResult(bn, b, TYPE_int, "subString");

	BATloopFast(b, p, q, xx) {
		ptr h = BUNhead(b, p);

		x = (str) BUNtail(b, p);
		if (x == 0 || *x == 0 || strcmp(x, str_nil) == 0)
			y = (str)str_nil;
		else
			STRSubstitute(yp, xp, arg2, arg3, rep);
		bunfastins(bn, h, yp);
	}
	finalizeResult(ret, bn, b);
	return MAL_SUCCEED;
bunins_failed:
	BBPreleaseref(b->batCacheid);
	BBPreleaseref(bn->batCacheid);
	throw(MAL, "batstr.subString", "bunins failed");
}

batstr_export str STRbatmatchCst(int *ret, int *bid, str *pat);
str
STRbatmatchCst(int *ret, int *bid, str *pat)
{
#ifdef HAVE_REGEX_H
	regex_t prg;
	BAT *b, *bn;
	int tpe, xx;
	BUN p, q;
	bit bnil = bit_nil;
	ptr nilptr;
	int error = regcomp(&prg, *pat, REG_EXTENDED | REG_NOSUB);

	if (error < 0)
		throw(MAL, "str.match", "Compilation of regular expression failed");

	prepareOperand(b, bid, "match");
	bn = BATnew(BAThtype(b), TYPE_bit, BATcount(b));

	tpe = BATttype(b);
	nilptr = ATOMnilptr(tpe);
	BATloopFast(b, p, q, xx) {
		ptr h = BUNhead(b, p);
		ptr t = BUNtail(b, p);

		if (ATOMcmp(tpe, t, nilptr) == 0) {
			bunfastins(bn, h, &bnil);
		} else {
			bit match = regexec(&prg, t, 0, 0, 0) == 0;

			bunfastins(bn, h, &match);
		}
	}
bunins_failed:
	bn->hsorted = b->hsorted;
	bn->tsorted = 0;
	if (!(bn->batDirty&2)) bn = BATsetaccess(bn, BAT_READ); 
	*ret = bn->batCacheid;
	BBPkeepref(bn->batCacheid);
	BBPreleaseref(b->batCacheid);
	return MAL_SUCCEED;
#else
	(void) ret;
	(void) bid;
	(void) pat;
	throw(MAL, "str.match", "No implementation available");
#endif
}


#line 636 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/batstr.mx"
#define percent "\001"
#define underscore "\002"
batstr_export str STRbatlike(int *ret, int *bid, str *pat, str *esc);
str
STRbatlike(int *ret, int *bid, str *pat, str *esc){
	BAT *b,*bn;
	BUN p, q;
	int xx;
	oid o= oid_nil;
	if( (b= BATdescriptor(*bid)) == NULL)
		throw(MAL, "batstr.like","Can not find BAT");
	bn= BATnew(BAThtype(b),TYPE_void, BATcount(b)/10+5);
	BATseqbase(BATmirror(b),o);
	bn->hsorted = b->hsorted;
	bn->tsorted = b->tsorted;

	BATloopFast(b, p, q, xx) {
		ptr h = BUNhead(b, p);
		ptr t = BUNtail(b, p);

		if ( STRlike((str) t, *pat, *esc) )
			bunfastins(bn, h,&o);
	}
bunins_failed:
	if (!(bn->batDirty&2)) bn = BATsetaccess(bn, BAT_READ); 
	*ret = bn->batCacheid;
	BBPkeepref(bn->batCacheid);
	BBPreleaseref(b->batCacheid);
	return MAL_SUCCEED;
}
batstr_export str STRbatlike2(int *ret, int *bid, str *pat);
str
STRbatlike2(int *ret, int *bid, str *pat){
	str esc="";
	return STRbatlike(ret,bid,pat,&esc);
}


#line 675 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/batstr.mx"
batstr_export str STRbatsubstringcst(int *ret, int *bid, int *start, int *length);
str
STRbatsubstringcst(int *ret, int *bid, int *start, int *length){
	BAT *b,*bn;
	BUN p, q;
	int xx;
	str res;
	oid o=oid_nil;

	if( (b= BATdescriptor(*bid)) == NULL)
		throw(MAL, "batstr.like","Can not find BAT");
	bn= BATnew(BAThtype(b),TYPE_void, BATcount(b)/10+5);
	BATseqbase(BATmirror(b),o);
	bn->hsorted = b->hsorted;
	bn->tsorted = b->tsorted;

	BATloopFast(b, p, q, xx) {
		ptr h = BUNhead(b, p);
		str t =  (str) BUNtail(b, p);

		if ( STRsubstring(&res, &t, start, length) )
			bunfastins(bn, h, (ptr)&res);
	}
bunins_failed:
	if (!(bn->batDirty&2)) bn = BATsetaccess(bn, BAT_READ); 
	*ret = bn->batCacheid;
	BBPkeepref(bn->batCacheid);
	BBPreleaseref(b->batCacheid);
	return MAL_SUCCEED;
}
batstr_export str STRbatsubstring(int *ret, int *l, int *r, int *t);
str STRbatsubstring(int *ret, int *l, int *r, int *t)
{   BAT *bn, *left, *start, *length;
	BUN os,ol,ps,qs;
	int xx,yy,zz;
	str v, *vp= &v;

	if( (left= BATdescriptor(*l)) == NULL ) 
		throw(MAL, "batstr.substring" , "Cannot access descriptor"); 
	if( (start= BATdescriptor(*r)) == NULL ){
		BBPreleaseref(left->batCacheid); 
		throw(MAL, "batstr.substring", "Cannot access descriptor");
	}
	if( (length= BATdescriptor(*t)) == NULL ){
		BBPreleaseref(left->batCacheid); 
		BBPreleaseref(start->batCacheid); 
		throw(MAL, "batstr.substring", "Cannot access descriptor");
	}
	
#line 337 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/batstr.mx"
	if( BATcount(left) != BATcount(start) )
	throw(MAL, "batcalc.CMDbatsubstring", "requires bats of identical size");


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

	
#line 337 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/kernel/batstr.mx"
	if( BATcount(left) != BATcount(length) )
	throw(MAL, "batcalc.CMDbatsubstring", "requires bats of identical size");


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

	bn= BATnew(left->htype,TYPE_str,BATcount(left)); 
	if( left->htype== TYPE_void)
		BATseqbase(bn, left->hseqbase); 
	if( bn == NULL){
		BBPreleaseref(left->batCacheid);
		BBPreleaseref(start->batCacheid);
		BBPreleaseref(length->batCacheid);
		throw(MAL, "batstr.substring", "no space available ");
	}
	bn->hsorted= left->hsorted; 
	bn->tsorted=0; 

	ps = BUNfirst(left);
	qs = BUNlast(left);
	os = BUNfirst(start);
	ol = BUNfirst(length);
	xx = BUNsize(left);
	yy = BUNsize(start);
	zz = BUNsize(length);
	while(ps<qs) {
		ptr h = BUNhead(left,ol);
		str tl = (str) BUNtail(left,ps);
		int *t1 = (int *) BUNtail(start,os);
		int *t2 = (int *) BUNtail(length,ol);
		STRsubstring(vp, &tl, t1, t2);
		bunfastins(bn, h, vp);
		ps += xx;
		os += yy;
		ol += zz;
	}
	BBPreleaseref(start->batCacheid);
	BBPreleaseref(length->batCacheid);
	finalizeResult(ret,bn,left);
	return MAL_SUCCEED;

bunins_failed:
	BBPreleaseref(left->batCacheid);
	BBPreleaseref(start->batCacheid);
	BBPreleaseref(length->batCacheid);
	BBPunfix(*ret);
	throw(MAL, "batstr.substring" , "bunins failed");
}


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