static void
CLKsignal(int nr)
{
/* int restype; */
int k = timerTop;
int t;
(void) nr;
if (signal(SIGALRM, CLKsignal) == SIG_ERR) {
GDKsyserror("CLKsignal: call failed\n");
}
if (timerTop == 0) {
return;
}
t = time(0);
while (k-- && t >= timer[k].alarm_time) {
if (timer[k].action) {
/* monet_eval(timer[k].action, &restype); */
GDKfree(timer[k].action);
} else {
MT_sema_up(&timer[k].sema, "CLKsignal");
}
timerTop--;
}
if (timerTop > 0) {
alarm(timer[timerTop - 1].alarm_time - time(0));
}
}
/*
* Determine the variables being used and clear non-used onces.
*/
void
MSresetVariables(Client cntxt, MalBlkPtr mb, MalStkPtr glb, int start)
{
int i;
bit *used = GDKzalloc(mb->vtop * sizeof(bit));
if( used == NULL){
GDKerror("MSresetVariables" MAL_MALLOC_FAIL);
return;
}
for (i = 0; i < start && start < mb->vtop; i++)
used[i] = 1;
if (mb->errors == 0)
for (i = start; i < mb->vtop; i++) {
if (used[i] || !isTmpVar(mb, i)) {
assert(!mb->var[i]->value.vtype || isVarConstant(mb, i));
used[i] = 1;
}
if (glb && !used[i]) {
if (isVarConstant(mb, i))
garbageElement(cntxt, &glb->stk[i]);
/* clean stack entry */
glb->stk[i].vtype = TYPE_int;
glb->stk[i].len = 0;
glb->stk[i].val.pval = 0;
}
}
if (mb->errors == 0)
trimMalVariables_(mb, used, glb);
GDKfree(used);
}
void
mal_client_reset(void)
{
MAL_MAXCLIENTS = 0;
if (mal_clients)
GDKfree(mal_clients);
}
/*
* Display routines
*/
str
MDBlifespan(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
Lifespan span;
str modnme;
str fcnnme;
Symbol s = NULL;
(void) cntxt;
if (stk != 0) {
modnme = *getArgReference_str(stk, p, 1);
fcnnme = *getArgReference_str(stk, p, 2);
} else {
modnme = getArgDefault(mb, p, 1);
fcnnme = getArgDefault(mb, p, 2);
}
s = findSymbol(cntxt->nspace, putName(modnme), putName(fcnnme));
if (s == NULL)
throw(MAL, "mdb.inspect", RUNTIME_SIGNATURE_MISSING);
span = setLifespan(s->def);
if( span == NULL)
throw(MAL,"mdb.inspect", MAL_MALLOC_FAIL);
debugLifespan(cntxt, s->def, span);
GDKfree(span);
(void) p;
(void) stk;
return MAL_SUCCEED;
}
/* Remote execution of MAL calls for more type/property information to be exchanged */
str
mal2str(MalBlkPtr mb, int first, int last)
{
str ps = NULL, *txt;
int i, *len, totlen = 0;
txt = GDKmalloc(sizeof(str) * mb->stop);
len = GDKmalloc(sizeof(int) * mb->stop);
if( txt == NULL || len == NULL){
GDKerror("mal2str: " MAL_MALLOC_FAIL);
if( txt ) GDKfree(txt);
if( len ) GDKfree(len);
return NULL;
}
for (i = first; i < last; i++) {
if( i == 0)
txt[i] = instruction2str(mb, 0, getInstrPtr(mb, i), LIST_MAL_NAME | LIST_MAL_TYPE | LIST_MAL_PROPS);
else
txt[i] = instruction2str(mb, 0, getInstrPtr(mb, i), LIST_MAL_CALL | LIST_MAL_PROPS | LIST_MAL_REMOTE);
#ifdef _DEBUG_LISTING_
mnstr_printf(GDKout,"%s\n",txt[i]);
#endif
if ( txt[i])
totlen += len[i] = (int)strlen(txt[i]);
}
ps = GDKmalloc(totlen + mb->stop + 1);
if( ps == NULL)
GDKerror("mal2str: " MAL_MALLOC_FAIL);
totlen = 0;
for (i = first; i < last; i++) {
if( txt[i]){
if( ps){
strncpy(ps + totlen, txt[i], len[i]);
ps[totlen + len[i]] = '\n';
ps[totlen + len[i] + 1] = 0;
totlen += len[i] + 1;
}
GDKfree(txt[i]);
}
}
GDKfree(len);
GDKfree(txt);
return ps;
}
/* Search for occurrence of the function in the library identified by the filename. */
MALfcn
getAddress(str fcnname)
{
void *dl;
MALfcn adr;
int idx=0;
static int prev= -1;
/* First try the last module loaded */
if( prev >= 0){
adr = (MALfcn) dlsym(filesLoaded[prev].handle, fcnname);
if( adr != NULL)
return adr; /* found it */
}
/*
* Search for occurrence of the function in any library already loaded.
* This deals with the case that files are linked together to reduce
* the loading time, while the signatures of the functions are still
* obtained from the source-file MAL script.
*/
for (idx =0; idx < lastfile; idx++)
if (idx != prev && /* skip already searched module */
filesLoaded[idx].handle &&
(idx == 0 || filesLoaded[idx].handle != filesLoaded[0].handle)) {
adr = (MALfcn) dlsym(filesLoaded[idx].handle, fcnname);
if (adr != NULL) {
prev = idx;
return adr; /* found it */
}
}
if (lastfile)
return NULL;
/*
* Try the program libraries at large or run through all
* loaded files and try to resolve the functionname again.
*
* the first argument must be the same as the base name of the
* library that is created in src/tools */
dl = mdlopen("libmonetdb5", RTLD_NOW | RTLD_GLOBAL);
if (dl == NULL)
return NULL;
adr = (MALfcn) dlsym(dl, fcnname);
filesLoaded[lastfile].modname = GDKstrdup("libmonetdb5");
if(filesLoaded[lastfile].modname == NULL) {
dlclose(dl);
return NULL;
}
filesLoaded[lastfile].fullname = GDKstrdup("libmonetdb5");
if(filesLoaded[lastfile].fullname == NULL) {
dlclose(dl);
GDKfree(filesLoaded[lastfile].modname);
return NULL;
}
filesLoaded[lastfile].handle = dl;
lastfile ++;
return adr;
}
void
MCpopClientInput(Client c)
{
ClientInput *x = c->bak;
if (c->fdin) {
/* missing protection against closing stdin stream */
(void) bstream_destroy(c->fdin);
}
GDKfree(c->prompt);
c->fdin = x->fdin;
c->yycur = x->yycur;
c->listing = x->listing;
c->prompt = x->prompt;
c->promptlength = strlen(c->prompt);
c->bak = x->next;
GDKfree(x);
}
static void
MRcleanCloud(void)
{
int i;
MT_lock_set(&mal_contextLock, "mapreduce");
for (i = 0; mapnodes[i].uri; i++) {
if (mapnodes[i].uri != NULL)
GDKfree(mapnodes[i].uri);
if (mapnodes[i].user != NULL)
GDKfree(mapnodes[i].user);
if (mapnodes[i].pass != NULL)
GDKfree(mapnodes[i].pass);
mapnodes[i].uri = mapnodes[i].user = mapnodes[i].pass = 0;
}
MT_lock_unset(&mal_contextLock, "mapreduce");
}
static str
JSONfilterInternal(json *ret, json *js, str *expr, str other)
{
pattern terms[MAXTERMS];
int tidx = 0;
JSON *jt;
str j = *js, msg = MAL_SUCCEED, s;
json result = 0;
size_t l;
(void) other;
if (strNil(j)) {
*ret = GDKstrdup(j);
return MAL_SUCCEED;
}
memset((char *) terms, 0, MAXTERMS * sizeof(pattern));
msg = JSONcompile(*expr, terms);
if (msg)
return msg;
jt = JSONparse(j, FALSE);
CHECK_JSON(jt);
result = s = JSONmatch(jt, 0, terms, tidx);
// process all other PATH expression
for (tidx++; tidx < MAXTERMS && terms[tidx].token; tidx++)
if (terms[tidx].token == END_STEP && tidx + 1 < MAXTERMS && terms[tidx + 1].token) {
s = JSONmatch(jt, 0, terms, ++tidx);
result = JSONglue(result, s, ',');
}
if (result) {
l = strlen(result);
if (result[l - 1] == ',')
result[l - 1] = 0;
} else
l = 3;
s = GDKzalloc(l + 3);
snprintf(s, l + 3, "[%s]", (result ? result : ""));
GDKfree(result);
for (l = 0; terms[l].token; l++)
if (terms[l].name)
GDKfree(terms[l].name);
JSONfree(jt);
*ret = s;
return msg;
}
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;
}
/* Clear V to an empty value (type void, value nil), freeing any
* memory allocated for external types. See VALempty for when V does
* not yet contain a value. */
void
VALclear(ValPtr v)
{
if (ATOMextern(v->vtype)) {
if (v->val.pval && v->val.pval != ATOMnilptr(v->vtype))
GDKfree(v->val.pval);
}
VALempty(v);
}
int
OPTgroupsImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
int i, actions=0;
InstrPtr q;
InstrPtr *old, *ref;
int limit,slimit;
(void) cntxt;
(void) stk;
if (varGetProp(mb, getArg(mb->stmt[0], 0), inlineProp) != NULL) {
return 0;
}
/* beware, new variables and instructions are introduced */
ref= (InstrPtr*) GDKzalloc(sizeof(InstrPtr) * mb->vtop); /* to find last assignment */
if ( ref == NULL) {
return 0;
}
old= mb->stmt;
limit= mb->stop;
slimit= mb->ssize;
if ( newMalBlkStmt(mb,mb->ssize) <0) {
GDKfree(ref);
return 0;
}
for (i = 0; i<limit; i++){
p= old[i];
if (getModuleId(p) == groupRef && p->argc == 4 && getFunctionId(p) == subgroupRef ){
setFunctionId(p, multicolumnsRef);
ref[getArg(p,0)] = p;
actions++;
OPTDEBUGgroups {
mnstr_printf(cntxt->fdout,"#new groups instruction\n");
printInstruction(cntxt->fdout,mb, 0, p, LIST_MAL_ALL);
}
}
if (getModuleId(p) == groupRef && p->argc == 5 && getFunctionId(p) == subgroupdoneRef && ref[getArg(p,4)] != NULL){
/*
* Try to expand its argument list with what we have found so far.
* This creates a series of derive paths, many of which will be removed during deadcode elimination.
*/
q= copyInstruction(ref[getArg(p,4)]);
q= pushArgument(mb, q, getArg(p,3));
getArg(q,0) = getArg(p,0);
getArg(q,1) = getArg(p,1);
getArg(q,2) = getArg(p,2);
ref[getArg(q,0)] = q;
freeInstruction(p);
p= q;
OPTDEBUGgroups{
mnstr_printf(cntxt->fdout,"#new groups instruction extension\n");
printInstruction(cntxt->fdout,mb, 0, p, LIST_MAL_ALL);
}
}
/*
* For analysis of memory leaks we should cleanup the libraries before
* we exit the server. This does not involve the libraries themselves,
* because they may still be in use.
*/
void
mal_linker_reset(void)
{
int i;
MT_lock_set(&mal_contextLock);
for (i = 0; i < lastfile; i++){
if (filesLoaded[i].fullname) {
/* dlclose(filesLoaded[i].handle);*/
GDKfree(filesLoaded[i].modname);
GDKfree(filesLoaded[i].fullname);
}
filesLoaded[i].modname = NULL;
filesLoaded[i].fullname = NULL;
}
lastfile = 0;
MT_lock_unset(&mal_contextLock);
}
/*
* When you add a value to the stack, you should ensure that
* there is space left. It should only be used for global
* stack frames, because the others are allocated in the
* runtime stack.
*/
void
freeStack(MalStkPtr stk)
{
if (!stk) {
return;
}
clearStack(stk);
GDKfree(stk);
}
void
VALclear(ValPtr v)
{
if (v->vtype == TYPE_str || ATOMextern(v->vtype)) {
if (v->val.pval && v->val.pval != str_nil)
GDKfree(v->val.pval);
}
VALempty(v);
}
/* 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
stringdiff_impl(int *res, str *s1, str *s2)
{
str r = MAL_SUCCEED;
char *S1 = NULL, *S2 = NULL;
r = soundex_impl(&S1, s1);
if( r != MAL_SUCCEED)
return r;
r = soundex_impl(&S2, s2);
if( r != MAL_SUCCEED){
GDKfree(S1);
return r;
}
r = levenshteinbasic_impl(res, &S1, &S2);
GDKfree(S1);
GDKfree(S2);
return r;
}
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 void
QEPfree(QEP qep)
{
int i;
if( qep == 0)
return;
for(i=0; i< qep->climit; i++)
if( qep->children[i])
QEPfree(qep->children[i]);
GDKfree(qep);
}
/*
* When a client needs to be terminated then the file descriptors for
* its input/output are simply closed. This leads to a graceful
* degradation, but may take some time when the client is busy. A more
* forcefull method is to kill the client thread, but this may leave
* locks and semaphores in an undesirable state.
*
* The routine freeClient ends a single client session, but through side
* effects of sharing IO descriptors, also its children. Conversely, a
* child can not close a parent.
*/
void
freeClient(Client c)
{
Thread t = c->mythread;
c->mode = FINISHING;
#ifdef MAL_CLIENT_DEBUG
printf("# Free client %d\n", c->idx);
#endif
MCexitClient(c);
/* scope list and curprg can not be removed, because the client may
* reside in a quit() command. Therefore the scopelist is re-used.
*/
c->scenario = NULL;
if (c->prompt)
GDKfree(c->prompt);
c->prompt = NULL;
c->promptlength = -1;
if (c->errbuf) {
GDKsetbuf(0);
if (c->father == NULL)
GDKfree(c->errbuf);
c->errbuf = 0;
}
c->father = 0;
c->login = c->lastcmd = 0;
c->qtimeout = 0;
c->stimeout = 0;
if (c->rcc) {
GDKfree(c->rcc);
c->rcc = NULL;
}
c->user = oid_nil;
c->mythread = 0;
c->mode = FREECLIENT;
GDKfree(c->glb);
c->glb = NULL;
if (t)
THRdel(t); /* you may perform suicide */
}
int
URLfromString(str src, int *len, str *u)
{
/* actually parse the message for valid url */
if (*u !=0)
GDKfree(*u);
*len = (int) strlen(src);
*u = GDKstrdup(src);
return *len;
}
void
addQueryToCache(Client c)
{
str msg = NULL;
insertSymbol(c->nspace, c->curprg);
msg = optimizeQuery(c);
if (msg != MAL_SUCCEED) {
showScriptException(c->fdout, c->curprg->def, 0, MAL, "%s", msg);
GDKfree(msg);
}
}
static reader_thread_data *
create_reader_thread_data(bam_wrapper * bws, int nr_files, sht nr_threads)
{
reader_thread_data *d =
(reader_thread_data *) GDKmalloc(nr_threads *
sizeof(reader_thread_data));
MT_Lock *reader_lock = (MT_Lock *) GDKmalloc(sizeof(MT_Lock));
int *cur_file = (int *) GDKmalloc(sizeof(int));
str reader_lock_ref = "bamReaderLock";
bit *failure = (bit *) GDKmalloc(sizeof(bit));
sht i;
assert(nr_threads > 0);
if (d == NULL || reader_lock == NULL || cur_file == NULL
|| failure == NULL) {
GDKfree(d);
GDKfree(reader_lock);
GDKfree(cur_file);
GDKfree(failure);
return NULL;
}
MT_lock_init(reader_lock, reader_lock_ref);
*cur_file = -1;
*failure = FALSE;
for (i = 0; i < nr_threads; ++i) {
d[i].thread_id = i;
d[i].bws = bws;
d[i].reader_lock = reader_lock;
d[i].reader_lock_ref = reader_lock_ref;
d[i].cur_file = cur_file;
d[i].nr_files = nr_files;
d[i].msg = MAL_SUCCEED;
d[i].failure = failure;
}
return d;
}
int
OPTjsonImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
int i, j, limit, slimit;
int bu = 0, br = 0, bj = 0;
str nme;
InstrPtr p,q;
int actions = 0;
InstrPtr *old;
(void) pci;
(void) cntxt;
(void) stk; /* to fool compilers */
old= mb->stmt;
limit= mb->stop;
slimit = mb->ssize;
if ( newMalBlkStmt(mb,mb->stop) < 0)
return 0;
for (i = 0; i < limit; i++) {
p = old[i];
if( getModuleId(p) == sqlRef && getFunctionId(p) == affectedRowsRef) {
q = newStmt(mb, jsonRef, resultSetRef);
q = pushArgument(mb, q, bu);
q = pushArgument(mb, q, br);
q = pushArgument(mb, q, bj);
j = getArg(q,0);
p= getInstrPtr(mb,0);
setVarType(mb,getArg(p,0),TYPE_str);
q = newReturnStmt(mb);
getArg(q,0)= getArg(p,0);
pushArgument(mb,q,j);
continue;
}
if( getModuleId(p) == sqlRef && getFunctionId(p) == rsColumnRef) {
nme = getVarConstant(mb,getArg(p,4)).val.sval;
if (strcmp(nme,"uuid")==0)
bu = getArg(p,7);
if (strcmp(nme,"lng")==0)
br = getArg(p,7);
if (strcmp(nme,"json")==0)
bj = getArg(p,7);
freeInstruction(p);
continue;
}
pushInstruction(mb,p);
}
for(; i<slimit; i++)
if (old[i])
freeInstruction(old[i]);
GDKfree(old);
return actions;
}
str
BATXMLgroup(xml *ret, const bat *bid)
{
BAT *b;
BUN p, q;
const char *t;
size_t len, size = BUFSIZ, offset;
str buf = GDKmalloc(size);
BATiter bi;
const char *err = NULL;
if (buf == NULL)
throw(MAL, "xml.aggr",MAL_MALLOC_FAIL);
if ((b = BATdescriptor(*bid)) == NULL) {
GDKfree(buf);
throw(MAL, "xml.aggr", RUNTIME_OBJECT_MISSING);
}
strcpy(buf, str_nil);
offset = 0;
bi = bat_iterator(b);
BATloop(b, p, q) {
int n;
t = (const char *) BUNtail(bi, p);
if (strNil(t))
continue;
len = strlen(t) + 1;
if (len >= size - offset) {
size += len + 128;
buf = GDKrealloc(buf, size);
if (buf == NULL) {
err= MAL_MALLOC_FAIL;
goto failed;
}
}
if (offset == 0)
n = snprintf(buf, size, "%s", t);
else if (buf[0] != *t) {
err = "incompatible values in group";
goto failed;
} else if (buf[0] == 'A')
n = snprintf(buf + offset, size - offset, " %s", t + 1);
else if (buf[0] == 'C')
n = snprintf(buf + offset, size - offset, "%s", t + 1);
else {
err = "can only group attributes and element content";
goto failed;
}
offset += n;
}
str
str_2_timestamp(timestamp *res, const str *val)
{
ptr p = NULL;
int len = 0;
int e;
char buf[BUFSIZ];
e = ATOMfromstr(TYPE_timestamp, &p, &len, *val);
if (e < 0 || !p || (ATOMcmp(TYPE_timestamp, p, ATOMnilptr(TYPE_timestamp)) == 0 && ATOMcmp(TYPE_str, *val, ATOMnilptr(TYPE_str)) != 0)) {
if (p)
GDKfree(p);
snprintf(buf, BUFSIZ, "conversion of string '%s' failed", *val? *val:"");
throw(SQL, "timestamp", "%s", buf);
}
*res = *(timestamp *) p;
if (!ATOMextern(TYPE_timestamp)) {
if (p)
GDKfree(p);
}
return MAL_SUCCEED;
}
str SABgetLocalConnectionHost(str *ret) {
str tmp, con, p;
rethrow("sabaoth.getLocalConnectionHost", tmp,
SABAOTHgetLocalConnection(&con));
/* this happens if no connection is available */
if (strcmp(con, (str)str_nil) == 0) {
*ret = con;
return(MAL_SUCCEED);
}
/* con looks like mapi:monetdb://hostname:port */
/* do some poor man's parsing */
tmp = con;
if ((p = strchr(con, ':')) == NULL) {
p = createException(MAL, "sabaoth.getLocalConnectionHost",
"invalid local connection string: %s", tmp);
GDKfree(tmp);
return(p);
}
if ((con = strchr(p + 1, ':')) == NULL) {
p = createException(MAL, "sabaoth.getLocalConnectionHost",
"invalid local connection string: %s", tmp);
GDKfree(tmp);
return(p);
}
if ((p = strchr(con + 3, ':')) == NULL) {
p = createException(MAL, "sabaoth.getLocalConnectionHost",
"invalid local connection string: %s", tmp);
GDKfree(tmp);
return(p);
}
*p = '\0';
*ret = GDKstrdup(con + 3);
GDKfree(tmp);
return(MAL_SUCCEED);
}
static void
JSONunfoldContainer(JSON *jt, int idx, BAT *bo, BAT *bk, BAT *bv, oid *o)
{
int i, last;
int cnt = 0;
char *r;
last = jt->elm[idx].tail;
if (jt->elm[idx].kind == JSON_OBJECT)
for (i = jt->elm[idx].next; i; i = jt->elm[i].next) {
r = JSONgetValue(jt, i);
BUNappend(bk, r, FALSE);
GDKfree(r);
r = JSONgetValue(jt, jt->elm[i].child);
BUNappend(bv, r, FALSE);
if (bo)
BUNappend(bo, o, FALSE);
(*o)++;
GDKfree(r);
if (i == last)
break;
} else if (jt->elm[idx].kind == JSON_ARRAY)
for (i = jt->elm[idx].next; i; i = jt->elm[i].next) {
r = GDKstrdup(str_nil);
BUNappend(bk, r, FALSE);
if (jt->elm[i].kind == JSON_VALUE)
r = JSONgetValue(jt, jt->elm[i].child);
else
r = JSONgetValue(jt, i);
BUNappend(bv, r, FALSE);
if (bo)
BUNappend(bo, o, FALSE);
(*o)++;
cnt++;
GDKfree(r);
if (i == last)
break;
}
}
/*
* At the end of the server session all remaining structured are
* explicitly released to simplify detection of memory leakage problems.
*/
void
MCcleanupClients(void)
{
Client c;
for (c = mal_clients; c < mal_clients + MAL_MAXCLIENTS; c++) {
if (c->prompt) {
GDKfree(c->prompt);
c->prompt = NULL;
}
c->user = oid_nil;
assert(c->bak == NULL);
MCexitClient(c);
}
}
static char *RAPIinstalladdons(void) {
int evalErr;
ParseStatus status;
char rlibs[FILENAME_MAX];
char rapiinclude[BUFSIZ];
SEXP librisexp;
int len;
// r library folder, create if not exists
len = snprintf(rlibs, sizeof(rlibs), "%s%c%s", GDKgetenv("gdk_dbpath"), DIR_SEP, "rapi_packages");
if (len == -1 || len >= FILENAME_MAX)
return "cannot create rapi_packages directory because the path is too large";
if (mkdir(rlibs, S_IRWXU) != 0 && errno != EEXIST) {
return "cannot create rapi_packages directory";
}
#ifdef _RAPI_DEBUG_
printf("# R libraries installed in %s\n",rlibs);
#endif
PROTECT(librisexp = allocVector(STRSXP, 1));
SET_STRING_ELT(librisexp, 0, mkChar(rlibs));
Rf_defineVar(Rf_install(".rapi.libdir"), librisexp, R_GlobalEnv);
UNPROTECT(1);
// run rapi.R environment setup script
{
char *f = locate_file("rapi", ".R", 0);
snprintf(rapiinclude, sizeof(rapiinclude), "source(\"%s\")", f);
GDKfree(f);
}
#if DIR_SEP != '/'
{
char *p;
for (p = rapiinclude; *p; p++)
if (*p == DIR_SEP)
*p = '/';
}
#endif
R_tryEvalSilent(
VECTOR_ELT(
R_ParseVector(mkString(rapiinclude), 1, &status,
R_NilValue), 0), R_GlobalEnv, &evalErr);
// of course the script may contain errors as well
if (evalErr != FALSE) {
return "failure running R setup script";
}
return NULL;
}
