batstr.mx

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

@= binarySTR
batstr_export str STRbat@1(int *ret, int *l, int *r);
str STRbat@1(int *ret, int *l, int *r)
{   BAT *bn, *left, *right;
	BUN o,p,q;
	int xx,yy;
	@2 v, *vp= &v;

	prepareOperand2(left,l,right,r,@5);
	@:chkSize(left,right,CMDcompare@1)@
	prepareResult2(bn,left,right,TYPE_@2,@5);

	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);
		@4(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." @5, "bunins failed");
}

batstr_export str STRbat@1cst(int *ret, int *l, @3 *cst);
str STRbat@1cst(int *ret, int *l, @3 *cst)
{   BAT *bn, *left;
	BUN p,q;
	int xx;
	@2 v, *vp= &v;

	prepareOperand(left,l,@5);
	prepareResult(bn,left,TYPE_@2,@5);

	p = BUNfirst(left);
	q = BUNlast(left);
	xx = BUNsize(left);
	while(p<q) {
		ptr h = BUNhead(left,p);
		ptr tl = BUNtail(left,p);
		@4(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"@5, "bunins failed");
}
@= binarySTRstr
batstr_export str STRbat@1(int *ret, int *l, int *r);
str STRbat@1(int *ret, int *l, int *r)
{   BAT *bn, *left, *right;
	BUN o,p,q;
	int xx,yy;
	@2 v, *vp= &v;

	prepareOperand2(left,l,right,r,@5);
	@:chkSize(left,right,CMDcompare@1)@
	prepareResult2(bn,left,right,TYPE_@2,@5);

	o = BUNfirst(left);
	p = BUNfirst(right);
	q = BUNlast(right);
	xx = BUNsize(left);
	yy = BUNsize(right);
	while(p<q) {
		ptr h = BUNhead(left,o);
		str tl = (str) BUNtail(left,o);
		str tr = (str) BUNtail(right,p);
		@4(vp, &tl, &tr);
		bunfastins(bn, h, @6);
		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." @5, "bunins failed");
}

batstr_export str STRbat@1cst(int *ret, int *l, @3 *cst);
str STRbat@1cst(int *ret, int *l, @3 *cst)
{   BAT *bn, *left;
	BUN p,q;
	int xx;
	@2 v, *vp= &v;

	prepareOperand(left,l,@5);
	prepareResult(bn,left,TYPE_@2,@5);

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

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

batstr_export str STRcst@1bat(int *ret, @3 *cst, int *r);
str STRcst@1bat(int *ret, @3 *cst, int *r)
{   BAT *bn, *right;
	BUN p,q;
	int xx;
	@2 v, *vp= &v;

	prepareOperand(right,r,@5);
	prepareResult(bn,right,TYPE_@2,@5);

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

bunins_failed:
	BBPreleaseref(right->batCacheid);
	BBPunfix(*ret);
	throw(MAL, "batstr"@5, "bunins failed");
}
@c
@:binarySTRstr(Prefix,bit,str,STRPrefix,"prefix",vp)@
@:binarySTRstr(Suffix,bit,str,STRSuffix,"suffix",vp)@
@:binarySTRstr(strSearch,int,str,STRstrSearch,"search",vp)@
@:binarySTRstr(RstrSearch,int,str,STRReverseStrSearch,"r_search",vp)@
@:binarySTRstr(Concat,str,str,STRConcat,"+",v)@
@:binarySTR(Tail,str,int,strTail,"tail")@
@:binarySTR(WChrAt,int,int,strWChrAt,"chrAt")@
@:binarySTR(ChrAt,chr,int,strChrAt,"chrAt")@

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
}
@-
The pattern matching routine is optimized for SQL pattern structures.
@c
#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);
}
@-
The substring functions require slightly different arguments
@c
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");
	}
	@:chkSize(left,start,CMDbatsubstring)@
	@:chkSize(left,length,CMDbatsubstring)@
	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");
}
@}