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);
}
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;
}
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;
}
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;
}
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;
}
/*
* 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
MATpackValues(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
int i,*ret, type, first = 1;
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 (ATOMvarsized(type)) {
for(i = first; i < p->argc; i++)
BUNappend(bn, stk->stk[getArg(p,i)].val.sval, TRUE);
} else {
for(i = first; i < p->argc; i++)
BUNappend(bn, getArgReference(stk, p, i), TRUE);
}
BATsettrivprop(bn);
BATderiveProps(bn,FALSE);
ret= (int*) getArgReference(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;
}
str
DCsliceStrict(int *ret, bat *bid, lng *start, lng *end)
{
BAT *b, *bn = NULL;
if ((b = BATdescriptor(*bid)) == NULL) {
throw(MAL, "dcoperator.sliceStrict", "Cannot access descriptor");
}
assert(*start >= 0);
assert(*end >= 0);
assert(*start <= (lng) BUN_MAX);
assert(*end < (lng) BUN_MAX);
assert(*start <= *end);
if ((BUN) ((*end - *start) + 1) > BATcount(b)) {
bn = BATnew(b->htype, b->ttype, 0);
BATsetcount(bn, 0);
*ret = bn->batCacheid;
BBPkeepref(*ret);
return MAL_SUCCEED;
}
bn = BATslice(b, (BUN) *start, (BUN) *end + 1);
BBPreleaseref(b->batCacheid);
if (bn != NULL) {
if (!(bn->batDirty & 2))
bn = BATsetaccess(bn, BAT_READ);
*ret = bn->batCacheid;
BBPkeepref(*ret);
return MAL_SUCCEED;
}
throw(MAL, "dcoperator.sliceStrict", "GDKerror");
}
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);
}
str
MseedLoadSQL(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
int *ret = (int*) getArgReference(stk,pci,0);
str *targetfile = (str*) getArgReference(stk,pci,1);
str msg = MAL_SUCCEED;
BAT *btime, *bdata, *table;
(void) cntxt;
(void) mb;
/* XXX: BATs of BATs are no longer allowed and this code hasn't worked
* for quite some time anyway */
table = BATnew(TYPE_str,TYPE_bat,0);
if ( table == NULL)
throw(MAL, "mseed.load", MAL_MALLOC_FAIL);
msg = MseedLoadIntern(&btime, &bdata, *targetfile);
if ( msg == MAL_SUCCEED){
BUNins(table, (ptr)"time", (ptr)&btime->batCacheid, FALSE);
BUNins(table, (ptr)"data", (ptr)&bdata->batCacheid, FALSE);
BBPreleaseref(btime->batCacheid);
BBPreleaseref(bdata->batCacheid);
BBPkeepref(*ret= table->batCacheid);
}
return msg;
}
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_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
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);
}
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);
}
/*
* 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;
}
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;
}
/*
* 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;
}
/* create and populate a dimension bat */
static str
NCDFARRAYseries(bat *bid, bte start, bte step, int stop, int group, int series)
{
BAT *bn = NULL;
BUN cnt = 0;
cnt = (BUN) ceil(((stop * 1.0 - start) / step)) * group * series ;
if (stop <= (int) GDK_bte_max ) {
bte sta = (bte) start, ste = (bte) step, sto = (bte) stop;
bn = BATnew(TYPE_void, TYPE_bte, cnt, TRANSIENT);
array_series(sta, ste, sto, bte);
} else if (stop <= (int) GDK_sht_max) {
sht sta = (sht) start, ste = (sht) step, sto = (sht) stop;
bn = BATnew(TYPE_void, TYPE_sht, cnt, TRANSIENT);
array_series(sta, ste, sto, sht);
} else {
int sta = (int) start, ste = (int) step, sto = (int) stop;
bn = BATnew(TYPE_void, TYPE_int, cnt, TRANSIENT);
array_series(sta, ste, sto, int);
}
if ( bn == NULL)
throw(MAL, "array.series", MAL_MALLOC_FAIL);
BATsetcount(bn, cnt);
BATseqbase(bn,0);
bn->hdense = TRUE;
BATkey(bn, TRUE);
bn->hsorted = 1;
bn->hrevsorted = (cnt <= 1);
bn->tsorted = (cnt <= 1 || (series == 1 && step > 0));
bn->trevsorted = (cnt <= 1 || (series == 1 && step < 0));
bn->T->nonil = TRUE;
BBPkeepref(*bid= bn->batCacheid);
return MAL_SUCCEED;
}
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;
}
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
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;
}
static BAT *
QOT_create(str hnme, str tnme, int tt)
{
BAT *b;
char buf[128];
snprintf(buf, 128, "stat_%s_%s", hnme, tnme);
b = BATdescriptor(BBPindex(buf));
if (b)
return b;
b = BATnew(TYPE_void, tt, 256, PERSISTENT);
if (b == NULL)
return NULL;
BATkey(b, TRUE);
BBPrename(b->batCacheid, buf);
BATmode(b, PERSISTENT);
return b;
}
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);
}
str
CMDbbpLRefCount(bat *ret)
{
BAT *b;
int i;
b = BATnew(TYPE_void, TYPE_int, getBBPsize(), TRANSIENT);
if (b == 0)
throw(MAL, "catalog.bbpLRefCount", MAL_MALLOC_FAIL);
BATseqbase(b,0);
BBPlock("CMDbbpLRefCount");
for (i = 1; i < getBBPsize(); i++)
if (i != b->batCacheid && BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
int refs = BBP_lrefs(i);
BUNappend(b, &refs, FALSE);
}
BBPunlock("CMDbbpLRefCount");
if (!(b->batDirty&2)) BATsetaccess(b, BAT_READ);
pseudo(ret,b,"bbp","lrefcnt");
return MAL_SUCCEED;
}
