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
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;
}
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;
}
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
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
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
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", SQLSTATE(HY005) "Cannot access column descriptor");
}
dst = COLnew(b->hseqbase, TYPE_timestamp, BATcount(b), TRANSIENT);
if (dst == NULL) {
BBPunfix(b->batCacheid);
throw(SQL, "sql.2_timestamp", SQLSTATE(HY001) MAL_MALLOC_FAIL);
}
BATloop(b, p, q) {
timestamp r = *timestamp_nil;
if (BUNappend(dst, &r, FALSE) != GDK_SUCCEED) {
BBPunfix(b->batCacheid);
BBPreclaim(dst);
throw(SQL, "sql.timestamp", SQLSTATE(HY001) MAL_MALLOC_FAIL);
}
}
/*
* Materialize a view into a normal BAT. If it is a slice, we really
* want to reduce storage of the new BAT.
*/
gdk_return
VIEWreset(BAT *b)
{
bat hp, tp, hvp, tvp;
Heap head, tail, hh, th;
BAT *n = NULL, *v = NULL;
if (b == NULL)
return GDK_FAIL;
hp = VIEWhparent(b);
tp = VIEWtparent(b);
hvp = VIEWvhparent(b);
tvp = VIEWvtparent(b);
if (hp || tp) {
BAT *m;
BATstore *bs;
BUN cnt;
str nme;
size_t nmelen;
/* alloc heaps */
memset(&head, 0, sizeof(Heap));
memset(&tail, 0, sizeof(Heap));
memset(&hh, 0, sizeof(Heap));
memset(&th, 0, sizeof(Heap));
n = BATdescriptor(abs(b->batCacheid)); /* normalized */
if (n == NULL)
goto bailout;
m = BATmirror(n); /* mirror of normalized */
bs = BBP_desc(n->batCacheid);
cnt = BATcount(n) + 1;
nme = BBP_physical(n->batCacheid);
nmelen = nme ? strlen(nme) : 0;
assert(n->batCacheid > 0);
assert(hp || !b->htype);
assert(tp || !b->ttype);
head.farmid = BBPselectfarm(n->batRole, n->htype, offheap);
tail.farmid = BBPselectfarm(n->batRole, n->ttype, offheap);
if (n->htype) {
head.filename = (str) GDKmalloc(nmelen + 12);
if (head.filename == NULL)
goto bailout;
snprintf(head.filename, nmelen + 12, "%s.head", nme);
if (n->htype && HEAPalloc(&head, cnt, Hsize(n)) != GDK_SUCCEED)
goto bailout;
}
if (n->ttype) {
tail.filename = (str) GDKmalloc(nmelen + 12);
if (tail.filename == NULL)
goto bailout;
snprintf(tail.filename, nmelen + 12, "%s.tail", nme);
if (n->ttype && HEAPalloc(&tail, cnt, Tsize(n)) != GDK_SUCCEED)
goto bailout;
}
if (n->H->vheap) {
hh.farmid = BBPselectfarm(n->batRole, n->htype, varheap);
hh.filename = (str) GDKmalloc(nmelen + 12);
if (hh.filename == NULL)
goto bailout;
snprintf(hh.filename, nmelen + 12, "%s.hheap", nme);
if (ATOMheap(n->htype, &hh, cnt) != GDK_SUCCEED)
goto bailout;
}
if (n->T->vheap) {
th.farmid = BBPselectfarm(n->batRole, n->ttype, varheap);
th.filename = (str) GDKmalloc(nmelen + 12);
if (th.filename == NULL)
goto bailout;
snprintf(th.filename, nmelen + 12, "%s.theap", nme);
if (ATOMheap(n->ttype, &th, cnt) != GDK_SUCCEED)
goto bailout;
}
v = VIEWcreate(n, n);
if (v == NULL)
goto bailout;
/* cut the link to your parents */
VIEWunlink(n);
if (hp) {
BBPunshare(hp);
BBPunfix(hp);
}
if (tp) {
BBPunshare(tp);
BBPunfix(tp);
}
if (hvp) {
BBPunshare(hvp);
BBPunfix(hvp);
}
if (tvp) {
BBPunshare(tvp);
BBPunfix(tvp);
}
/* make sure everything points there */
m->S = n->S = &bs->S;
m->T = n->H = &bs->H;
m->H = n->T = &bs->T;
n->H->type = v->H->type;
n->H->varsized = v->H->varsized;
n->H->shift = v->H->shift;
n->H->width = v->H->width;
n->H->seq = v->H->seq;
n->T->type = v->T->type;
n->T->varsized = v->T->varsized;
n->T->shift = v->T->shift;
n->T->width = v->T->width;
n->T->seq = v->T->seq;
n->H->heap.parentid = n->T->heap.parentid = 0;
n->batRestricted = BAT_WRITE;
/* reset BOUND2KEY */
n->H->key = BAThkey(v);
n->T->key = BATtkey(v);
/* copy the heaps */
n->H->heap = head;
n->T->heap = tail;
/* unshare from parents heap */
if (hh.base) {
assert(n->H->vheap == NULL);
n->H->vheap = (Heap *) GDKzalloc(sizeof(Heap));
if (n->H->vheap == NULL)
goto bailout;
*n->H->vheap = hh;
n->H->vheap->parentid = n->batCacheid;
}
if (th.base) {
assert(n->T->vheap == NULL);
n->T->vheap = (Heap *) GDKzalloc(sizeof(Heap));
if (n->T->vheap == NULL)
goto bailout;
*n->T->vheap = th;
n->T->vheap->parentid = n->batCacheid;
}
n->batSharecnt = 0;
n->batCopiedtodisk = 0;
n->batDirty = 1;
/* reset BOUND2KEY */
n->hkey = BAThkey(v);
n->tkey = BATtkey(v);
/* make the BAT empty and insert all again */
DELTAinit(n);
/* reset capacity */
n->batCapacity = cnt;
/* swap n and v in case the original input was reversed, because
* BATins demands (v)oid-headed input */
if (b->batCacheid < 0) {
n = m;
m = BATmirror(v);
} else {
m = v;
}
/* insert all of v in n, and quit */
BATins(n, m, FALSE);
BBPreclaim(v);
BBPunfix(n->batCacheid);
}
return GDK_SUCCEED;
bailout:
BBPreclaim(v);
if (n != NULL)
BBPunfix(n->batCacheid);
HEAPfree(&head, 0);
HEAPfree(&tail, 0);
HEAPfree(&hh, 0);
HEAPfree(&th, 0);
return GDK_FAIL;
}
str RAPIeval(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci, bit grouped) {
sql_func * sqlfun = NULL;
str exprStr = *getArgReference_str(stk, pci, pci->retc + 1);
SEXP x, env, retval;
SEXP varname = R_NilValue;
SEXP varvalue = R_NilValue;
ParseStatus status;
int i = 0;
char argbuf[64];
char *argnames = NULL;
size_t argnameslen;
size_t pos;
char* rcall = NULL;
size_t rcalllen;
int ret_cols = 0; /* int because pci->retc is int, too*/
str *args;
int evalErr;
char *msg = MAL_SUCCEED;
BAT *b;
node * argnode;
int seengrp = FALSE;
rapiClient = cntxt;
if (!RAPIEnabled()) {
throw(MAL, "rapi.eval",
"Embedded R has not been enabled. Start server with --set %s=true",
rapi_enableflag);
}
if (!rapiInitialized) {
throw(MAL, "rapi.eval",
"Embedded R initialization has failed");
}
if (!grouped) {
sql_subfunc *sqlmorefun = (*(sql_subfunc**) getArgReference(stk, pci, pci->retc));
if (sqlmorefun) sqlfun = (*(sql_subfunc**) getArgReference(stk, pci, pci->retc))->func;
} else {
sqlfun = *(sql_func**) getArgReference(stk, pci, pci->retc);
}
args = (str*) GDKzalloc(sizeof(str) * pci->argc);
if (args == NULL) {
throw(MAL, "rapi.eval", SQLSTATE(HY001) MAL_MALLOC_FAIL);
}
// get the lock even before initialization of the R interpreter, as this can take a second and must be done only once.
MT_lock_set(&rapiLock);
env = PROTECT(eval(lang1(install("new.env")), R_GlobalEnv));
assert(env != NULL);
// first argument after the return contains the pointer to the sql_func structure
// NEW macro temporarily renamed to MNEW to allow including sql_catalog.h
if (sqlfun != NULL && sqlfun->ops->cnt > 0) {
int carg = pci->retc + 2;
argnode = sqlfun->ops->h;
while (argnode) {
char* argname = ((sql_arg*) argnode->data)->name;
args[carg] = GDKstrdup(argname);
carg++;
argnode = argnode->next;
}
}
// the first unknown argument is the group, we don't really care for the rest.
argnameslen = 2;
for (i = pci->retc + 2; i < pci->argc; i++) {
if (args[i] == NULL) {
if (!seengrp && grouped) {
args[i] = GDKstrdup("aggr_group");
seengrp = TRUE;
} else {
snprintf(argbuf, sizeof(argbuf), "arg%i", i - pci->retc - 1);
args[i] = GDKstrdup(argbuf);
}
}
argnameslen += strlen(args[i]) + 2; /* extra for ", " */
}
// install the MAL variables into the R environment
// we can basically map values to int ("INTEGER") or double ("REAL")
for (i = pci->retc + 2; i < pci->argc; i++) {
int bat_type = getBatType(getArgType(mb,pci,i));
// check for BAT or scalar first, keep code left
if (!isaBatType(getArgType(mb,pci,i))) {
b = COLnew(0, getArgType(mb, pci, i), 0, TRANSIENT);
if (b == NULL) {
msg = createException(MAL, "rapi.eval", SQLSTATE(HY001) MAL_MALLOC_FAIL);
goto wrapup;
}
if ( getArgType(mb,pci,i) == TYPE_str) {
if (BUNappend(b, *getArgReference_str(stk, pci, i), false) != GDK_SUCCEED) {
BBPreclaim(b);
b = NULL;
msg = createException(MAL, "rapi.eval", SQLSTATE(HY001) MAL_MALLOC_FAIL);
goto wrapup;
}
} else {
if (BUNappend(b, getArgReference(stk, pci, i), false) != GDK_SUCCEED) {
BBPreclaim(b);
b = NULL;
msg = createException(MAL, "rapi.eval", SQLSTATE(HY001) MAL_MALLOC_FAIL);
goto wrapup;
}
}
} else {
b = BATdescriptor(*getArgReference_bat(stk, pci, i));
if (b == NULL) {
msg = createException(MAL, "rapi.eval", SQLSTATE(HY001) MAL_MALLOC_FAIL);
goto wrapup;
}
}
// check the BAT count, if it is bigger than RAPI_MAX_TUPLES, fail
if (BATcount(b) > RAPI_MAX_TUPLES) {
msg = createException(MAL, "rapi.eval",
"Got "BUNFMT" rows, but can only handle "LLFMT". Sorry.",
BATcount(b), (lng) RAPI_MAX_TUPLES);
BBPunfix(b->batCacheid);
goto wrapup;
}
varname = PROTECT(Rf_install(args[i]));
varvalue = bat_to_sexp(b, bat_type);
if (varvalue == NULL) {
msg = createException(MAL, "rapi.eval", "unknown argument type ");
goto wrapup;
}
BBPunfix(b->batCacheid);
// install vector into R environment
Rf_defineVar(varname, varvalue, env);
UNPROTECT(2);
}
/* we are going to evaluate the user function within an anonymous function call:
* ret <- (function(arg1){return(arg1*2)})(42)
* the user code is put inside the {}, this keeps our environment clean (TM) and gives
* a clear path for return values, namely using the builtin return() function
* this is also compatible with PL/R
*/
pos = 0;
argnames = malloc(argnameslen);
if (argnames == NULL) {
msg = createException(MAL, "rapi.eval", SQLSTATE(HY001) MAL_MALLOC_FAIL);
goto wrapup;
}
argnames[0] = '\0';
for (i = pci->retc + 2; i < pci->argc; i++) {
pos += snprintf(argnames + pos, argnameslen - pos, "%s%s",
args[i], i < pci->argc - 1 ? ", " : "");
}
rcalllen = 2 * pos + strlen(exprStr) + 100;
rcall = malloc(rcalllen);
if (rcall == NULL) {
msg = createException(MAL, "rapi.eval", SQLSTATE(HY001) MAL_MALLOC_FAIL);
goto wrapup;
}
snprintf(rcall, rcalllen,
"ret <- as.data.frame((function(%s){%s})(%s), nm=NA, stringsAsFactors=F)\n",
argnames, exprStr, argnames);
free(argnames);
argnames = NULL;
#ifdef _RAPI_DEBUG_
printf("# R call %s\n",rcall);
#endif
x = R_ParseVector(mkString(rcall), 1, &status, R_NilValue);
if (LENGTH(x) != 1 || status != PARSE_OK) {
msg = createException(MAL, "rapi.eval",
"Error parsing R expression '%s'. ", exprStr);
goto wrapup;
}
retval = R_tryEval(VECTOR_ELT(x, 0), env, &evalErr);
if (evalErr != FALSE) {
char* errormsg = strdup(R_curErrorBuf());
size_t c;
if (errormsg == NULL) {
msg = createException(MAL, "rapi.eval", "Error running R expression.");
goto wrapup;
}
// remove newlines from error message so it fits into a MAPI error (lol)
for (c = 0; c < strlen(errormsg); c++) {
if (errormsg[c] == '\r' || errormsg[c] == '\n') {
errormsg[c] = ' ';
}
}
msg = createException(MAL, "rapi.eval",
"Error running R expression: %s", errormsg);
free(errormsg);
goto wrapup;
}
// ret should be a data frame with exactly as many columns as we need from retc
ret_cols = LENGTH(retval);
if (ret_cols != pci->retc) {
msg = createException(MAL, "rapi.eval",
"Expected result of %d columns, got %d", pci->retc, ret_cols);
goto wrapup;
}
// collect the return values
for (i = 0; i < pci->retc; i++) {
SEXP ret_col = VECTOR_ELT(retval, i);
int bat_type = getBatType(getArgType(mb,pci,i));
if (bat_type == TYPE_any || bat_type == TYPE_void) {
getArgType(mb,pci,i) = bat_type;
msg = createException(MAL, "rapi.eval",
"Unknown return value, possibly projecting with no parameters.");
goto wrapup;
}
// hand over the vector into a BAT
b = sexp_to_bat(ret_col, bat_type);
if (b == NULL) {
msg = createException(MAL, "rapi.eval",
"Failed to convert column %i", i);
goto wrapup;
}
// bat return
if (isaBatType(getArgType(mb,pci,i))) {
*getArgReference_bat(stk, pci, i) = b->batCacheid;
} else { // single value return, only for non-grouped aggregations
BATiter li = bat_iterator(b);
if (VALinit(&stk->stk[pci->argv[i]], bat_type,
BUNtail(li, 0)) == NULL) { // TODO BUNtail here
msg = createException(MAL, "rapi.eval", SQLSTATE(HY001) MAL_MALLOC_FAIL);
goto wrapup;
}
}
msg = MAL_SUCCEED;
}
/* unprotect environment, so it will be eaten by the GC. */
UNPROTECT(1);
wrapup:
MT_lock_unset(&rapiLock);
if (argnames)
free(argnames);
if (rcall)
free(rcall);
for (i = 0; i < pci->argc; i++)
GDKfree(args[i]);
GDKfree(args);
return msg;
}
static BUN
ALGjoinCost(Client cntxt, BAT *l, BAT *r, int flag)
{
BUN lc, rc;
BUN cost=0;
#if 0
BUN lsize,rsize;
BAT *lsample, *rsample, *j;
#endif
(void) flag;
(void) cntxt;
lc = BATcount(l);
rc = BATcount(r);
#if 0
/* The sampling method */
if(flag < 2 && ( lc > 100000 || rc > 100000)){
lsize= MIN(lc/100, (1<<SAMPLE_THRESHOLD_lOG)/3);
lsample= BATsample(l,lsize);
BBPreclaim(lsample);
rsize= MIN(rc/100, (1<<SAMPLE_THRESHOLD_lOG)/3);
rsample= BATsample(r,rsize);
BBPreclaim(rsample);
j= BATjoin(l,r, MAX(lsize,rsize));
lsize= BATcount(j);
BBPreclaim(j);
return lsize;
}
#endif
/* first use logical properties to estimate upper bound of result size */
if (l->tkey && r->hkey)
cost = MIN(lc,rc);
else
if (l->tkey)
cost = rc;
else
if (r->hkey)
cost = lc;
else
if (lc * rc >= BUN_MAX)
cost = BUN_MAX;
else
cost = lc * rc;
/* then use physical properties to rank costs */
if (BATtdense(l) && BAThdense(r))
/* densefetchjoin -> sequential access */
cost /= 7;
else
if (BATtordered(l) && BAThdense(r))
/* orderedfetchjoin > sequential access */
cost /= 6;
else
if (BATtdense(l) && BAThordered(r) && flag != 0 /* no leftjoin */)
/* (reversed-) orderedfetchjoin -> sequential access */
cost /= 6;
else
if (BAThdense(r) && rc <= SMALL_OPERAND)
/* fetchjoin with random access in L1 */
cost /= 5;
else
if (BATtdense(l) && lc <= SMALL_OPERAND && flag != 0 /* no leftjoin */)
/* (reversed-) fetchjoin with random access in L1 */
cost /= 5;
else
if (BATtordered(l) && BAThordered(r))
/* mergejoin > sequential access */
cost /= 4;
else
if (BAThordered(r) && rc <= SMALL_OPERAND)
/* binary-lookup-join with random access in L1 */
cost /= 3;
else
if (BATtordered(l) && lc <= SMALL_OPERAND && flag != 0 /* no leftjoin */)
/* (reversed-) binary-lookup-join with random access in L1 */
cost /= 3;
else
if ((BAThordered(r) && lc <= SMALL_OPERAND) || (BATtordered(l) && rc <= SMALL_OPERAND))
/* sortmergejoin with sorting in L1 */
cost /= 3;
else
if (rc <= SMALL_OPERAND)
/* hashjoin with hashtable in L1 */
cost /= 3;
else
if (lc <= SMALL_OPERAND && flag != 0 /* no leftjoin */)
/* (reversed-) hashjoin with hashtable in L1 */
cost /= 3;
else
if (BAThdense(r))
/* fetchjoin with random access beyond L1 */
cost /= 2;
else
if (BATtdense(l) && flag != 0 /* no leftjoin */)
/* (reversed-) fetchjoin with random access beyond L1 */
cost /= 2;
else
/* hashjoin with hashtable larger than L1 */
/* sortmergejoin with sorting beyond L1 */
cost /= 1;
ALGODEBUG
fprintf(stderr,"#batjoin cost ?"BUNFMT"\n",cost);
return cost;
}
str CMDbbp(bat *ID, bat *NS, bat *HT, bat *TT, bat *CNT, bat *REFCNT, bat *LREFCNT, bat *LOCATION, bat *HEAT, bat *DIRTY, bat *STATUS, bat *KIND)
{
BAT *id, *ns, *ht, *tt, *cnt, *refcnt, *lrefcnt, *location, *heat, *dirty, *status, *kind, *bn;
int i;
char buf[MAXPATHLEN];
id = BATnew(TYPE_void, TYPE_int, getBBPsize(), TRANSIENT);
ns = BATnew(TYPE_void, TYPE_str, getBBPsize(), TRANSIENT);
ht = BATnew(TYPE_void, TYPE_str, getBBPsize(), TRANSIENT);
tt = BATnew(TYPE_void, TYPE_str, getBBPsize(), TRANSIENT);
cnt = BATnew(TYPE_void, TYPE_lng, getBBPsize(), TRANSIENT);
refcnt = BATnew(TYPE_void, TYPE_int, getBBPsize(), TRANSIENT);
lrefcnt = BATnew(TYPE_void, TYPE_int, getBBPsize(), TRANSIENT);
location = BATnew(TYPE_void, TYPE_str, getBBPsize(), TRANSIENT);
heat = BATnew(TYPE_void, TYPE_int, getBBPsize(), TRANSIENT);
dirty = BATnew(TYPE_void, TYPE_str, getBBPsize(), TRANSIENT);
status = BATnew(TYPE_void, TYPE_str, getBBPsize(), TRANSIENT);
kind = BATnew(TYPE_void, TYPE_str, getBBPsize(), TRANSIENT);
if (!id || !ns || !ht || !tt || !cnt || !refcnt || !lrefcnt || !location || !heat || !dirty || !status || !kind) {
BBPreclaim(id);
BBPreclaim(ns);
BBPreclaim(ht);
BBPreclaim(tt);
BBPreclaim(cnt);
BBPreclaim(refcnt);
BBPreclaim(lrefcnt);
BBPreclaim(location);
BBPreclaim(heat);
BBPreclaim(dirty);
BBPreclaim(status);
BBPreclaim(kind);
throw(MAL, "catalog.bbp", MAL_MALLOC_FAIL);
}
BATseqbase(id, 0);
BATseqbase(ns, 0);
BATseqbase(ht, 0);
BATseqbase(tt, 0);
BATseqbase(cnt, 0);
BATseqbase(refcnt, 0);
BATseqbase(lrefcnt, 0);
BATseqbase(location, 0);
BATseqbase(heat, 0);
BATseqbase(dirty, 0);
BATseqbase(status, 0);
BATseqbase(kind, 0);
for (i = 1; i < getBBPsize(); i++) {
if (BBP_logical(i) && (BBP_refs(i) || BBP_lrefs(i))) {
bn = BATdescriptor(i);
if (bn) {
lng l = BATcount(bn);
int heat_ = BBP_lastused(i);
char *loc = BBP_cache(i) ? "load" : "disk";
char *mode = "persistent";
int refs = BBP_refs(i);
int lrefs = BBP_lrefs(i);
if ((BBP_status(i) & BBPDELETED) || !(BBP_status(i) & BBPPERSISTENT))
mode = "transient";
snprintf(buf, MAXPATHLEN, "%s", BBP_physical(i));
BUNappend(id, &i, FALSE);
BUNappend(ns, BBP_logical(i), FALSE);
BUNappend(ht, BATatoms[BAThtype(bn)].name, FALSE);
BUNappend(tt, BATatoms[BATttype(bn)].name, FALSE);
BUNappend(cnt, &l, FALSE);
BUNappend(refcnt, &refs, FALSE);
BUNappend(lrefcnt, &lrefs, FALSE);
BUNappend(location, buf, FALSE);
BUNappend(heat, &heat_, FALSE);
BUNappend(dirty, bn ? BATdirty(bn) ? "dirty" : DELTAdirty(bn) ? "diffs" : "clean" : (BBP_status(i) & BBPSWAPPED) ? "diffs" : "clean", FALSE);
BUNappend(status, loc, FALSE);
BUNappend(kind, mode, FALSE);
BBPunfix(bn->batCacheid);
}
}
}
BBPkeepref(*ID = id->batCacheid);
BBPkeepref(*NS = ns->batCacheid);
BBPkeepref(*HT = ht->batCacheid);
BBPkeepref(*TT = tt->batCacheid);
BBPkeepref(*CNT = cnt->batCacheid);
BBPkeepref(*REFCNT = refcnt->batCacheid);
BBPkeepref(*LREFCNT = lrefcnt->batCacheid);
BBPkeepref(*LOCATION = location->batCacheid);
BBPkeepref(*HEAT = heat->batCacheid);
BBPkeepref(*DIRTY = dirty->batCacheid);
BBPkeepref(*STATUS = status->batCacheid);
BBPkeepref(*KIND = kind->batCacheid);
return MAL_SUCCEED;
}
static gdk_return
CMDinfo(BAT **ret1, BAT **ret2, BAT *b)
{
BAT *bk, *bv;
const char *mode, *accessmode;
if (!(bk = BATnew(TYPE_void, TYPE_str, 128, TRANSIENT)))
return GDK_FAIL;
if (!(bv = BATnew(TYPE_void, TYPE_str, 128, TRANSIENT))) {
BBPreclaim(bk);
return GDK_FAIL;
}
BATseqbase(bk,0);
BATseqbase(bv,0);
*ret1 = bk;
*ret2 = bv;
if (b->batPersistence == PERSISTENT) {
mode = "persistent";
} else if (b->batPersistence == TRANSIENT) {
mode = "transient";
} else {
mode ="unknown";
}
switch (b->batRestricted) {
case BAT_READ:
accessmode = "read-only";
break;
case BAT_WRITE:
accessmode = "updatable";
break;
case BAT_APPEND:
accessmode = "append-only";
break;
default:
accessmode = "unknown";
}
BUNappend(bk, "batId", FALSE);
BUNappend(bv, BATgetId(b),FALSE);
BUNappend(bk, "batCacheid", FALSE);
BUNappend(bv, local_itoa((ssize_t)(b->batCacheid)),FALSE);
BUNappend(bk, "hparentid", FALSE);
BUNappend(bv, local_itoa((ssize_t)(b->H->heap.parentid)),FALSE);
BUNappend(bk, "tparentid", FALSE);
BUNappend(bv, local_itoa((ssize_t)(b->T->heap.parentid)),FALSE);
BUNappend(bk, "batSharecnt", FALSE);
BUNappend(bv, local_itoa((ssize_t)(b->batSharecnt)),FALSE);
BUNappend(bk, "batCount", FALSE);
BUNappend(bv, local_utoa((size_t)b->batCount),FALSE);
BUNappend(bk, "batCapacity", FALSE);
BUNappend(bv, local_utoa((size_t)b->batCapacity),FALSE);
BUNappend(bk, "head", FALSE);
BUNappend(bv, ATOMname(b->htype),FALSE);
BUNappend(bk, "tail", FALSE);
BUNappend(bv, ATOMname(b->ttype),FALSE);
BUNappend(bk, "batPersistence", FALSE);
BUNappend(bv, mode,FALSE);
BUNappend(bk, "batRestricted", FALSE);
BUNappend(bv, accessmode,FALSE);
BUNappend(bk, "batRefcnt", FALSE);
BUNappend(bv, local_itoa((ssize_t)(BBP_refs(b->batCacheid))),FALSE);
BUNappend(bk, "batLRefcnt", FALSE);
BUNappend(bv, local_itoa((ssize_t)(BBP_lrefs(b->batCacheid))),FALSE);
BUNappend(bk, "batDirty", FALSE);
BUNappend(bv, BATdirty(b) ? "dirty" : "clean",FALSE);
BUNappend(bk, "hsorted", FALSE);
BUNappend(bv, local_itoa((ssize_t)BAThordered(b)),FALSE);
BUNappend(bk, "hrevsorted", FALSE);
BUNappend(bv, local_itoa((ssize_t)BAThrevordered(b)),FALSE);
BUNappend(bk, "hident", FALSE);
BUNappend(bv, b->hident,FALSE);
BUNappend(bk, "hdense", FALSE);
BUNappend(bv, local_itoa((ssize_t)(BAThdense(b))),FALSE);
BUNappend(bk, "hseqbase", FALSE);
BUNappend(bv, oidtostr(b->hseqbase),FALSE);
BUNappend(bk, "hkey", FALSE);
BUNappend(bv, local_itoa((ssize_t)(b->hkey)),FALSE);
BUNappend(bk, "hvarsized", FALSE);
BUNappend(bv, local_itoa((ssize_t)(b->hvarsized)),FALSE);
BUNappend(bk, "halign", FALSE);
BUNappend(bv, local_utoa(b->halign),FALSE);
BUNappend(bk, "hnosorted", FALSE);
BUNappend(bv, local_utoa(b->H->nosorted),FALSE);
BUNappend(bk, "hnorevsorted", FALSE);
BUNappend(bv, local_utoa(b->H->norevsorted),FALSE);
BUNappend(bk, "hnodense", FALSE);
BUNappend(bv, local_utoa(b->H->nodense),FALSE);
BUNappend(bk, "hnokey[0]", FALSE);
BUNappend(bv, local_utoa(b->H->nokey[0]),FALSE);
BUNappend(bk, "hnokey[1]", FALSE);
BUNappend(bv, local_utoa(b->H->nokey[1]),FALSE);
BUNappend(bk, "hnonil", FALSE);
BUNappend(bv, local_utoa(b->H->nonil),FALSE);
BUNappend(bk, "hnil", FALSE);
BUNappend(bv, local_utoa(b->H->nil),FALSE);
BUNappend(bk, "tident", FALSE);
BUNappend(bv, b->tident,FALSE);
BUNappend(bk, "tdense", FALSE);
BUNappend(bv, local_itoa((ssize_t)(BATtdense(b))), FALSE);
BUNappend(bk, "tseqbase", FALSE);
BUNappend(bv, oidtostr(b->tseqbase), FALSE);
BUNappend(bk, "tsorted", FALSE);
BUNappend(bv, local_itoa((ssize_t)BATtordered(b)), FALSE);
BUNappend(bk, "trevsorted", FALSE);
BUNappend(bv, local_itoa((ssize_t)BATtrevordered(b)), FALSE);
BUNappend(bk, "tkey", FALSE);
BUNappend(bv, local_itoa((ssize_t)(b->tkey)), FALSE);
BUNappend(bk, "tvarsized", FALSE);
BUNappend(bv, local_itoa((ssize_t)(b->tvarsized)), FALSE);
BUNappend(bk, "talign", FALSE);
BUNappend(bv, local_utoa(b->talign), FALSE);
BUNappend(bk, "tnosorted", FALSE);
BUNappend(bv, local_utoa(b->T->nosorted), FALSE);
BUNappend(bk, "tnorevsorted", FALSE);
BUNappend(bv, local_utoa(b->T->norevsorted), FALSE);
BUNappend(bk, "tnodense", FALSE);
BUNappend(bv, local_utoa(b->T->nodense), FALSE);
BUNappend(bk, "tnokey[0]", FALSE);
BUNappend(bv, local_utoa(b->T->nokey[0]), FALSE);
BUNappend(bk, "tnokey[1]", FALSE);
BUNappend(bv, local_utoa(b->T->nokey[1]), FALSE);
BUNappend(bk, "tnonil", FALSE);
BUNappend(bv, local_utoa(b->T->nonil), FALSE);
BUNappend(bk, "tnil", FALSE);
BUNappend(bv, local_utoa(b->T->nil), FALSE);
BUNappend(bk, "batInserted", FALSE);
BUNappend(bv, local_utoa(b->batInserted), FALSE);
BUNappend(bk, "batDeleted", FALSE);
BUNappend(bv, local_utoa(b->batDeleted), FALSE);
BUNappend(bk, "batFirst", FALSE);
BUNappend(bv, local_utoa(b->batFirst), FALSE);
BUNappend(bk, "htop", FALSE);
BUNappend(bv, local_utoa(b->H->heap.free), FALSE);
BUNappend(bk, "ttop", FALSE);
BUNappend(bv, local_utoa(b->T->heap.free), FALSE);
BUNappend(bk, "batStamp", FALSE);
BUNappend(bv, local_itoa((ssize_t)(b->batStamp)), FALSE);
BUNappend(bk, "lastUsed", FALSE);
BUNappend(bv, local_itoa((ssize_t)(BBP_lastused(b->batCacheid))), FALSE);
BUNappend(bk, "curStamp", FALSE);
BUNappend(bv, local_itoa((ssize_t)(BBPcurstamp())), FALSE);
BUNappend(bk, "batCopiedtodisk", FALSE);
BUNappend(bv, local_itoa((ssize_t)(b->batCopiedtodisk)), FALSE);
BUNappend(bk, "batDirtydesc", FALSE);
BUNappend(bv, b->batDirtydesc ? "dirty" : "clean", FALSE);
BUNappend(bk, "H->heap.dirty", FALSE);
BUNappend(bv, b->H->heap.dirty ? "dirty" : "clean", FALSE);
BUNappend(bk, "T->heap.dirty", FALSE);
BUNappend(bv, b->T->heap.dirty ? "dirty" : "clean", FALSE);
infoHeap(bk, bv, &b->H->heap, "head.");
infoHeap(bk, bv, &b->T->heap, "tail.");
BUNappend(bk, "H->vheap->dirty", FALSE);
BUNappend(bv, (b->H->vheap && b->H->vheap->dirty) ? "dirty" : "clean", FALSE);
infoHeap(bk, bv, b->H->vheap, "hheap.");
BUNappend(bk, "T->vheap->dirty", FALSE);
BUNappend(bv, (b->T->vheap && b->T->vheap->dirty) ? "dirty" : "clean", FALSE);
infoHeap(bk, bv, b->T->vheap, "theap.");
/* dump index information */
if (b->H->hash) {
HASHinfo(bk, bv, b->H->hash, "hhash->");
}
if (b->T->hash) {
HASHinfo(bk, bv, b->T->hash, "thash->");
}
assert(BATcount(bk) == BATcount(bv));
return GDK_SUCCEED;
}
str
MDBStkTrace(Client cntxt, MalBlkPtr m, MalStkPtr s, InstrPtr p)
{
BAT *b, *bn;
str msg;
char *buf;
bat *ret = getArgReference_bat(s, p, 0);
bat *ret2 = getArgReference_bat(s, p, 1);
int k = 0;
size_t len,l;
b = BATnew(TYPE_void, TYPE_int, 256, TRANSIENT);
if ( b== NULL)
throw(MAL, "mdb.getStackTrace", MAL_MALLOC_FAIL);
bn = BATnew(TYPE_void, TYPE_str, 256, TRANSIENT);
if ( bn== NULL) {
BBPreclaim(b);
throw(MAL, "mdb.getStackTrace", MAL_MALLOC_FAIL);
}
BATseqbase(b,0);
BATseqbase(bn,0);
(void) cntxt;
msg = instruction2str(s->blk, s, p, LIST_MAL_DEBUG);
len = strlen(msg);
buf = (char*) GDKmalloc(len +1024);
if ( buf == NULL){
GDKfree(msg);
throw(MAL,"mdb.setTrace",MAL_MALLOC_FAIL);
}
snprintf(buf,len+1024,"%s at %s.%s[%d]", msg,
getModuleId(getInstrPtr(m,0)),
getFunctionId(getInstrPtr(m,0)), getPC(m, p));
BUNappend(b, &k, FALSE);
BUNappend(bn, buf, FALSE);
GDKfree(msg);
for (s = s->up, k++; s != NULL; s = s->up, k++) {
msg = instruction2str(s->blk, s, getInstrPtr(s->blk,s->pcup),LIST_MAL_DEBUG);
l = strlen(msg);
if (l>len){
GDKfree(buf);
len=l;
buf = (char*) GDKmalloc(len +1024);
if ( buf == NULL){
GDKfree(msg);
BBPunfix(b->batCacheid);
BBPunfix(bn->batCacheid);
throw(MAL,"mdb.setTrace",MAL_MALLOC_FAIL);
}
}
snprintf(buf,len+1024,"%s at %s.%s[%d]", msg,
getModuleId(getInstrPtr(s->blk,0)),
getFunctionId(getInstrPtr(s->blk,0)), s->pcup);
BUNappend(b, &k, FALSE);
BUNappend(bn, buf, FALSE);
GDKfree(msg);
}
GDKfree(buf);
if (!(b->batDirty&2)) BATsetaccess(b, BAT_READ);
if (!(bn->batDirty&2)) BATsetaccess(bn, BAT_READ);
pseudo(ret,b,"view","stk","trace");
pseudo(ret2,bn,"view","stk","traceB");
return MAL_SUCCEED;
}
