str QOTgetStatistics(int *ret, str *nme) { int idx; QOTstatisticsInit(); if( qotStat[QOTnames] == NULL) throw(ILLARG,"optimizer.getStatistics",RUNTIME_OBJECT_MISSING); idx= QOTindex(*nme); if( idx < 0 || qotStat[idx] == 0 ) throw(ILLARG,"optimizer.getStatistics",RUNTIME_OBJECT_MISSING); BBPincref(*ret= qotStat[idx]->batCacheid, TRUE); return MAL_SUCCEED; }
/* * At the end of the query plan we save the result in * a separate variable. */ str RUNpickResult(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p) { ValPtr lhs, rhs; int i; (void) cntxt; lhs = &stk->stk[getArg(p, 0)]; for (i = p->retc; i < p->argc; i++) if (!isVarDisabled(mb, getArg(p, i))) { rhs = &stk->stk[getArg(p, i)]; if ((rhs)->vtype < TYPE_str) *lhs = *rhs; else VALcopy(lhs, rhs); if (lhs->vtype == TYPE_bat) BBPincref(lhs->val.bval, TRUE); return MAL_SUCCEED; } throw(MAL, "scheduler.pick", OPERATION_FAILED "No result available"); }
void temp_dup(log_bid b) { BBPincref(b, TRUE); }
static void bat_incref(bat bid) { BBPincref(bid, TRUE); }
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 mnstr_printf(cntxt->fdout, "#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", 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)]; VALcopy(lhs, rhs); if( lhs->vtype == TYPE_bat ) BBPincref(lhs->val.bval, TRUE); } 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); VALcopy(lhs,rhs); } } 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; }
/* * The shortcut operator for factory calls assumes that the user is * not interested in the results produced. */ str callFactory(Client cntxt, MalBlkPtr mb, ValPtr argv[], char flag){ Plant pl; InstrPtr psig = getInstrPtr(mb, 0); int i; ValPtr lhs,rhs; MalStkPtr stk; str ret; i= findPlant(mb); if( i< 0) { /* first call? prepare the factory */ pl = newPlant(mb); if (pl == NULL) throw(MAL, "factory.call", MAL_MALLOC_FAIL); /* remember context, which does not exist. */ pl->client = cntxt; pl->caller = 0; pl->env = 0; pl->pci = 0; pl->inuse = 1; stk = pl->stk; /* initialize the stack */ stk->stktop= mb->vtop; stk->stksize= mb->vsize; stk->blk= mb; stk->up = 0; stk->cmd= flag; /* initialize the stack */ for(i= psig->argc; i< mb->vtop; i++) if( isVarConstant(mb,i) > 0 ){ lhs = &stk->stk[i]; rhs = &getVarConstant(mb,i); VALcopy(lhs,rhs); } else { lhs = &stk->stk[i]; lhs->vtype = getVarGDKType(mb,i); } pl->stk= stk; } else { pl= plants+i; /* * When you re-enter the factory the old arguments should be * released to make room for the new ones. */ for (i = psig->retc; i < psig->argc; i++) { lhs = &pl->stk->stk[psig->argv[i]]; if( lhs->vtype == TYPE_bat ) BBPdecref(lhs->val.bval, TRUE); } } /* copy the calling arguments onto the stack of the factory */ i = psig->retc; for (i = psig->retc; i < psig->argc; i++) { lhs = &pl->stk->stk[psig->argv[i]]; VALcopy(lhs, argv[i]); if( lhs->vtype == TYPE_bat ) BBPincref(lhs->val.bval, TRUE); } ret= reenterMAL(cntxt, mb, pl->pc, -1, pl->stk); /* garbage collect the string arguments, these positions will simply be overwritten the next time. for (i = psig->retc; i < psig->argc; i++) garbageElement(lhs = &pl->stk->stk[psig->argv[i]]); */ return ret; }