str
runFactory(Client cntxt, MalBlkPtr mb, MalBlkPtr mbcaller, MalStkPtr stk, InstrPtr pci)
{
Plant pl=0;
int firstcall= TRUE, i, k;
InstrPtr psig = getInstrPtr(mb, 0);
ValPtr lhs, rhs;
char cmd;
str msg;
#ifdef DEBUG_MAL_FACTORY
fprintf(stderr, "#factoryMgr called\n");
#endif
/* the lookup can be largely avoided by handing out the index
upon factory definition. todo
Alternative is to move them to the front
*/
for(i=0; i< lastPlant; i++)
if( plants[i].factory == mb){
if(i > 0 && i< lastPlant ){
PlantRecord prec= plants[i-1];
plants[i-1] = plants[i];
plants[i]= prec;
i--;
}
pl= plants+i;
firstcall= FALSE;
break;
}
if (pl == 0) {
/* compress the plant table*/
for(k=i=0;i<=lastPlant; i++)
if( plants[i].inuse)
plants[k++]= plants[i];
lastPlant = k;
/* initialize a new plant using the owner policy */
pl = newPlant(mb);
if (pl == NULL)
throw(MAL, "factory.new", SQLSTATE(HY001) MAL_MALLOC_FAIL);
}
/*
* We have found a factory to process the request.
* Let's call it as a synchronous action, without concern on parallelism.
*/
/* remember context */
pl->client = cntxt;
pl->caller = mbcaller;
pl->env = stk;
pl->pci = pci;
pl->inuse = 1;
/* inherit debugging */
cmd = stk->cmd;
if ( pl->stk == NULL)
throw(MAL, "factory.new", "internal error, stack frame missing");
/* copy the calling arguments onto the stack
of the factory */
i = psig->retc;
for (k = pci->retc; i < pci->argc; i++, k++) {
lhs = &pl->stk->stk[psig->argv[k]];
/* variable arguments ? */
if (k == psig->argc - 1)
k--;
rhs = &pl->env->stk[getArg(pci, i)];
if (VALcopy(lhs, rhs) == NULL)
throw(MAL, "factory.call", SQLSTATE(HY001) MAL_MALLOC_FAIL);
if( lhs->vtype == TYPE_bat )
BBPretain(lhs->val.bval);
}
if (mb->errors)
throw(MAL, "factory.call", PROGRAM_GENERAL);
if (firstcall ){
/* initialize the stack */
for(i= psig->argc; i< mb->vtop; i++) {
lhs = &pl->stk->stk[i];
if( isVarConstant(mb,i) > 0 ){
if( !isVarDisabled(mb,i)){
rhs = &getVarConstant(mb,i);
if (VALcopy(lhs,rhs) == NULL)
throw(MAL, "factory.call", SQLSTATE(HY001) MAL_MALLOC_FAIL);
}
} else{
lhs->vtype = getVarGDKType(mb,i);
lhs->val.pval = 0;
lhs->len = 0;
}
}
pl->stk->stkbot= mb->vtop; /* stack already initialized */
msg = runMAL(cntxt, mb, 0, pl->stk);
} else {
msg = reenterMAL(cntxt, mb, pl->pc, -1, pl->stk);
}
/* propagate change in debugging status */
if (cmd && pl->stk && pl->stk->cmd != cmd && cmd != 'x')
for (; stk; stk = stk->up)
stk->cmd = pl->stk->cmd;
return msg;
}
str
SQLengineIntern(Client c, backend *be)
{
str msg = MAL_SUCCEED;
MalStkPtr oldglb = c->glb;
char oldlang = be->language;
mvc *m = be->mvc;
InstrPtr p;
MalBlkPtr mb;
if (oldlang == 'X') { /* return directly from X-commands */
sqlcleanup(be->mvc, 0);
return MAL_SUCCEED;
}
if (m->emod & mod_explain) {
if (be->q && be->q->code)
printFunction(c->fdout, ((Symbol) (be->q->code))->def, 0, LIST_MAL_NAME | LIST_MAL_VALUE | LIST_MAL_MAPI);
else if (be->q)
msg = createException(PARSE, "SQLparser", "%s", (*m->errstr) ? m->errstr : "39000!program contains errors");
else if (c->curprg->def)
printFunction(c->fdout, c->curprg->def, 0, LIST_MAL_NAME | LIST_MAL_VALUE | LIST_MAL_MAPI);
goto cleanup_engine;
}
if (m->emod & mod_dot) {
if (be->q && be->q->code)
showFlowGraph(((Symbol) (be->q->code))->def, 0, "stdout-mapi");
else if (be->q)
msg = createException(PARSE, "SQLparser", "%s", (*m->errstr) ? m->errstr : "39000!program contains errors");
else if (c->curprg->def)
showFlowGraph(c->curprg->def, 0, "stdout-mapi");
goto cleanup_engine;
}
#ifdef SQL_SCENARIO_DEBUG
mnstr_printf(GDKout, "#Ready to execute SQL statement\n");
#endif
if (c->curprg->def->stop == 1) {
sqlcleanup(be->mvc, 0);
return MAL_SUCCEED;
}
if (m->emode == m_inplace) {
msg = SQLexecutePrepared(c, be, be->q);
goto cleanup_engine;
}
if (m->emode == m_prepare)
goto cleanup_engine;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = 0;
be->language = 'D';
/*
* The code below is copied from MALengine, which handles execution
* in the context of a user global environment. We have a private
* environment.
*/
if (MALcommentsOnly(c->curprg->def)) {
msg = MAL_SUCCEED;
} else {
msg = (str) runMAL(c, c->curprg->def, 0, 0);
}
cleanup_engine:
if (m->type == Q_SCHEMA)
qc_clean(m->qc);
if (msg) {
enum malexception type = getExceptionType(msg);
if (type == OPTIMIZER) {
MSresetInstructions(c->curprg->def, 1);
freeVariables(c, c->curprg->def, NULL, be->vtop);
be->language = oldlang;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
if ( msg)
GDKfree(msg);
return SQLrecompile(c, be); // retry compilation
} else {
/* don't print exception decoration, just the message */
char *n = NULL;
char *o = msg;
while ((n = strchr(o, '\n')) != NULL) {
*n = '\0';
mnstr_printf(c->fdout, "!%s\n", getExceptionMessage(o));
*n++ = '\n';
o = n;
}
if (*o != 0)
mnstr_printf(c->fdout, "!%s\n", getExceptionMessage(o));
}
showErrors(c);
m->session->status = -10;
}
mb = c->curprg->def;
if (m->type != Q_SCHEMA && be->q && msg) {
qc_delete(m->qc, be->q);
} else if (m->type != Q_SCHEMA && be->q && mb && varGetProp(mb, getArg(p = getInstrPtr(mb, 0), 0), runonceProp)) {
msg = SQLCacheRemove(c, getFunctionId(p));
qc_delete(be->mvc->qc, be->q);
///* this should invalidate any match */
//be->q->key= -1;
//be->q->paramlen = -1;
///* qc_delete(be->q) */
}
be->q = NULL;
sqlcleanup(be->mvc, (!msg) ? 0 : -1);
MSresetInstructions(c->curprg->def, 1);
freeVariables(c, c->curprg->def, NULL, be->vtop);
be->language = oldlang;
/*
* Any error encountered during execution should block further processing
* unless auto_commit has been set.
*/
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
return msg;
}
/*
* BEWARE: SQLstatementIntern only commits after all statements found
* in expr are executed, when autocommit mode is enabled.
*
* The tricky part for this statement is to ensure that the SQL statement
* is executed within the client context specified. This leads to context juggling.
*/
str
SQLstatementIntern(Client c, str *expr, str nme, int execute, bit output, res_table **result)
{
int status = 0;
int err = 0;
mvc *o, *m;
int ac, sizevars, topvars;
sql_var *vars;
int oldvtop, oldstop = 1;
buffer *b;
char *n;
stream *buf;
str msg = MAL_SUCCEED;
backend *be, *sql = (backend *) c->sqlcontext;
size_t len = strlen(*expr);
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#SQLstatement:%s\n", *expr);
#endif
if (!sql) {
msg = SQLinitEnvironment(c, NULL, NULL, NULL);
sql = (backend *) c->sqlcontext;
}
if (msg){
GDKfree(msg);
throw(SQL, "SQLstatement", "Catalogue not available");
}
initSQLreferences();
m = sql->mvc;
ac = m->session->auto_commit;
o = MNEW(mvc);
if (!o)
throw(SQL, "SQLstatement", "Out of memory");
*o = *m;
/* create private allocator */
m->sa = NULL;
SQLtrans(m);
status = m->session->status;
m->type = Q_PARSE;
be = sql;
sql = backend_create(m, c);
sql->output_format = be->output_format;
m->qc = NULL;
m->caching = 0;
m->user_id = m->role_id = USER_MONETDB;
if (result)
m->reply_size = -2; /* do not cleanup, result tables */
/* mimick a client channel on which the query text is received */
b = (buffer *) GDKmalloc(sizeof(buffer));
n = GDKmalloc(len + 1 + 1);
strncpy(n, *expr, len);
n[len] = '\n';
n[len + 1] = 0;
len++;
buffer_init(b, n, len);
buf = buffer_rastream(b, "sqlstatement");
scanner_init(&m->scanner, bstream_create(buf, b->len), NULL);
m->scanner.mode = LINE_N;
bstream_next(m->scanner.rs);
m->params = NULL;
m->argc = 0;
m->session->auto_commit = 0;
if (!m->sa)
m->sa = sa_create();
/*
* System has been prepared to parse it and generate code.
* Scan the complete string for SQL statements, stop at the first error.
*/
c->sqlcontext = sql;
while (msg == MAL_SUCCEED && m->scanner.rs->pos < m->scanner.rs->len) {
sql_rel *r;
stmt *s;
MalStkPtr oldglb = c->glb;
if (!m->sa)
m->sa = sa_create();
m->sym = NULL;
if ((err = sqlparse(m)) ||
/* Only forget old errors on transaction boundaries */
(mvc_status(m) && m->type != Q_TRANS) || !m->sym) {
if (!err)
err = mvc_status(m);
if (*m->errstr)
msg = createException(PARSE, "SQLparser", "%s", m->errstr);
*m->errstr = 0;
sqlcleanup(m, err);
execute = 0;
if (!err)
continue;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
/*
* We have dealt with the first parsing step and advanced the input reader
* to the next statement (if any).
* Now is the time to also perform the semantic analysis,
* optimize and produce code.
* We don't search the cache for a previous incarnation yet.
*/
MSinitClientPrg(c, "user", nme);
oldvtop = c->curprg->def->vtop;
oldstop = c->curprg->def->stop;
r = sql_symbol2relation(m, m->sym);
s = sql_relation2stmt(m, r);
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#SQLstatement:\n");
#endif
scanner_query_processed(&(m->scanner));
if (s == 0 || (err = mvc_status(m))) {
msg = createException(PARSE, "SQLparser", "%s", m->errstr);
handle_error(m, c->fdout, status);
sqlcleanup(m, err);
/* restore the state */
MSresetInstructions(c->curprg->def, oldstop);
freeVariables(c, c->curprg->def, c->glb, oldvtop);
c->curprg->def->errors = 0;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
/* generate MAL code */
if (backend_callinline(sql, c, s, 1) == 0)
addQueryToCache(c);
else
err = 1;
if (err ||c->curprg->def->errors) {
/* restore the state */
MSresetInstructions(c->curprg->def, oldstop);
freeVariables(c, c->curprg->def, c->glb, oldvtop);
c->curprg->def->errors = 0;
msg = createException(SQL, "SQLparser", "Errors encountered in query");
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#result of sql.eval()\n");
printFunction(c->fdout, c->curprg->def, 0, c->listing);
#endif
if (execute) {
MalBlkPtr mb = c->curprg->def;
if (!output)
sql->out = NULL; /* no output */
msg = runMAL(c, mb, 0, 0);
MSresetInstructions(mb, oldstop);
freeVariables(c, mb, NULL, oldvtop);
}
sqlcleanup(m, 0);
if (!execute) {
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#parse/execute result %d\n", err);
#endif
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
}
if (m->results && result) { /* return all results sets */
*result = m->results;
m->results = NULL;
}
/*
* We are done; a MAL procedure resides in the cache.
*/
endofcompile:
if (execute)
MSresetInstructions(c->curprg->def, 1);
c->sqlcontext = be;
backend_destroy(sql);
GDKfree(n);
GDKfree(b);
bstream_destroy(m->scanner.rs);
if (m->sa)
sa_destroy(m->sa);
m->sa = NULL;
m->sym = NULL;
/* variable stack maybe resized, ie we need to keep the new stack */
status = m->session->status;
sizevars = m->sizevars;
topvars = m->topvars;
vars = m->vars;
*m = *o;
_DELETE(o);
m->sizevars = sizevars;
m->topvars = topvars;
m->vars = vars;
m->session->status = status;
m->session->auto_commit = ac;
return msg;
}
str
MALengine(Client c)
{
Symbol prg;
str msg = MAL_SUCCEED;
MalBlkRecord oldstate = *c->curprg->def;
oldstate.stop = 0;
if (c->blkmode)
return MAL_SUCCEED;
prg = c->curprg;
if (prg == NULL)
throw(SYNTAX, "mal.engine", SYNTAX_SIGNATURE);
if (prg->def == NULL)
throw(SYNTAX, "mal.engine", SYNTAX_SIGNATURE);
if (prg->def->errors > 0) {
showErrors(c);
if (c->listing)
printFunction(c->fdout, c->curprg->def, 0, c->listing);
MSresetVariables(c, c->curprg->def, c->glb, oldstate.vtop);
resetMalBlk(c->curprg->def, 1);
throw(MAL, "mal.engine", PROGRAM_GENERAL);
}
if (prg->def->stop == 1 || MALcommentsOnly(prg->def))
return 0; /* empty block */
if (c->glb) {
if (prg->def && c->glb->stksize < prg->def->vsize){
c->glb = reallocGlobalStack(c->glb, prg->def->vsize);
if( c->glb == NULL)
throw(MAL, "mal.engine", MAL_MALLOC_FAIL);
}
c->glb->stktop = prg->def->vtop;
c->glb->blk = prg->def;
c->glb->cmd = (c->itrace && c->itrace != 'C') ? 'n' : 0;
}
if (c->listing > 1)
printFunction(c->fdout, c->curprg->def, 0, c->listing);
/*
* In interactive mode we should avoid early garbage collection of values.
* This can be controlled by the clean up control at the instruction level
* and marking all non-temporary variables as being (potentially) used.
*/
if (c->glb) {
c->glb->pcup = 0;
c->glb->keepAlive = TRUE; /* no garbage collection */
}
if (prg->def->errors == 0)
msg = (str) runMAL(c, prg->def, 0, c->glb);
if (msg) {
/* ignore "internal" exceptions */
str fcn = getExceptionPlace(msg); /* retrieves from "first" exception */
if (strcmp(fcn, "client.quit") != 0)
dumpExceptionsToStream(c->fdout, msg);
GDKfree(fcn);
if (!c->listing)
printFunction(c->fdout, c->curprg->def, 0, c->listing);
showErrors(c);
}
MSresetVariables(c, prg->def, c->glb, 0);
resetMalBlk(prg->def, 1);
if (c->glb) {
/* for global stacks avoid reinitialization from this point */
c->glb->stkbot = prg->def->vtop;
}
prg->def->errors = 0;
if (c->itrace)
mnstr_printf(c->fdout, "mdb>#EOD\n");
return msg;
}
