static str
CMDbatUNARY1(MalStkPtr stk, InstrPtr pci, int abort_on_error,
BAT *(*batfunc)(BAT *, BAT *, int), const char *malfunc)
{
bat *bid;
BAT *bn, *b, *s = NULL;
bid = getArgReference_bat(stk, pci, 1);
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
if (pci->argc == 3) {
bat *sid = getArgReference_bat(stk, pci, 2);
if (*sid && (s = BATdescriptor(*sid)) == NULL) {
BBPunfix(b->batCacheid);
throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
}
}
bn = (*batfunc)(b, s, abort_on_error);
BBPunfix(b->batCacheid);
if (s)
BBPunfix(s->batCacheid);
if (bn == NULL) {
return mythrow(MAL, malfunc, OPERATION_FAILED);
}
bid = getArgReference_bat(stk, pci, 0);
BBPkeepref(*bid = bn->batCacheid);
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
BKCbat_inplace_force(bat *r, const bat *bid, const bat *rid, const bat *uid, const bit *force)
{
BAT *b, *p, *u;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "bat.inplace", RUNTIME_OBJECT_MISSING);
if ((p = BATdescriptor(*rid)) == NULL) {
BBPunfix(b->batCacheid);
throw(MAL, "bat.inplace", RUNTIME_OBJECT_MISSING);
}
if ((u = BATdescriptor(*uid)) == NULL) {
BBPunfix(b->batCacheid);
BBPunfix(p->batCacheid);
throw(MAL, "bat.inplace", RUNTIME_OBJECT_MISSING);
}
if (void_replace_bat(b, p, u, *force) == BUN_NONE) {
BBPunfix(b->batCacheid);
BBPunfix(p->batCacheid);
BBPunfix(u->batCacheid);
throw(MAL, "bat.inplace", GDK_EXCEPTION);
}
BBPkeepref(*r = b->batCacheid);
BBPunfix(p->batCacheid);
BBPunfix(u->batCacheid);
return MAL_SUCCEED;
}
static str
CMDconvertbat(MalStkPtr stk, InstrPtr pci, int tp, int abort_on_error)
{
bat *bid;
BAT *b, *bn, *s = NULL;
bid = getArgReference_bat(stk, pci, 1);
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "batcalc.convert", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
if (pci->argc == 3) {
bat *sid = getArgReference_bat(stk, pci, 2);
if (*sid && (s = BATdescriptor(*sid)) == NULL) {
BBPunfix(b->batCacheid);
throw(MAL, "batcalc.convert", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
}
}
bn = BATconvert(b, s, tp, abort_on_error);
BBPunfix(b->batCacheid);
if (s)
BBPunfix(s->batCacheid);
if (bn == NULL) {
char buf[20];
snprintf(buf, sizeof(buf), "batcalc.%s", ATOMname(tp));
return mythrow(MAL, buf, OPERATION_FAILED);
}
bid = getArgReference_bat(stk, pci, 0);
BBPkeepref(*bid = bn->batCacheid);
return MAL_SUCCEED;
}
str
AGGRsubmin_val(bat *retval, bat *bid, bat *gid, bat *eid, bit *skip_nils)
{
BAT *a, *b, *r;
str res;
bat ret;
if ((res = AGGRsubgrouped(&ret, NULL, bid, gid, eid, NULL, *skip_nils,
0, TYPE_oid, BATgroupmin, NULL, "aggr.submin")) != MAL_SUCCEED)
return res;
b = BATdescriptor(*bid);
if( b == NULL)
throw(MAL,"aggr.submax", INTERNAL_BAT_ACCESS);
a = BATdescriptor(ret);
if( a == NULL){
BBPreleaseref(b->batCacheid);
throw(MAL,"aggr.submax", INTERNAL_BAT_ACCESS);
}
r = BATproject(a, b);
BBPreleaseref(b->batCacheid);
BBPreleaseref(a->batCacheid);
BBPdecref(ret, TRUE);
BBPkeepref(*retval = r->batCacheid);
return MAL_SUCCEED;
}
char *
BKCappend_force_wrap(bat *r, const bat *bid, const bat *uid, const bit *force)
{
BAT *b, *u;
gdk_return ret;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "bat.append", RUNTIME_OBJECT_MISSING);
if ((u = BATdescriptor(*uid)) == NULL) {
BBPunfix(b->batCacheid);
throw(MAL, "bat.append", RUNTIME_OBJECT_MISSING);
}
if (BATcount(u) == 0) {
ret = GDK_SUCCEED;
} else {
if ((b = setaccess(b, BAT_WRITE)) == NULL)
throw(MAL, "bat.append", OPERATION_FAILED);
ret = BATappend(b, u, *force);
}
BBPunfix(u->batCacheid);
if (ret != GDK_SUCCEED) {
BBPunfix(b->batCacheid);
throw(MAL, "bat.append", GDK_EXCEPTION);
}
if( b->batPersistence == PERSISTENT)
BATmsync(b);
BBPkeepref(*r = b->batCacheid);
return MAL_SUCCEED;
}
str
BKCdelete_bat_bun(bat *r, const bat *bid, const bat *sid)
{
BAT *b, *s;
gdk_return ret;
if (*bid == *sid)
return BKCdelete_all(r, bid);
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "bat.delete", RUNTIME_OBJECT_MISSING);
if ((s = BATdescriptor(*sid)) == NULL) {
BBPunfix(b->batCacheid);
throw(MAL, "bat.delete", RUNTIME_OBJECT_MISSING);
}
ret = BATdel(b, s, FALSE);
BBPunfix(s->batCacheid);
if (ret != GDK_SUCCEED) {
BBPunfix(b->batCacheid);
throw(MAL, "bat.delete_bat_bun", GDK_EXCEPTION);
}
if( b->batPersistence == PERSISTENT)
BATmsync(b);
BBPkeepref(*r = b->batCacheid);
return MAL_SUCCEED;
}
str
AGGRsubmaxcand_val(bat *retval, bat *bid, bat *gid, bat *eid, bat *sid, bit *skip_nils)
{
BAT *a, *b, *r;
str res;
bat ret;
if ((res = AGGRsubgrouped(&ret, NULL, bid, gid, eid, sid, *skip_nils,
0, TYPE_oid, BATgroupmax, NULL, "aggr.submax")) != MAL_SUCCEED)
return res;
b = BATdescriptor(*bid);
if ( b == NULL)
throw(MAL,"aggr.max",RUNTIME_OBJECT_MISSING);
a = BATdescriptor(ret);
if ( a == NULL){
BBPreleaseref(b->batCacheid);
throw(MAL,"aggr.max",RUNTIME_OBJECT_MISSING);
}
r = BATproject(a, b);
BBPreleaseref(b->batCacheid);
BBPreleaseref(a->batCacheid);
BBPdecref(ret, TRUE);
BBPkeepref(*retval = r->batCacheid);
return MAL_SUCCEED;
}
str
CMDcalcavg(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
dbl avg;
BUN vals;
bat *bid;
BAT *b, *s = NULL;
gdk_return ret;
(void) cntxt;
(void) mb;
bid = getArgReference_bat(stk, pci, pci->retc + 0);
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "aggr.avg", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
if (pci->retc == pci->retc + 2) {
bat *sid = getArgReference_bat(stk, pci, pci->retc + 1);
if (*sid && (s = BATdescriptor(*sid)) == NULL) {
BBPunfix(b->batCacheid);
throw(MAL, "aggr.avg", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
}
}
ret = BATcalcavg(b, s, &avg, &vals);
BBPunfix(b->batCacheid);
if (s)
BBPunfix(s->batCacheid);
if (ret != GDK_SUCCEED)
return mythrow(MAL, "aggr.avg", OPERATION_FAILED);
* getArgReference_dbl(stk, pci, 0) = avg;
if (pci->retc == 2)
* getArgReference_lng(stk, pci, 1) = vals;
return MAL_SUCCEED;
}
str DCselectInsert(int *ret, int *res, int *bid, lng *low, lng *hgh)
{
BAT *b, *r;
lng *readerH, *writerH;
lng *readerT, *writerT;
BUN size, i;
(void) ret;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "dc.selectInsert", "Cannot access input BAT");
if ((r = BATdescriptor(*res)) == NULL)
throw(MAL, "dc.selectInsert", "Cannot access result BAT");
size = BATcount(b);
if (size > BATcapacity(r) - BATcount(r)) {
BUN ncap;
BUN grows;
BUN needed = size - (BATcapacity(r) - BATcount(r));
ncap = BATcapacity(r) + needed;
grows = BATgrows(r);
if (ncap > grows)
grows = ncap;
if (BATextend(r, grows) == NULL)
throw(MAL, "dc.selectInsert", "Failed to make room for the new values");
}
/*printf("in dc.selectInsert size is "OIDFMT,size);*/
writerH = (lng *) Hloc(r, BUNfirst(r));
writerT = (lng *) Tloc(r, BUNfirst(r));
readerH = (lng *) Hloc(b, BUNfirst(b));
readerT = (lng *) Tloc(b, BUNfirst(b));
for (i = 0; i < size; i++) {
if (*readerT >= *low && *readerT <= *hgh) {
*writerH = *readerH;
*writerT = *readerT;
writerH++;
writerT++;
}
readerH++;
readerT++;
}
BATsetcount(r, (BUN) (writerT - (lng *) Tloc(r, BUNfirst(r))));
BBPunfix(*bid);
BBPunfix(*res);
return MAL_SUCCEED;
}
/*
* 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;
}
/*
* @-
* The operator below is only working for a very limited cases.
*/
str DCreplaceTailBasedOnHead(int *ret, int *res, int *bid)
{
BAT *b, *r;
oid *readerH_b;
int *writerT_r, *readerT_b;
BUN size_b, size_r, i;
(void) ret;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "dc.replaceTailBasedOnHead", "Cannot access input BAT");
/* check for a failure */
assert(b != NULL);
if ((r = BATdescriptor(*res)) == NULL)
throw(MAL, "dc.replaceTailBasedOnHead", "Cannot access result BAT");
/* check for a failure */
assert(r != NULL);
/* remove Hashes etc */
if (r->H->hash)
HASHremove(r);
if (r->T->hash)
HASHremove(BATmirror(r));
size_r = BATcount(r);
size_b = BATcount(b);
if ((b->htype == TYPE_void) && (size_b == size_r)) {
writerT_r = (int *) Tloc(r, BUNfirst(r));
readerT_b = (int *) Tloc(b, BUNfirst(b));
for (i = 0; i < size_r; i++) {
*writerT_r = *readerT_b;
writerT_r++;
readerT_b++;
}
} else if ((b->htype != TYPE_void) && (size_b < size_r)) {
readerH_b = (oid *) Hloc(b, BUNfirst(b));
readerT_b = (int *) Tloc(b, BUNfirst(b));
for (i = 0; i < size_b; i++) {
writerT_r = (int *) Tloc(r, BUNfirst(r)) + *readerH_b;
*writerT_r = *readerT_b;
readerH_b++;
readerT_b++;
}
}
BBPunfix(*bid);
BBPunfix(*res);
r->batDirty = TRUE;
return MAL_SUCCEED;
}
str
AGGRquantile3(bat *retval, bat *bid, bat *gid, bat *eid, bat *quantile)
{
// this is inlined from AGGRgrouped3 to avoid changing all the other functions for now
BAT *b, *g, *e, *q;
b = BATdescriptor(*bid); /* [head,value] */
g = BATdescriptor(*gid); /* [head,gid] */
e = BATdescriptor(*eid); /* [gid,any] */
q = BATdescriptor(*quantile);
return AGGRgrouped(retval, NULL, b, g, e, TYPE_any, NULL, NULL, BATgroupquantile, q, 0, "aggr.quantile");
}
static str
AGGRgrouped3(bat *retval, bat *bid, bat *gid, bat *eid, int tp,
BAT *(*grpfunc)(BAT *, BAT *, BAT *, BAT *, int, int, int),
int skip_nils,
const char *malfunc)
{
BAT *b, *g, *e;
b = BATdescriptor(*bid); /* [head,value] */
g = BATdescriptor(*gid); /* [head,gid] */
e = BATdescriptor(*eid); /* [gid,any] */
return AGGRgrouped(retval, b, g, e, tp, grpfunc, skip_nils, malfunc);
}
str
BKCgetSize(lng *tot, const bat *bid){
BAT *b;
lng size = 0;
lng blksize = (lng) MT_pagesize();
if ((b = BATdescriptor(*bid)) == NULL) {
throw(MAL, "bat.getDiskSize", RUNTIME_OBJECT_MISSING);
}
size = sizeof (bat);
if ( !isVIEW(b)) {
BUN cnt = BATcapacity(b);
size += ROUND_UP(b->H->heap.free, blksize);
size += ROUND_UP(b->T->heap.free, blksize);
if (b->H->vheap)
size += ROUND_UP(b->H->vheap->free, blksize);
if (b->T->vheap)
size += ROUND_UP(b->T->vheap->free, blksize);
if (b->H->hash)
size += ROUND_UP(sizeof(BUN) * cnt, blksize);
if (b->T->hash)
size += ROUND_UP(sizeof(BUN) * cnt, blksize);
size += IMPSimprintsize(b);
}
*tot = size;
BBPunfix(*bid);
return MAL_SUCCEED;
}
/*
* @-
* The operator below is only working for a very limited
* case. It also re-uses oids, which may become a semantic
* problem quickly.
*/
str DCdeleteUpperSlice(int *ret, int *bid, int *pos)
{
BAT *b;
int *readerT, *writerT;
BUN size, i;
(void) ret;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "dc.deleteUpperSlice", "Cannot access input BAT");
/* check for a failure */
assert(b != NULL);
/* remove Hashes etc */
if (b->H->hash)
HASHremove(b);
if (b->T->hash)
HASHremove(BATmirror(b));
size = BATcount(b);
writerT = (int *) Tloc(b, BUNfirst(b));
readerT = (int *) Tloc(b, BUNfirst(b)) + *pos;
for (i = *pos; i < size; i++)
*writerT++ = *readerT++;
b->batInserted -= *pos;
BATsetcount(b, (BUN) (writerT - (int *) Tloc(b, BUNfirst(b))));
BBPunfix(*bid);
b->batDirty = TRUE;
return MAL_SUCCEED;
}
str
BKCmirror(bat *ret, const bat *bid)
{
BAT *b, *bn;
if ((b = BATdescriptor(*bid)) == NULL) {
throw(MAL, "bat.mirror", RUNTIME_OBJECT_MISSING);
}
bn = VIEWcombine(b);
if (bn != NULL) {
if (b->batRestricted == BAT_WRITE) {
BAT *bn1;
bn1 = BATcopy(bn, bn->htype, bn->ttype, FALSE, TRANSIENT);
BBPreclaim(bn);
bn = bn1;
}
if (bn != NULL) {
*ret = bn->batCacheid;
BBPkeepref(*ret);
BBPunfix(b->batCacheid);
return MAL_SUCCEED;
}
}
*ret = 0;
BBPunfix(b->batCacheid);
throw(MAL, "bat.mirror", GDK_EXCEPTION);
}
str
MRgetCloud(int *ret, str *mrcluster)
{
str msg;
BAT *cloud;
BUN p, q;
BATiter bi;
char nodes[BUFSIZ];
char *n = nodes;
int mapcount = 0;
snprintf(nodes, sizeof(nodes), "*/%s/node/*", *mrcluster);
if ((msg = RMTresolve(ret, &n)) != MAL_SUCCEED)
return msg;
MT_lock_set(&mal_contextLock, "mapreduce");
cloud = BATdescriptor(*ret); /* should succeed */
mapnodes = (mapnode*)GDKzalloc(sizeof(mapnode) * (BATcount(cloud) + 1));
if (mapnodes == NULL) {
BBPreleaseref(*ret);
throw(MAL, "mapreduce.getCloud", MAL_MALLOC_FAIL);
}
bi = bat_iterator(cloud);
BATloop(cloud, p, q) {
str t = (str)BUNtail(bi, p);
mapnodes[mapcount].uri = GDKstrdup(t);
mapnodes[mapcount].user = GDKstrdup("monetdb");
mapnodes[mapcount].pass = GDKstrdup("monetdb");
mapcount++;
}
str
db_password_wrap(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
(void) mb;
if (stk->stk[pci->argv[0]].vtype == TYPE_bat) {
BAT *b = BATdescriptor(*getArgReference_bat(stk, pci, 1));
if (b == NULL)
throw(SQL, "sql.password", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
BAT *bn = COLnew(b->hseqbase, TYPE_str, BATcount(b), TRANSIENT);
if (bn == NULL) {
BBPunfix(b->batCacheid);
throw(SQL, "sql.password", SQLSTATE(HY001) MAL_MALLOC_FAIL);
}
BATiter bi = bat_iterator(b);
BUN p, q;
BATloop(b, p, q) {
char *hash, *msg;
msg = AUTHgetPasswordHash(&hash, cntxt, BUNtvar(bi, p));
if (msg != MAL_SUCCEED) {
BBPunfix(b->batCacheid);
BBPreclaim(bn);
return msg;
}
if (BUNappend(bn, hash, false) != GDK_SUCCEED) {
BBPunfix(b->batCacheid);
BBPreclaim(bn);
throw(SQL, "sql.password", SQLSTATE(HY001) MAL_MALLOC_FAIL);
}
GDKfree(hash);
}
str
BATXMLxml2str(bat *ret, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
BATiter bi;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "xml.str", INTERNAL_BAT_ACCESS);
prepareResult(bn, b, TYPE_str, "str", (void) 0);
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
if (strNil(t)) {
bunfastapp(bn, t);
bn->T->nonil = 0;
} else {
assert(*t == 'A' || *t == 'C' || *t == 'D');
bunfastapp(bn, t + 1);
}
}
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
throw(MAL, "xml.str", OPERATION_FAILED " during bulk coercion");
}
/*
* @-
* The BUN- and BAT-stream manipulate a long handle, i.e.
* the destination variable. It assumes it has been set to
* zero as part of runtime stack initialization. Subsequently,
* it fetches a bun and returns the increment to the control
* variable. If it returns zero the control variable has been reset
* to zero and end of stream has been reached.
*/
str
ITRbunIterator(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
BATiter bi;
BAT *b;
oid *head;
bat *bid;
ValPtr tail;
(void) cntxt;
(void) mb;
head = getArgReference_oid(stk, pci, 0);
tail = &stk->stk[pci->argv[1]];
bid = getArgReference_bat(stk, pci, 2);
if ((b = BATdescriptor(*bid)) == NULL) {
throw(MAL, "iterator.nextChunk", INTERNAL_BAT_ACCESS);
}
if (BATcount(b) == 0) {
*head = oid_nil;
BBPunfix(b->batCacheid);
return MAL_SUCCEED;
}
*head = BUNfirst(b);
bi = bat_iterator(b);
VALinit(tail, b->ttype, BUNtail(bi, *(BUN*) head));
BBPunfix(b->batCacheid);
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
BKCgetAccess(str *res, const bat *bid)
{
BAT *b;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "bat.getAccess", RUNTIME_OBJECT_MISSING);
switch (BATgetaccess(b)) {
case BAT_READ:
*res = GDKstrdup("read");
break;
case BAT_APPEND:
*res = GDKstrdup("append");
break;
case BAT_WRITE:
*res = GDKstrdup("write");
break;
default:
/* cannot happen, just here to help analysis tools */
*res = GDKstrdup(str_nil);
break;
}
BBPunfix(b->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
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
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
BKCsetAccess(bat *res, const bat *bid, const char * const *param)
{
BAT *b;
int m;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "bat.setAccess", RUNTIME_OBJECT_MISSING);
switch (*param[0]) {
case 'r':
m = BAT_READ;
break;
case 'a':
m = BAT_APPEND;
break;
case 'w':
m = BAT_WRITE;
break;
default:
*res = 0;
throw(MAL, "bat.setAccess", ILLEGAL_ARGUMENT " Got %c" " expected 'r','a', or 'w'", *param[0]);
}
if ((b = setaccess(b, m)) == NULL)
throw(MAL, "bat.setAccess", OPERATION_FAILED);
BBPkeepref(*res = b->batCacheid);
return MAL_SUCCEED;
}
str
ITRbunNext(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
BATiter bi;
BAT *b;
oid *head;
bat *bid;
ValPtr tail;
(void) cntxt;
(void) mb;
head = (oid *) getArgReference(stk, pci, 0);
tail = getArgReference(stk,pci,1);
bid = (bat *) getArgReference(stk, pci, 2);
if ((b = BATdescriptor(*bid)) == NULL) {
throw(MAL, "iterator.nextChunk", INTERNAL_BAT_ACCESS);
}
*head = (BUN)*head + 1;
if (*head >= BUNlast(b)) {
*head = oid_nil;
BBPunfix(b->batCacheid);
return MAL_SUCCEED;
}
bi = bat_iterator(b);
VALinit(tail, b->ttype, BUNtail(bi, *(BUN*) head));
BBPunfix(b->batCacheid);
return MAL_SUCCEED;
}
str
BATXMLdocument(bat *ret, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
BATiter bi;
size_t size = BUFSIZ;
str buf = GDKmalloc(size);
const char *err = OPERATION_FAILED;
if (buf == NULL)
throw(MAL,"xml.document",MAL_MALLOC_FAIL);
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.document", INTERNAL_BAT_ACCESS);
}
prepareResult(bn, b, TYPE_xml, "document", GDKfree(buf));
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
xmlDocPtr doc;
int len;
xmlChar *s;
if (strNil(t)) {
bunfastapp(bn, str_nil);
bn->T->nonil = 0;
continue;
}
len = (int) strlen(t);
doc = xmlParseMemory(t, len);
if (doc == NULL) {
err = OPERATION_FAILED XML_PARSE_ERROR;
goto bunins_failed;
}
xmlDocDumpMemory(doc, &s, &len);
xmlFreeDoc(doc);
if ((size_t) len + 2 >= size) {
GDKfree(buf);
size = (size_t) len + 128;
buf = GDKmalloc(size);
if (buf == NULL) {
err= MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
buf[0] = 'D';
strcpy(buf + 1, (char *) s);
bunfastapp(bn, buf);
}
GDKfree(buf);
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
GDKfree(buf);
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
throw(MAL, "xml.document", "%s", err);
}
/*
* Synced BATs
*/
str
BKCisSynced(bit *ret, const bat *bid1, const bat *bid2)
{
BAT *b1, *b2;
if ((b1 = BATdescriptor(*bid1)) == NULL) {
throw(MAL, "bat.isSynced", RUNTIME_OBJECT_MISSING);
}
if ((b2 = BATdescriptor(*bid2)) == NULL) {
BBPunfix(b1->batCacheid);
throw(MAL, "bat.isSynced", RUNTIME_OBJECT_MISSING);
}
*ret = ALIGNsynced(b1, b2) != 0;
BBPunfix(b1->batCacheid);
BBPunfix(b2->batCacheid);
return MAL_SUCCEED;
}
