/*
* The multiplexSimple is called by the MAL scenario. It bypasses
* the optimizer infrastructure, to avoid excessive space allocation
* and interpretation overhead.
*/
str
OPTmultiplexSimple(Client cntxt)
{
MalBlkPtr mb= cntxt->curprg->def;
int i, doit=0;
InstrPtr p;
if(mb)
for( i=0; i<mb->stop; i++){
p= getInstrPtr(mb,i);
if(getModuleId(p) == malRef && getFunctionId(p) == multiplexRef)
doit++;
}
if( doit) {
OPTmultiplexImplementation(cntxt, mb, 0, 0);
chkTypes(cntxt->fdout, cntxt->nspace, mb,TRUE);
if ( mb->errors == 0) {
chkFlow(cntxt->fdout, mb);
chkDeclarations(cntxt->fdout,mb);
}
}
return 0;
}
/*
* The multiplexSimple is called by the MAL scenario. It bypasses
* the optimizer infrastructure, to avoid excessive space allocation
* and interpretation overhead.
*/
str
OPTmultiplexSimple(Client cntxt, MalBlkPtr mb)
{
//MalBlkPtr mb= cntxt->curprg->def;
int i, doit=0;
InstrPtr p;
str msg = MAL_SUCCEED;
if(mb)
for( i=0; i<mb->stop; i++){
p= getInstrPtr(mb,i);
if(isMultiplex(p)) {
p->typechk = TYPE_UNKNOWN;
doit++;
}
}
if( doit) {
msg = OPTmultiplexImplementation(cntxt, mb, 0, 0);
chkTypes(cntxt->usermodule, mb,TRUE);
chkFlow(mb);
chkDeclarations(mb);
}
return msg;
}
str
OPTevaluateImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
InstrPtr p;
int i, k, limit, *alias = 0, barrier;
MalStkPtr env = NULL;
int profiler;
int debugstate = cntxt->itrace, actions = 0, constantblock = 0;
int *assigned = 0, use;
char buf[256];
lng usec = GDKusec();
str msg = MAL_SUCCEED;
(void)stk;
(void)pci;
if ( mb->inlineProp )
return MAL_SUCCEED;
cntxt->itrace = 0;
#ifdef DEBUG_OPT_EVALUATE
fprintf(stderr, "Constant expression optimizer started\n");
#endif
assigned = (int*) GDKzalloc(sizeof(int) * mb->vtop);
if (assigned == NULL)
throw(MAL,"optimzier.evaluate", SQLSTATE(HY001) MAL_MALLOC_FAIL);
alias = (int*)GDKzalloc(mb->vsize * sizeof(int) * 2); /* we introduce more */
if (alias == NULL){
GDKfree(assigned);
throw(MAL,"optimzier.evaluate", SQLSTATE(HY001) MAL_MALLOC_FAIL);
}
// arguments are implicitly assigned by context
p = getInstrPtr(mb, 0);
for ( k =p->retc; k < p->argc; k++)
assigned[getArg(p,k)]++;
limit = mb->stop;
for (i = 1; i < limit; i++) {
p = getInstrPtr(mb, i);
// The double count emerging from a barrier exit is ignored.
if (! blockExit(p) || (blockExit(p) && p->retc != p->argc))
for ( k =0; k < p->retc; k++)
if ( p->retc != p->argc || p->token != ASSIGNsymbol )
assigned[getArg(p,k)]++;
}
for (i = 1; i < limit && cntxt->mode != FINISHCLIENT; i++) {
p = getInstrPtr(mb, i);
// to avoid management of duplicate assignments over multiple blocks
// we limit ourselves to evaluation of the first assignment only.
use = assigned[getArg(p,0)] == 1 && !(p->argc == p->retc && blockExit(p));
for (k = p->retc; k < p->argc; k++)
if (alias[getArg(p, k)])
getArg(p, k) = alias[getArg(p, k)];
#ifdef DEBUG_OPT_EVALUATE
fprintInstruction(stderr , mb, 0, p, LIST_MAL_ALL);
#endif
/* be aware that you only assign once to a variable */
if (use && p->retc == 1 && OPTallConstant(cntxt, mb, p) && !isUnsafeFunction(p)) {
barrier = p->barrier;
p->barrier = 0;
profiler = malProfileMode; /* we don't trace it */
malProfileMode = 0;
if ( env == NULL) {
env = prepareMALstack(mb, 2 * mb->vsize);
if (!env) {
msg = createException(MAL,"optimizer.evaluate", SQLSTATE(HY001) MAL_MALLOC_FAIL);
goto wrapup;
}
env->keepAlive = TRUE;
}
msg = reenterMAL(cntxt, mb, i, i + 1, env);
malProfileMode= profiler;
p->barrier = barrier;
#ifdef DEBUG_OPT_EVALUATE
fprintf(stderr, "#retc var %s\n", getVarName(mb, getArg(p, 0)));
fprintf(stderr, "#result:%s\n", msg == MAL_SUCCEED ? "ok" : msg);
#endif
if (msg == MAL_SUCCEED) {
int nvar;
ValRecord cst;
actions++;
cst.vtype = 0;
VALcopy(&cst, &env->stk[getArg(p, 0)]);
/* You may not overwrite constants. They may be used by
* other instructions */
nvar = getArg(p, 1) = defConstant(mb, getArgType(mb, p, 0), &cst);
if (nvar >= env->stktop) {
VALcopy(&env->stk[getArg(p, 1)], &getVarConstant(mb, getArg(p, 1)));
env->stktop = getArg(p, 1) + 1;
}
alias[getArg(p, 0)] = getArg(p, 1);
p->argc = 2;
p->token = ASSIGNsymbol;
clrFunction(p);
p->barrier = barrier;
/* freeze the type */
setVarFixed(mb,getArg(p,1));
setVarUDFtype(mb,getArg(p,1));
#ifdef DEBUG_OPT_EVALUATE
{str tpename;
fprintf(stderr, "Evaluated new constant=%d -> %d:%s\n",
getArg(p, 0), getArg(p, 1), tpename = getTypeName(getArgType(mb, p, 1)));
GDKfree(tpename);
}
#endif
} else {
/* if there is an error, we should postpone message handling,
as the actual error (eg. division by zero ) may not happen) */
#ifdef DEBUG_OPT_EVALUATE
fprintf(stderr, "Evaluated %s\n", msg);
#endif
freeException(msg);
msg= MAL_SUCCEED;
mb->errors = 0;
}
}
constantblock += blockStart(p) && OPTallConstant(cntxt, mb, p); /* default */
}
// produces errors in SQL when enabled
if ( constantblock)
msg = OPTremoveUnusedBlocks(cntxt, mb);
cntxt->itrace = debugstate;
/* Defense line against incorrect plans */
/* Plan is unaffected */
chkTypes(cntxt->usermodule, mb, FALSE);
chkFlow(mb);
chkDeclarations(mb);
/* keep all actions taken as a post block comment */
usec = GDKusec()- usec;
snprintf(buf,256,"%-20s actions=%2d time=" LLFMT " usec","evaluate",actions,usec);
newComment(mb,buf);
if( actions >= 0)
addtoMalBlkHistory(mb);
wrapup:
if ( env) freeStack(env);
if(assigned) GDKfree(assigned);
if(alias) GDKfree(alias);
return msg;
}
str
OPTvolcanoImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
int i, limit;
int mvcvar = -1;
int count=0;
InstrPtr p,q, *old = mb->stmt;
char buf[256];
lng usec = GDKusec();
str msg = MAL_SUCCEED;
(void) pci;
(void) cntxt;
(void) stk; /* to fool compilers */
if ( mb->inlineProp )
return MAL_SUCCEED;
limit= mb->stop;
if ( newMalBlkStmt(mb, mb->ssize + 20) < 0)
throw(MAL,"optimizer.volcano", SQLSTATE(HY001) MAL_MALLOC_FAIL);
for (i = 0; i < limit; i++) {
p = old[i];
pushInstruction(mb,p);
if( getModuleId(p) == sqlRef && getFunctionId(p)== mvcRef ){
mvcvar = getArg(p,0);
continue;
}
if( count < MAXdelays && getModuleId(p) == algebraRef ){
if( getFunctionId(p) == selectRef ||
getFunctionId(p) == thetaselectRef ||
getFunctionId(p) == likeselectRef ||
getFunctionId(p) == joinRef
){
q= newInstruction(0,languageRef,blockRef);
setDestVar(q, newTmpVariable(mb,TYPE_any));
q = pushArgument(mb,q,mvcvar);
q = pushArgument(mb,q,getArg(p,0));
mvcvar= getArg(q,0);
pushInstruction(mb,q);
count++;
}
continue;
}
if( count < MAXdelays && getModuleId(p) == groupRef ){
if( getFunctionId(p) == subgroupdoneRef || getFunctionId(p) == groupdoneRef ){
q= newInstruction(0,languageRef,blockRef);
setDestVar(q, newTmpVariable(mb,TYPE_any));
q = pushArgument(mb,q,mvcvar);
q = pushArgument(mb,q,getArg(p,0));
mvcvar= getArg(q,0);
pushInstruction(mb,q);
count++;
}
}
if( getModuleId(p) == sqlRef){
if ( getFunctionId(p) == bindRef ||
getFunctionId(p) == bindidxRef ||
getFunctionId(p)== tidRef ||
getFunctionId(p)== appendRef ||
getFunctionId(p)== updateRef ||
getFunctionId(p)== deleteRef
){
setArg(p,p->retc,mvcvar);
}
}
}
GDKfree(old);
/* Defense line against incorrect plans */
if( count){
chkTypes(cntxt->usermodule, mb, FALSE);
chkFlow(mb);
chkDeclarations(mb);
}
/* keep all actions taken as a post block comment */
usec = GDKusec()- usec;
snprintf(buf,256,"%-20s actions=%2d time=" LLFMT " usec","volcano",count,usec);
newComment(mb,buf);
if( count >= 0)
addtoMalBlkHistory(mb);
return msg;
}
str
OPTmultiplexImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
InstrPtr *old = 0, p;
int i, limit, slimit, actions= 0;
str msg= MAL_SUCCEED;
char buf[256];
lng usec = GDKusec();
(void) stk;
(void) pci;
old = mb->stmt;
limit = mb->stop;
slimit = mb->ssize;
if ( newMalBlkStmt(mb, mb->ssize) < 0 )
throw(MAL,"optimizer.mergetable", SQLSTATE(HY001) MAL_MALLOC_FAIL);
for (i = 0; i < limit; i++) {
p = old[i];
if (msg == MAL_SUCCEED && isMultiplex(p)) {
if ( MANIFOLDtypecheck(cntxt,mb,p,0) != NULL){
setFunctionId(p, manifoldRef);
p->typechk = TYPE_UNKNOWN;
pushInstruction(mb, p);
actions++;
continue;
}
msg = OPTexpandMultiplex(cntxt, mb, stk, p);
if( msg== MAL_SUCCEED){
freeInstruction(p);
old[i]=0;
actions++;
continue;
}
pushInstruction(mb, p);
actions++;
} else if( old[i])
pushInstruction(mb, p);
}
for(;i<slimit; i++)
if( old[i])
freeInstruction(old[i]);
GDKfree(old);
/* Defense line against incorrect plans */
if( msg == MAL_SUCCEED && actions > 0){
chkTypes(cntxt->usermodule, mb, FALSE);
chkFlow(mb);
chkDeclarations(mb);
}
/* keep all actions taken as a post block comment */
usec = GDKusec()- usec;
snprintf(buf,256,"%-20s actions=%2d time=" LLFMT " usec","multiplex",actions, usec);
newComment(mb,buf);
if( actions >= 0)
addtoMalBlkHistory(mb);
return msg;
}
str
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;
char buf[256];
lng usec = GDKusec();
str msg = MAL_SUCCEED;
(void) pci;
(void) cntxt;
(void) stk; /* to fool compilers */
old= mb->stmt;
limit= mb->stop;
slimit = mb->ssize;
if ( newMalBlkStmt(mb,mb->stop) < 0)
throw(MAL,"optimizer.json", SQLSTATE(HY001) MAL_MALLOC_FAIL);
for (i = 0; i < limit; i++) {
p = old[i];
if( getModuleId(p) == sqlRef && getFunctionId(p) == affectedRowsRef) {
q = newInstruction(0, 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);
setDestVar(q, newTmpVariable(mb, TYPE_str));
pushInstruction(mb,p);
q = newInstruction(0, NULL, NULL);
q->barrier = RETURNsymbol;
getArg(q,0)= getArg(p,0);
pushArgument(mb,q,j);
pushInstruction(mb,q);
actions++;
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);
actions++;
continue;
}
pushInstruction(mb,p);
}
for(; i<slimit; i++)
if (old[i])
freeInstruction(old[i]);
GDKfree(old);
/* Defense line against incorrect plans */
if( actions > 0){
chkTypes(cntxt->usermodule, mb, FALSE);
chkFlow(mb);
chkDeclarations(mb);
}
/* keep all actions taken as a post block comment */
usec = GDKusec()- usec;
snprintf(buf,256,"%-20s actions=%2d time=" LLFMT " usec","json",actions, usec);
newComment(mb,buf);
if( actions >= 0)
addtoMalBlkHistory(mb);
return msg;
}
