static void QOTstatisticsInit(void){
oid o=0;
int i,j;
if (qotStat[QOTnames]) return;
#ifdef NEED_MT_LOCK_INIT
MT_lock_init(&qotlock,"QOT statistics");
#endif
MT_lock_set(&qotlock, "QOT statistics");
qotStat[QOTnames]= QOT_create("opt","names",TYPE_str);
BATseqbase(qotStat[QOTnames],o);
qotStat[QOTcalls]= QOT_create("opt","calls",TYPE_int);
BATseqbase(qotStat[QOTcalls],o);
qotStat[QOTactions]= QOT_create("opt","actions",TYPE_int);
BATseqbase(qotStat[QOTactions],o);
qotStat[QOTtimings]= QOT_create("opt","timings",TYPE_lng);
BATseqbase(qotStat[QOTtimings],o);
/* recover from errors */
for ( i=0; i<4; i++)
if ( qotStat[i] == NULL){
for (j= 0; j < i; j++)
BBPclear(qotStat[j]->batCacheid);
MT_lock_unset(&qotlock, "QOT statistics");
return;
}
MT_lock_unset(&qotlock, "QOT statistics");
/* save them at least once */
QOTstatisticsExit();
}
str
MDBgetStackFrameN(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);
}
/*
* Enable incremental packing. The SQL front-end requires
* fixed oid sequences.
*/
str
MATpackIncrement(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;
}
static BAT *
MATsort_bte( BAT **map, BAT **bats, int len, BUN cnt, int rev )
{
BAT *res;
int i;
bte *resT, **batsT, *in;
bte *mapT;
BUN len1, len2;
bte *map_in = NULL;
res = BATnew(TYPE_void, bats[0]->ttype, cnt, TRANSIENT);
*map = BATnew(TYPE_void, TYPE_bte, cnt, TRANSIENT);
if (res == NULL || *map == NULL) {
BBPreclaim(res);
BBPreclaim(*map);
*map = NULL;
return NULL;
}
BATseqbase(res, 0);
BATseqbase(*map, 0);
resT = (bte*)Tloc(res, 0);
mapT = (bte*)Tloc(*map, 0);
batsT = (bte**)GDKmalloc(sizeof(bte*) * len);
for (i=0; i<len; i++)
batsT[i] = (bte*)Tloc(bats[i], 0);
/* merge */
in = batsT[0];
len1 = BATcount(bats[0]);
map_in = NULL;
/* TODO: change into a tree version */
for (i=1; i<len; i++) {
len2 = BATcount(bats[i]);
if (rev) {
MATsortloop_bte_rev( resT+cnt-len1-len2,
mapT+cnt-len1-len2,
in, map_in, len1,
batsT[i], i, len2);
} else {
MATsortloop_bte_( resT+cnt-len1-len2,
mapT+cnt-len1-len2,
in, map_in, len1,
batsT[i], i, len2);
}
in = resT+cnt-len1-len2;
map_in = mapT+cnt-len1-len2;
len1 += len2;
}
BATsetcount(res, len1);
BATsetcount(*map, len1);
res->hrevsorted = len1 <= 1;
(*map)->hrevsorted = len1 <= 1;
GDKfree(batsT);
return res;
}
/*
* 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 str
MATpackInternal(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;
}
str
CMDbbpKind(bat *ret)
{
BAT *b;
int i;
b = BATnew(TYPE_void, TYPE_str, getBBPsize(), TRANSIENT);
if (b == 0)
throw(MAL, "catalog.bbpKind", MAL_MALLOC_FAIL);
BATseqbase(b,0);
BBPlock("CMDbbpKind");
for (i = 1; i < getBBPsize(); i++)
if (i != b->batCacheid)
if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
char *mode = NULL;
if ((BBP_status(i) & BBPDELETED) || !(BBP_status(i) & BBPPERSISTENT))
mode = "transient";
else
mode = "persistent";
if (mode)
BUNappend(b, mode, FALSE);
}
BBPunlock("CMDbbpKind");
if (!(b->batDirty&2)) BATsetaccess(b, BAT_READ);
pseudo(ret,b,"bbp","kind");
return MAL_SUCCEED;
}
str
CMDbbpHeat(bat *ret)
{
BAT *b;
int i;
b = BATnew(TYPE_void, TYPE_int, getBBPsize(), TRANSIENT);
if (b == 0)
throw(MAL, "catalog.bbpHeat", MAL_MALLOC_FAIL);
BATseqbase(b,0);
BBPlock("CMDbbpHeat");
for (i = 1; i < getBBPsize(); i++)
if (i != b->batCacheid) {
if (BBP_cache(i) && !monet_modulesilent) {
int heat = BBP_lastused(i);
BUNins(b, &i, &heat, FALSE);
} else if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
int zero = 0;
BUNins(b, &i, &zero, FALSE);
}
}
BBPunlock("CMDbbpHeat");
if (!(b->batDirty&2)) BATsetaccess(b, BAT_READ);
pseudo(ret,b,"bbp","heat");
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.
*/
str
ITRnextChunk(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;
}
str
CMDbbpCount(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;
}
str
batstr_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);
}
str
JSONvalueTable(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;
}
static str
gsl_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);
}
log_bid
ebat_copy(log_bid b, oid ibase, int temp)
{
/* make a copy of b */
BAT *o = temp_descriptor(b);
BAT *c;
log_bid r;
if (!ebats[o->ttype])
ebats[o->ttype] = bat_new(TYPE_void, o->ttype, 0);
if (!temp && BATcount(o)) {
c = BATcopy(o, TYPE_void, o->ttype, TRUE);
BATseqbase(c, ibase );
c->H->dense = 1;
BATcommit(o);
BATcommit(c);
bat_set_access(c, BAT_READ);
r = temp_create(c);
bat_destroy(c);
} else {
c = ebats[o->ttype];
r = temp_create(c);
}
bat_destroy(o);
return r;
}
/*
* the @#VIEWcombine@ routine effortlessly produces a view with double
* vision on the head column.
*/
BAT *
VIEWcombine(BAT *b)
{
BAT *bn = VIEWhcreate(b), *bm;
if (bn == NULL)
return NULL;
bm = BATmirror(bn);
if (bm == NULL)
return NULL;
if (bn->htype != TYPE_void) {
assert(bn->T->vheap == NULL);
bn->T = bn->H;
bm->H = bn->H;
if (bn->T->heap.parentid)
BBPshare(bn->T->heap.parentid);
if (bn->T->vheap) {
assert(bn->T->vheap->parentid != abs(bn->batCacheid));
assert(bn->T->vheap->parentid > 0);
BBPshare(bn->T->vheap->parentid);
}
ALIGNsetH(bn, b);
} else {
BATseqbase(bm, bn->hseqbase);
}
return bn;
}
/*
* The BAT status is redundantly stored in CMDbat_info.
*/
str
CMDbbpLocation(bat *ret)
{
BAT *b;
int i;
char buf[MAXPATHLEN];
char cwd[MAXPATHLEN];
if (getcwd(cwd, MAXPATHLEN) == NULL)
throw(MAL, "catalog.bbpLocation", RUNTIME_DIR_ERROR);
b = BATnew(TYPE_void, TYPE_str, getBBPsize(), TRANSIENT);
if (b == 0)
throw(MAL, "catalog.bbpLocation", MAL_MALLOC_FAIL);
BATseqbase(b,0);
BBPlock("CMDbbpLocation");
for (i = 1; i < getBBPsize(); i++)
if (i != b->batCacheid) {
if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
snprintf(buf,MAXPATHLEN,"%s/bat/%s",cwd,BBP_physical(i));
BUNappend(b, buf, FALSE);
}
}
BBPunlock("CMDbbpLocation");
if (!(b->batDirty&2)) BATsetaccess(b, BAT_READ);
pseudo(ret,b,"bbp","location");
return MAL_SUCCEED;
}
str
CMDbbpNames(bat *ret)
{
BAT *b;
int i;
b = BATnew(TYPE_void, TYPE_str, getBBPsize(), TRANSIENT);
if (b == 0)
throw(MAL, "catalog.bbpNames", MAL_MALLOC_FAIL);
BATseqbase(b,0);
BBPlock("CMDbbpNames");
for (i = 1; i < getBBPsize(); i++)
if (i != b->batCacheid) {
if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i)) ) {
BUNappend(b, BBP_logical(i), FALSE);
if (BBP_logical(-i) && (BBP_refs(-i) || BBP_lrefs(-i)) && !BBPtmpcheck(BBP_logical(-i)))
BUNappend(b, BBP_logical(-i), FALSE);
}
}
BBPunlock("CMDbbpNames");
if (!(b->batDirty&2)) BATsetaccess(b, BAT_READ);
pseudo(ret,b,"bbp","name");
return MAL_SUCCEED;
}
static BAT *
MATproject_hge( BAT *map, BAT **bats, int len, int ttpe )
{
BAT *res;
int i;
BUN j, cnt = BATcount(map);
hge *resT, **batsT;
bte *mapT;
res = BATnew(TYPE_void, ttpe, cnt, TRANSIENT);
batsT = (hge**)GDKmalloc(sizeof(hge*) * len);
if (res == NULL || batsT == NULL) {
if (res)
BBPreclaim(res);
if (batsT)
GDKfree(batsT);
return NULL;
}
BATseqbase(res, map->hseqbase);
resT = (hge*)Tloc(res, 0);
mapT = (bte*)Tloc(map, 0);
for (i=0; i<len; i++)
batsT[i] = (hge*)Tloc(bats[i], 0);
for (j=0; j<cnt; j++)
resT[j] = *batsT[mapT[j]]++;
BATsetcount(res, j);
res->hrevsorted = j <= 1;
GDKfree(batsT);
return res;
}
str
MATpackValues(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;
}
static BAT *
MATproject_any( BAT *map, BAT **bats, int len )
{
BAT *res;
int i;
BUN j, cnt = BATcount(map);
BATiter *bats_i;
BUN *batsT;
bte *mapT;
res = BATnew(TYPE_void, bats[0]->ttype, cnt, TRANSIENT);
batsT = (BUN*)GDKmalloc(sizeof(BUN) * len);
bats_i = (BATiter*)GDKmalloc(sizeof(BATiter) * len);
if (res == NULL || batsT == NULL || bats_i == NULL) {
if (res)
BBPreclaim(res);
if (batsT)
GDKfree(batsT);
if (bats_i)
GDKfree(bats_i);
return NULL;
}
BATseqbase(res, map->hseqbase);
mapT = (bte*)Tloc(map, 0);
for (i=0; i<len; i++) {
batsT[i] = 0;
bats_i[i] = bat_iterator(bats[i]);
}
for (j=0; j<cnt; j++)
BUNappend(res, BUNtail(bats_i[mapT[j]], batsT[mapT[j]]++), FALSE);
GDKfree(batsT);
GDKfree(bats_i);
return res;
}
static BAT*
MATsortloop_( bte *map_res, BAT *i1, bte *map_i1, BUN cnt_i1, BAT *i2, bte map_i2, BUN cnt_i2)
{
int c;
BUN val_i1 = BUNfirst(i1);
BUN val_i2 = BUNfirst(i2);
BUN end_i1 = val_i1 + cnt_i1;
BUN end_i2 = val_i2 + cnt_i2;
BATiter bi_i1 = bat_iterator(i1);
BATiter bi_i2 = bat_iterator(i2);
int (*cmp) (const void *, const void *) = BATatoms[i1->ttype].atomCmp;
BAT *res = BATnew(TYPE_void, i1->ttype, cnt_i1 + cnt_i2, TRANSIENT);
if (res == NULL)
return NULL;
BATseqbase(res, 0);
if (map_i1 == NULL) {
/* map_i1 = 0 */
while ( val_i1 < end_i1 && val_i2 < end_i2) {
if ((c = cmp(BUNtail(bi_i1,val_i1),BUNtail(bi_i2,val_i2))) <= 0) {
BUNappend(res, BUNtail(bi_i1,val_i1), FALSE);
*map_res++ = 0;
val_i1++;
} else if (c > 0) {
BUNappend(res, BUNtail(bi_i2,val_i2), FALSE);
*map_res++ = map_i2;
val_i2++;
}
}
while ( val_i1 < end_i1 ) {
BUNappend(res, BUNtail(bi_i1,val_i1), FALSE);
*map_res++ = 0;
val_i1++;
}
} else {
while ( val_i1 < end_i1 && val_i2 < end_i2) {
if ((c = cmp(BUNtail(bi_i1,val_i1),BUNtail(bi_i2,val_i2))) <= 0) {
BUNappend(res, BUNtail(bi_i1,val_i1), FALSE);
*map_res++ = *map_i1++;
val_i1++;
} else if (c > 0) {
BUNappend(res, BUNtail(bi_i2,val_i2), FALSE);
*map_res++ = map_i2;
val_i2++;
}
}
while ( val_i1 < end_i1 ) {
BUNappend(res, BUNtail(bi_i1,val_i1), FALSE);
*map_res++ = *map_i1++;
val_i1++;
}
}
while ( val_i2 < end_i2 ) {
BUNappend(res, BUNtail(bi_i2,val_i2), FALSE);
*map_res++ = map_i2;
val_i2++;
}
return res;
}
/* actual implementation */
static char *
UDFBATreverse_(BAT **ret, BAT *src)
{
BATiter li;
BAT *bn = NULL;
BUN p = 0, q = 0;
/* assert calling sanity */
assert(ret != NULL);
/* handle NULL pointer */
if (src == NULL)
throw(MAL, "batudf.reverse", RUNTIME_OBJECT_MISSING);
/* check tail type */
if (src->ttype != TYPE_str) {
throw(MAL, "batudf.reverse",
"tail-type of input BAT must be TYPE_str");
}
/* allocate result BAT */
bn = BATnew(src->htype, TYPE_str, BATcount(src));
if (bn == NULL) {
throw(MAL, "batudf.reverse", MAL_MALLOC_FAIL);
}
BATseqbase(bn, src->hseqbase);
/* create BAT iterator */
li = bat_iterator(src);
/* the core of the algorithm, expensive due to malloc/frees */
BATloop(src, p, q) {
char *tr = NULL, *err = NULL;
/* get original head & tail value */
ptr h = BUNhead(li, p);
const char *t = (const char *) BUNtail(li, p);
/* revert tail value */
err = UDFreverse_(&tr, t);
if (err != MAL_SUCCEED) {
/* error -> bail out */
BBPreleaseref(bn->batCacheid);
return err;
}
/* assert logical sanity */
assert(tr != NULL);
/* insert original head and reversed tail in result BAT */
/* BUNins() takes care of all necessary administration */
BUNins(bn, h, tr, FALSE);
/* free memory allocated in UDFreverse_() */
GDKfree(tr);
}
str
MDBgetStackFrame(Client cntxt, MalBlkPtr m, MalStkPtr s, InstrPtr p)
{
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);
pseudo(ret,b,"view","stk","frame");
pseudo(ret2,bn,"view","stk","frame");
return MDBgetFrame(b,bn, cntxt, m, s, 0);
}
str
BKCdensebat(bat *ret, const wrd *size)
{
BAT *bn;
wrd sz = *size;
if (sz < 0)
sz = 0;
if (sz > (wrd) BUN_MAX)
sz = (wrd) BUN_MAX;
bn = BATnew(TYPE_void, TYPE_void, (BUN) sz, TRANSIENT);
if (bn == NULL)
throw(MAL, "bat.densebat", GDK_EXCEPTION);
BATsetcount(bn, (BUN) sz);
BATseqbase(bn, 0);
BATseqbase(BATmirror(bn), 0);
*ret = bn->batCacheid;
BBPkeepref(*ret);
return MAL_SUCCEED;
}
BAT *
bat_new(int ht, int tt, BUN size)
{
BAT *nb = BATnew(ht, tt, size);
if (ht == TYPE_void) {
BATseqbase(nb, 0);
nb->H->dense = 1;
}
return nb;
}
void
ALIGNsetH(BAT *b1, BAT *b2)
{
ssize_t diff;
if (b1 == NULL || b2 == NULL)
return;
diff = (ssize_t) (BUNfirst(b1) - BUNfirst(b2));
if (b2->halign == 0) {
b2->halign = OIDnew(1);
b2->batDirtydesc = TRUE;
}
if (BAThvoid(b2)) {
/* b2 is either dense or has a void(nil) head */
if (b1->htype != TYPE_void)
b1->hdense = TRUE;
else if (b2->hseqbase == oid_nil)
b1->H->nonil = FALSE;
BATseqbase(b1, b2->hseqbase);
} else if (b1->htype != TYPE_void) {
/* b2 is not dense, so set b1 not dense */
b1->hdense = FALSE;
BATseqbase(b1, oid_nil);
b1->H->nonil = b2->H->nonil;
} else if (BAThkey(b2))
BATseqbase(b1, 0);
BATkey(b1, BAThkey(b2));
b1->hsorted = BAThordered(b2);
b1->hrevsorted = BAThrevordered(b2);
b1->halign = b2->halign;
b1->batDirtydesc = TRUE;
b1->H->norevsorted = (BUN) (b2->H->norevsorted + diff);
b1->H->nokey[0] = (BUN) (b2->H->nokey[0] + diff);
b1->H->nokey[1] = (BUN) (b2->H->nokey[1] + diff);
b1->H->nosorted = (BUN) (b2->H->nosorted + diff);
b1->H->nodense = (BUN) (b2->H->nodense + diff);
}
str
BKCnewBAT(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;
}
log_bid
ebat2real(log_bid b, oid ibase)
{
/* make a copy of b */
BAT *o = temp_descriptor(b);
BAT *c = BATcopy(o, TYPE_void, ATOMtype(o->ttype), TRUE);
log_bid r;
BATseqbase(c, ibase );
c->H->dense = 1;
r = temp_create(c);
bat_destroy(c);
bat_destroy(o);
return r;
}
str
batnil_2_timestamp(bat *res, const bat *bid)
{
BAT *b, *dst;
BUN p, q;
if ((b = BATdescriptor(*bid)) == NULL) {
throw(SQL, "batcalc.nil_2_timestamp", "Cannot access descriptor");
}
dst = BATnew(TYPE_void, TYPE_timestamp, BATcount(b), TRANSIENT);
if (dst == NULL) {
BBPunfix(b->batCacheid);
throw(SQL, "sql.2_timestamp", MAL_MALLOC_FAIL);
}
BATseqbase(dst, b->hseqbase);
BATloop(b, p, q) {
timestamp r = *timestamp_nil;
BUNappend(dst, &r, FALSE);
}
static BAT *
MATsort_any( BAT **map, BAT **bats, int len, BUN cnt, int rev )
{
BAT *res = 0, *in;
int i;
bte *mapT;
BUN len1, len2;
bte *map_in = NULL;
*map = BATnew(TYPE_void, TYPE_bte, cnt, TRANSIENT);
if (*map == NULL)
return NULL;
BATseqbase(*map, 0);
mapT = (bte*)Tloc(*map, 0);
/* merge */
/* TODO: change into a tree version */
in = bats[0];
len1 = BATcount(in);
for (i=1; i<len; i++) {
len2 = BATcount(bats[i]);
if (rev) {
res = MATsortloop_rev(
mapT+cnt-len1-len2,
in, map_in, len1,
bats[i], i, len2);
} else {
res = MATsortloop_(
mapT+cnt-len1-len2,
in, map_in, len1,
bats[i], i, len2);
}
if (i != 1)
BBPunfix(in->batCacheid);
if (res == NULL)
return NULL;
in = res;
map_in = mapT+cnt-len1-len2;
len1 += len2;
}
BATsetcount(*map, len1);
(*map)->hrevsorted = len1 <= 1;
return res;
}
str
batnil_2_timestamp(bat *res, const bat *bid)
{
BAT *b, *dst;
BATiter bi;
BUN p, q;
if ((b = BATdescriptor(*bid)) == NULL) {
throw(SQL, "batcalc.nil_2_timestamp", "Cannot access descriptor");
}
bi = bat_iterator(b);
dst = BATnew(b->htype, TYPE_timestamp, BATcount(b), TRANSIENT);
if (dst == NULL) {
BBPunfix(b->batCacheid);
throw(SQL, "sql.2_timestamp", MAL_MALLOC_FAIL);
}
BATseqbase(dst, b->hseqbase);
BATloop(b, p, q) {
timestamp r = *timestamp_nil;
BUNins(dst, BUNhead(bi, p), &r, FALSE);
}
