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;
}
/*
* 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
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;
}
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;
}
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;
}
/*
* @-
* 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
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");
}
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
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);
}
/* calculate the footprint for optimizer pipe line choices
* and identify empty columns upfront for just in time optimizers.
*/
static lng
SQLgetColumnSize(sql_trans *tr, sql_column *c, int access)
{
lng size = 0;
BAT *b;
switch(access){
case 0:
b= store_funcs.bind_col(tr, c, RDONLY);
if (b) {
size += getBatSpace(b);
BBPunfix(b->batCacheid);
}
break;
case 1:
b = store_funcs.bind_col(tr, c, RD_INS);
if (b) {
size+= getBatSpace(b);
BBPunfix(b->batCacheid);
}
break;
case 2:
b = store_funcs.bind_col(tr, c, RD_UPD_VAL);
if (b) {
size += getBatSpace(b);
BBPunfix(b->batCacheid);
}
b = store_funcs.bind_col(tr, c, RD_UPD_ID);
if (b) {
size+= getBatSpace(b);
BBPunfix(b->batCacheid);
}
}
return size;
}
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
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);
}
str
BATXMLcomment(bat *ret, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
size_t size = BUFSIZ;
str buf = GDKmalloc(size);
BATiter bi;
const char *err= OPERATION_FAILED;
if (buf == NULL)
throw(MAL, "xml.comment", MAL_MALLOC_FAIL);
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.comment", INTERNAL_BAT_ACCESS);
}
prepareResult(bn, b, TYPE_xml, "comment", GDKfree(buf));
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
size_t len;
if (strNil(t)) {
bunfastapp(bn, str_nil);
bn->T->nonil = 0;
continue;
}
if (strstr(t, "--") != NULL) {
err = XML_COMMENT_ERROR;
goto bunins_failed;
}
len = strlen(t);
if (len + 9 >= size) {
/* make sure there is enough space */
size = len + 128;
/* free/malloc so we don't copy */
GDKfree(buf);
buf = GDKmalloc(size);
if (buf == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
snprintf(buf, size, "C<!--%s-->", t);
bunfastapp(bn, buf);
}
GDKfree(buf);
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
if (buf != NULL)
GDKfree(buf);
throw(MAL, "xml.comment", "%s", err);
}
static AGGRtask*
GROUPcollect( Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci){
AGGRtask *a;
int i;
BAT *b, *bs, *bh = NULL;
BUN sample;
(void) mb;
(void) cntxt;
a= (AGGRtask *) GDKzalloc(sizeof(*a));
if ( a == NULL)
return NULL;
a->bid = (bat*) GDKzalloc(pci->argc * sizeof(bat));
a->cols = (BAT**) GDKzalloc(pci->argc * sizeof(BAT*));
a->unique = (BUN *) GDKzalloc(pci->argc * sizeof(BUN));
if ( a->cols == NULL || a->bid == NULL || a->unique == NULL){
if(a->cols) GDKfree(a->cols);
if(a->bid) GDKfree(a->bid);
if(a->unique) GDKfree(a->unique);
GDKfree(a);
return NULL;
}
for ( i= pci->retc; i< pci->argc; i++, a->last++) {
a->bid[a->last] = *getArgReference_bat(stk,pci,i);
b = a->cols[a->last]= BATdescriptor(a->bid[a->last]);
if ( a->cols[a->last] == NULL){
for(a->last--; a->last>=0; a->last--)
BBPunfix(a->cols[a->last]->batCacheid);
GDKfree(a->cols);
GDKfree(a->bid);
GDKfree(a->unique);
GDKfree(a);
return NULL;
}
sample = BATcount(b) < 1000 ? BATcount(b): 1000;
bs = BATsample( b, sample);
if (bs) {
bh = BATunique(b, bs);
if (bh) {
a->unique[a->last] = BATcount(bh);
BBPunfix(bh->batCacheid);
}
BBPunfix(bs->batCacheid);
}
if ( b->tsorted)
a->unique[a->last] = 1000; /* sorting helps grouping */
a->size = BATcount(b);
}
#ifdef _DEBUG_GROUPBY_
for(i=0; i<a->last; i++)
fprintf(stderr,"#group %d unique "BUNFMT "\n", i, a->unique[i]);
#endif
return a;
}
/*
* 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;
}
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;
}
/*
* @-
* 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;
}
/*
* The core of the activity is str2xml, where the actual strings
* are constructed.
* To avoid repetitive copying we make sure that the garbage
* collector does not remove the xml intermediates.
* This way, we know that as long as the xml-variables are not
* reused, the complete structure of the xml document(s) are available.
* We merely have to collect the pieces.
* [FOR LATER, FIRST GO FOR THE EASY IMPLEMENTATION]
* XML values are represented by strings already.
*/
str
BATXMLstr2xml(bat *ret, const bat *bid)
{
BAT *b, *bn;
BUN p, q;
size_t size = BUFSIZ;
str buf;
const char *err= OPERATION_FAILED;
BATiter bi;
buf = GDKmalloc(size);
if (buf == NULL)
throw(MAL,"xml.str2xml",MAL_MALLOC_FAIL);
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.xml", INTERNAL_BAT_ACCESS);
}
prepareResult(bn, b, TYPE_xml, "xml", GDKfree(buf));
bi = bat_iterator(b);
BATloop(b, p, q) {
const char *t = (const char *) BUNtail(bi, p);
size_t len;
if (strNil(t)) {
bunfastapp(bn, str_nil);
bn->T->nonil = 0;
continue;
}
len = strlen(t) * 6 + 1;
if (size < len) {
size = len + 128;
GDKfree(buf);
buf = GDKmalloc(size);
if (buf == NULL) {
err = MAL_MALLOC_FAIL;
goto bunins_failed;
}
}
buf[0] = 'C';
XMLquotestring(t, buf + 1, size - 1);
bunfastapp(bn, buf);
}
GDKfree(buf);
finalizeResult(ret, bn, b);
return MAL_SUCCEED;
bunins_failed:
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
if (buf != NULL)
GDKfree(buf);
throw(MAL, "xml.xml", "%s", err);
}
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 lng
SQLgetSpace(mvc *m, MalBlkPtr mb)
{
sql_trans *tr = m->session->tr;
lng space = 0, i;
for (i = 0; i < mb->stop; i++) {
InstrPtr p = mb->stmt[i];
char *f = getFunctionId(p);
if (getModuleId(p) == sqlRef && (f == bindRef || f == bindidxRef)) {
int upd = (p->argc == 7 || p->argc == 9), mode = 0;
char *sname = getVarConstant(mb, getArg(p, 2 + upd)).val.sval;
char *tname = getVarConstant(mb, getArg(p, 3 + upd)).val.sval;
char *cname = NULL;
sql_schema *s = mvc_bind_schema(m, sname);
if (!s || strcmp(s->base.name, dt_schema) == 0)
continue;
cname = getVarConstant(mb, getArg(p, 4 + upd)).val.sval;
mode = getVarConstant(mb, getArg(p, 5 + upd)).val.ival;
if (mode != 0 || !cname || !s)
continue;
if (f == bindidxRef) {
sql_idx *i = mvc_bind_idx(m, s, cname);
if (i && (!isRemote(i->t) && !isMergeTable(i->t))) {
BAT *b = store_funcs.bind_idx(tr, i, RDONLY);
if (b) {
space += getBatSpace(b);
BBPunfix(b->batCacheid);
}
}
} else if (f == bindRef) {
sql_table *t = mvc_bind_table(m, s, tname);
sql_column *c = mvc_bind_column(m, t, cname);
if (c && (!isRemote(c->t) && !isMergeTable(c->t))) {
BAT *b = store_funcs.bind_col(tr, c, RDONLY);
if (b) {
space += getBatSpace(b);
BBPunfix(b->batCacheid);
}
}
}
}
}
return space;
}
/**
* Function returns the highest file id that currently exists in the
* bam.files table and stores this number + 1 in the next_file_id
* variable. Function doesn't use a mutex to guarantee that the
* returned value is up to date at return time. If this is required,
* the calling function should activate a mutex.
*/
str
next_file_id(mvc * m, sql_table * files, lng * next_file_id)
{
sql_column *c;
BAT *b = NULL;
BATiter li;
BUN p = 0, q = 0;
lng max_file_id = 0;
sht i;
assert(m != NULL);
assert(files != NULL);
/* Try to bind the file_id column of the bam.files table */
if ((c = mvc_bind_column(m, files, "file_id")) == NULL) {
throw(MAL, "next_file_id",
"Could not retrieve the next file id: Error binding file_id column of 'files' table");
}
/* Loop through BATs for this column and find the maximum file_id */
for(i=0; i<3; ++i) {
b = store_funcs.bind_col(m->session->tr, c, i);
li = bat_iterator(b);
BATloop(b, p, q) {
lng t = *(lng *) BUNtail(li, p);
max_file_id = MAX(max_file_id, t);
}
BBPunfix(b->batCacheid);
}
/*
* @-
* 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
BKCpersists(void *r, const bat *bid, const bit *flg)
{
BAT *b;
(void) r;
if ((b = BATdescriptor(*bid)) == NULL) {
throw(MAL, "bat.setPersistence", RUNTIME_OBJECT_MISSING);
}
if (BATmode(b, (*flg == TRUE) ? PERSISTENT : TRANSIENT) != GDK_SUCCEED) {
BBPunfix(b->batCacheid);
throw(MAL, "bat.setPersistence", ILLEGAL_ARGUMENT);
}
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
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
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;
}
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);
}
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;
}
