algebra.mx

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

	if (c == NULL)
		return GDK_FAIL;
	for (s = t; *s; s++, yy++)
		*s = tolower(*s);

	if (b->hvarsized) {
		BATloopFast(b, u, v, xx)
			if (like(BUNtvar(b, u), t, yy))
			if (BUNfastins(c, BUNhvar(b, u), BUNtvar(b, u)) == NULL) {
				BBPreclaim(c);
				return GDK_FAIL;
			}
	} else {
		BATloopFast(b, u, v, xx)
			if (like(BUNtvar(b, u), t, yy))
			if (BUNfastins(c, BUNhloc(b, u), BUNtvar(b, u)) == NULL) {
				BBPreclaim(c);
				return GDK_FAIL;
			}
	}
	c->hsorted = BAThordered(b);
	c->tsorted = BATtordered(b);
	*ret = c;
	return GDK_SUCCEED;
}

@- BAT slice
@c
static int
slice(BAT **retval, BAT *b, lng start, lng end)
{
	/* the internal BATslice requires exclusive end */
	if (start < 0) {
		GDKerror("CMDslice: start position of slice should >= 0\n");
		return GDK_FAIL;
	}
#if SIZEOF_SIZE_T < SIZEOF_LNG
	if (start >= ((lng) 1 << (8 * SIZEOF_SIZE_T)) ||
	    end >= ((lng) 1 << (8 * SIZEOF_SIZE_T))) {
		GDKerror("CMDslice: argument out of range\n");
		return GDK_FAIL;
	}
#endif

	return (*retval = BATslice(b, (size_t) start, (size_t) end + 1)) ? GDK_SUCCEED : GDK_FAIL;
}

int
CMDslice(BAT **retval, BAT *b, lng *start, lng *end)
{
	return slice(retval, b, *start, *end);
}

int
CMDslice_int(BAT **retval, BAT *b, int *start, int *end)
{
	return slice(retval, b, *start, *end);
}

@- BUN Get/Fetch
@c
int
CMDposition(int *retval, BAT *b, ptr val)
{
	ptr p = (b->htype == TYPE_bat) ? (ptr) &((BAT *) val)->batCacheid : val;
	ptr v = BUNfnd(b, p);

	if (v == 0) {
		GDKerror("CMDposition: item not found\n");
		return GDK_FAIL;
	}
	*retval = BUNindex(b, v) - BUNindex(b, BUNfirst(b));
	return GDK_SUCCEED;
}

int
CMDpositionBUN(int *retval, BAT *b, ptr val, ptr tval)
{
	ptr p = (b->htype == TYPE_bat) ? (ptr) &((BAT *) val)->batCacheid : val;
	ptr o = (b->ttype == TYPE_bat) ? (ptr) &((BAT *) tval)->batCacheid : tval;
	ptr v = BUNlocate(b, p, o);

	if (v == 0) {
		GDKerror("CMDposition: item not found\n");
		return GDK_FAIL;
	}
	*retval = BUNindex(b, v) - BUNindex(b, BUNfirst(b));
	return GDK_SUCCEED;
}

int
CMDfetchbat(BAT **ret, BAT *b, BAT *s)
{
	return (*ret = BATfetch(b, s)) ? GDK_SUCCEED : GDK_FAIL;
}

int
doCMDfetch(ptr ret, BAT *b, lng i)
{
	if (i < 0 || i >= (lng) BATcount(b)) {
		GDKerror("CMDfetch: idx out of range\n");
		return GDK_FAIL;
	}
	i += BUNindex(b, BUNfirst(b));
	@:putTail(BUNptr(b,(size_t)i))@
@= putTail
	if (b->ttype && b->theap) {
		ptr _src = BUNtvar(b,@1);/*b->theap->base + *(var_t*) BUNtloc(b,@1);*/
		int _len = ATOMlen(b->ttype, _src);
		ptr _dst = GDKmalloc(_len);
		memcpy(_dst, _src, _len);
		*(ptr*) ret = _dst;
	} else {
		int _s = ATOMsize(ATOMtype(b->ttype));
		if (ATOMvarsized(b->ttype)) {
			memcpy(*(ptr*) ret=GDKmalloc(_s), BUNtvar(b, @1), _s);
		} else if (b->ttype == TYPE_bat) {
			bat bid = *(bat*) BUNtloc(b, @1);
			*(BAT**) ret = BATdescriptor(bid);
		} else if (_s == 4) {
			*(int*) ret = *(int*) BUNtail(b, @1);
		} else if (_s == 1) {
			*(chr*) ret = *(chr*) BUNtail(b, @1);
		} else if (_s == 2) {
			*(sht*) ret = *(sht*) BUNtail(b, @1);
		} else if (_s == 8) {
			*(lng*) ret = *(lng*) BUNtail(b, @1);
		} else {
			memcpy(ret, BUNtloc(b, @1), _s);
		}
	}
@c
	return GDK_SUCCEED;
}

int
CMDfetch(ptr ret, BAT *b, lng *pos)
{
	return doCMDfetch(ret, b, (size_t) * pos);
}

int
CMDfetchoid(ptr ret, BAT *b, oid *pos)
{
	if (b->hseqbase == oid_nil) {
		GDKerror("CMDfetchoid: void lookup on uninitialized column.\n");
		return GDK_FAIL;
	}
	return doCMDfetch(ret, b, (size_t) (*pos - b->hseqbase));
}

int
CMDexist(bit *ret, BAT *b, ptr val)
{
	ptr p = (b->htype == TYPE_bat) ? (ptr) &((BAT *) val)->batCacheid : val;
	BUN q = BUNfnd(b, p);

	*ret = q ? 1 : 0;
	return GDK_SUCCEED;
}
int
CMDtexist(bit *ret, BAT *b, ptr val)
{
	return CMDexist(ret, BATmirror(b), val);
}

int
CMDexistBUN(bit *ret, BAT *b, ptr val, ptr tval)
{
	ptr p = (b->htype == TYPE_bat) ? (ptr) &((BAT *) val)->batCacheid : val;
	ptr o = (b->ttype == TYPE_bat) ? (ptr) &((BAT *) tval)->batCacheid : tval;
	BUN q = BUNlocate(b, p, o);

	*ret = q ? 1 : 0;
	return GDK_SUCCEED;
}

int
CMDfind(ptr ret, BAT *b, ptr val)
{
	ptr p = (b->htype == TYPE_bat) ? (ptr) &((BAT *) val)->batCacheid : val;
	BUN q = BUNfnd(b, p);

	if (q == NULL) {
		GDKerror("CMDfind: value not found.\n");
		return GDK_FAIL;
	}
	@:putTail(q)@
	return GDK_SUCCEED;
}

int
CMDfind_oid(ptr ret, BAT *b, oid* val)
{
	return CMDfind(ret, b, (ptr) val); 
}

@= find_bounds
int
CMDr@1_summary(BAT **ret, BAT* b, int *quantiles)
{
	ssize_t cnt = BATcount(b), n = MIN(cnt,*quantiles);
	dbl threshold =0, delta = ((dbl) cnt) / (dbl) (MAX(1,n)-1);
	BAT *bn = *ret = BATnew(b->ttype, TYPE_oid, n);
	int (*cmp)(ptr,ptr) = BATatoms[b->ttype].atomCmp;

	if (bn == NULL)
		return GDK_FAIL;
	bn->hsorted = (1 @3 0 ? GDK_SORTED : FALSE);
	bn->tsorted = GDK_SORTED;

	if (cnt > 0) {
		ssize_t yy = 0, bunwidth = 0 @5 BUNsize(b);
		BUN p, bnds[2];
		ptr v;

		bnds[0 @3 1] = BUNfirst(b);
		bnds[1 @3 0] = BUNlast(b) - BUNsize(b);

		for (p=bnds[0], v=BUNtail(b, p); bnds[1] @3 p; p += bunwidth) {
			ptr cur = BUNtail(b,p);
			if (cmp(cur, v) @3 0)
				v = cur;
			if (++yy > threshold) {
				bunfastins(bn, v, BUNhead(b,p));
				threshold += delta;
			}
		}
		bunfastins(bn, v, BUNhead(b,p));
	}
	if ((BAThordered(bn)&1) == 0)
		bn = BATrevert(bn);
	if (bn) {
		bn->hsorted = GDK_SORTED;
		return GDK_SUCCEED;
	}
bunins_failed:
	BBPreclaim(bn);
	return GDK_FAIL;
}

int
CMDr@1_@2(oid* ret, BAT *b, ptr v)
{
	if ((BAThordered(b)&1) == 0) {
		GDKerror("CMDr@1_@2: %s should be sorted on head\n", BATgetId(b));
		return GDK_FAIL;
	} else if (BATcount(b) > 0) {
		BUN p = NULL;
		ssize_t idx;

		switch(ATOMstorage(b->htype)) {
		case TYPE_chr:
			p = SORTfnd@4_chr(BATmirror(b),v);
			break;
		case TYPE_sht:
			p = SORTfnd@4_sht(BATmirror(b),v);
			break;
		case TYPE_int:
			p = SORTfnd@4_int(BATmirror(b),v);
			break;
		case TYPE_lng:
			p = SORTfnd@4_lng(BATmirror(b),v);
			break;
		case TYPE_flt:
			p = SORTfnd@4_flt(BATmirror(b),v);
			break;
		case TYPE_dbl:
			p = SORTfnd@4_dbl(BATmirror(b),v);
			break;
		default:
			if (b->hvarsized ) {
				p = SORTfnd@4_var(BATmirror(b),v);
			} else {
				p = SORTfnd@4_loc(BATmirror(b),v);
			}
		}
		if (p == NULL) {
			p = BUNlast(b);
		} else if (1 @3 0) {
			p -= BUNsize(b);
		}
		if (p < BUNfirst(b)) {
			idx = *(ssize_t*) BUNtail(b,p) - 1;
		} else if (p >= BUNlast(b)) {
			idx = (*(ssize_t*) BUNtail(b,BUNlast(b)-BUNsize(b))) + 1;
		} else {
			idx = (*(ssize_t*) BUNtail(b,p)) @5 1;
		}
		*ret = (idx < 0)?0:idx;
	} else {
		*ret = oid_nil;
	}
	return GDK_SUCCEED;
}

int
CMDfind_@2(oid *ret, BAT *b, ptr v)
{
	ssize_t idx = (ssize_t) oid_nil;

	if ((BAThordered(b)&1) == 0) {
		GDKerror("CMDfind_@2: %s should be sorted on head\n", BATgetId(b));
		return GDK_FAIL;
	} else if (BATcount(b) > 0) {
		BUN p = NULL;

		switch(ATOMstorage(b->htype)) {
		case TYPE_chr:
			p = SORTfnd@4_chr(BATmirror(b),v);
			break;
		case TYPE_sht:
			p = SORTfnd@4_sht(BATmirror(b),v);
			break;
		case TYPE_int:
			p = SORTfnd@4_int(BATmirror(b),v);
			break;
		case TYPE_lng:
			p = SORTfnd@4_lng(BATmirror(b),v);
			break;
		case TYPE_flt:
			p = SORTfnd@4_flt(BATmirror(b),v);
			break;
		case TYPE_dbl:
			p = SORTfnd@4_dbl(BATmirror(b),v);
			break;
		default:
			if (b->hvarsized ) {
				p = SORTfnd@4_var(BATmirror(b),v);
			} else {
				p = SORTfnd@4_loc(BATmirror(b),v);
			}
		}
		if (p) {
			idx = *(ssize_t*) BUNtail(b,p);
			@6;
		}
	}
	*ret = (oid) idx;
	return GDK_SUCCEED;
}
@c
@:find_bounds(min,higher,<,last,-)@
@:find_bounds(max,lower,>,first,+,if (idx && (p >= BUNlast(b) || ATOMcmp(b->htype, v, BUNhead(b, p)))) idx--) @

int
CMDmerge(BAT **ret, BAT *b)
{
	int n = BATcount(b);
	BAT *bn = *ret = BATnew(TYPE_lng, TYPE_void, n);
	BUN p, q;
	int xx;
	lng *r = (lng *) BUNhead(bn, BUNfirst(bn));

	BATloopFast(b, p, q, xx) {
		oid hp = *(oid *) BUNhead(b, p);
		oid tp = *(oid *) BUNtail(b, p);

		*r++ = (((lng) hp) << 32) + tp;
	}
	bn->batBuns->free = (BUN) r - bn->batBuns->base;
	BATsetcount(bn, bn->batBuns->free/BUNsize(bn));
	if (!bn->batDirty)
		bn->batDirty = TRUE;

	bn->hsorted = ( BAThordered(b)&1 && (BATtordered(b)&1 || BAThkey(b))) 
		? GDK_SORTED : FALSE ;
	bn->tsorted = FALSE ;
	bn->tdense = FALSE ;
	BATkey(bn, BAThkey(b) || BATtkey(b)) ;
	BATkey(BATmirror(bn), FALSE) ;

	return GDK_SUCCEED;
}

int
CMDsplit(BAT **ret, BAT *b)
{
	int n = BATcount(b);
	BAT *bn = *ret = BATnew(TYPE_oid, TYPE_oid, n);
	int i;
	lng *r = (lng *) BUNhead(b, BUNfirst(b));

	for (i = 0; i < n; i++, r++) {
		oid hp = (int) (*r >> 32);
		oid tp = (int) *r;

		bunfastins(bn, &hp, &tp);
	}

	bn->hsorted = BAThordered(b)&1 ? GDK_SORTED : FALSE ;
	bn->tsorted = FALSE ;
	bn->hdense = FALSE ;
	bn->tdense = FALSE ;
	BATkey(bn, FALSE) ;
	BATkey(BATmirror(bn), FALSE) ;

	return GDK_SUCCEED;
bunins_failed:
	BBPreclaim(bn);
	return GDK_FAIL;
}

@- Wrapper
The remainder of this file contains the wrapper around the V4 code base
The BAT identifiers passed through this module may indicate
that the 'reverse' view applies. This should be taken into
account while resolving them.
@+ BAT sum and product aggregation 
The sum aggregate only works for int and float fields.
The routines below assumes that the caller knows what type
is large enough to prevent overflow.

@= ALGsum_implementation
algebra_export str ALGsum_@1_@2(@2* res, int *bid) ;
str ALGsum_@1_@2(@2* res, int *bid) {
	BAT *b;
	if( (b= BATdescriptor(*bid)) == NULL ){
		 throw(MAL, "algebra.sum", "Cannot access descriptor");
	}

	CMDsum_@1_@2(res,b);
	BBPreleaseref(b->batCacheid);
	return MAL_SUCCEED;
}

@= ALGprod_implementation
algebra_export str ALGprod_@1_@2(@2* res, int *bid) ;
str ALGprod_@1_@2(@2* res, int *bid) {
	BAT *b;
	if( (b= BATdescriptor(*bid)) == NULL ){
		 throw(MAL, "algebra.prod", "Cannot access descriptor");
	}
	CMDprod_@1_@2(res,b);
	BBPreleaseref(b->batCacheid);
	return MAL_SUCCEED;
}
@c

@:ALGsum_implementation(sht,sht,0)@
@:ALGsum_implementation(sht,int,0)@
@:ALGsum_implementation(sht,lng,0)@
@:ALGsum_implementation(int,int,0)@
@:ALGsum_implementation(int,lng,0)@
@:ALGsum_implementation(lng,lng,0)@
@:ALGsum_implementation(flt,flt,0.0)@
@:ALGsum_implementation(flt,dbl,0.0)@
@:ALGsum_implementation(dbl,dbl,0.0)@

@:ALGprod_implementation(sht,sht,1)@
@:ALGprod_implementation(sht,int,1)@
@:ALGprod_implementation(sht,lng,1)@
@:ALGprod_implementation(int,int,1)@
@:ALGprod_implementation(int,lng,1)@
@:ALGprod_implementation(lng,lng,1)@