Lng32 ExpLOBinterfaceInit(void *& exLobGlob, void * lobHeap,
void *currContext,NABoolean isHive,
char *hdfsServer,
Int32 port)
{
Ex_Lob_Error err;
Int64 dummyParam = 0;
Int64 cliError = -1;
Ex_Lob_Error status;
Int32 dummyParam2 = 0;
err = ExLobsOper((char*)"dummy",
NULL, 0,
NULL, 0,
NULL, dummyParam2, 0, dummyParam,
dummyParam, 0, dummyParam, status, cliError,
NULL, Lob_HDFS_File,
NULL, 0,
0,NULL,
Lob_Init,
Lob_None,
1, // waited op
exLobGlob,
0,
NULL, 0,
0);
if (exLobGlob)
{
((ExLobGlobals *)exLobGlob)->setIsHive(isHive);
NAHeap *heap = new ((NAHeap *)lobHeap) NAHeap("LOB Heap", (NAHeap *)lobHeap);
if (isHive)
((ExLobGlobals *)exLobGlob)->startWorkerThreads();
heap->setThreadSafe();
((ExLobGlobals *)exLobGlob)->setHeap(heap);
}
//set hdfsConnection from context global
ContextCli *localContext = (ContextCli *)currContext;
if (localContext)
{
hdfsFS fs = localContext->getHdfsServerConnection(hdfsServer,port);
if (fs == NULL)
{
return LOB_HDFS_CONNECT_ERROR;
}
else
{
((ExLobGlobals *)exLobGlob)->setHdfsFs(fs);
}
}
if (err != LOB_OPER_OK)
return err;
else
return 0;
}
IpcEnvironment *CliGlobals::getEnvironment()
{
ContextCli *currentContext = currContext();
if (currentContext != NULL)
return currentContext->getEnvironment();
else
return NULL;
}
void HdfsClient::deleteInstance()
{
ContextCli *currContext = GetCliGlobals()->currContext();
HdfsClient *hdfsClient = currContext->getHDFSClient();
if (hdfsClient != NULL) {
NAHeap *heap = currContext->exHeap();
NADELETE(hdfsClient, HdfsClient, heap);
currContext->setHDFSClient(NULL);
}
}
void HiveClient_JNI::deleteInstance()
{
ContextCli *currContext = GetCliGlobals()->currContext();
HiveClient_JNI *hiveClient_JNI = currContext->getHiveClient();
if (hiveClient_JNI != NULL)
{
NAHeap *heap = currContext->exHeap();
NADELETE(hiveClient_JNI, HiveClient_JNI, heap);
currContext->setHiveClient(NULL);
}
}
HdfsClient* HdfsClient::getInstance()
{
ContextCli *currContext = GetCliGlobals()->currContext();
HdfsClient *hdfsClient = currContext->getHDFSClient();
HDFS_Client_RetCode retcode;
if (hdfsClient == NULL) {
NAHeap *heap = currContext->exHeap();
hdfsClient = newInstance(heap, NULL, retcode);
if (retcode != HDFS_CLIENT_OK)
return NULL;
currContext->setHDFSClient(hdfsClient);
}
return hdfsClient;
}
void ExHdfsFastExtractTcb::createSequenceFileError(Int32 sfwRetCode)
{
ContextCli *currContext = GetCliGlobals()->currContext();
ComDiagsArea * diagsArea = NULL;
char* errorMsg = sequenceFileWriter_->getErrorText((SFW_RetCode)sfwRetCode);
ExRaiseSqlError(getHeap(),
&diagsArea,
(ExeErrorCode)(8447),
NULL, NULL, NULL, NULL,
errorMsg,
(char *)currContext->getJniErrorStr().data());
//ex_queue_entry *pentry_down = qParent_.down->getHeadEntry();
//pentry_down->setDiagsArea(diagsArea);
updateWorkATPDiagsArea(diagsArea);
}
HiveClient_JNI* HiveClient_JNI::getInstance()
{
HVC_RetCode hvcRetcode = HVC_OK;
ContextCli *currContext = GetCliGlobals()->currContext();
HiveClient_JNI *hiveClient_JNI = currContext->getHiveClient();
if (hiveClient_JNI == NULL)
{
NAHeap *heap = currContext->exHeap();
hiveClient_JNI = new (heap) HiveClient_JNI(heap);
if ((hvcRetcode = hiveClient_JNI->init()) == HVC_OK)
currContext->setHiveClient(hiveClient_JNI);
else {
NADELETE(hiveClient_JNI, HiveClient_JNI, heap);
hiveClient_JNI = NULL;
}
}
return hiveClient_JNI;
}
ContextCli * CliGlobals::getContext(SQLCTX_HANDLE context_handle,
NABoolean calledFromDrop)
{
ContextCli * context;
cliSemaphore_->get();
contextList_->position((char*)&context_handle, sizeof(SQLCTX_HANDLE));
while ((context = (ContextCli *)contextList_->getNext()) != NULL)
{
if (context_handle == context->getContextHandle())
{
if (context->isDropInProgress())
context = NULL;
else if (calledFromDrop)
context->setDropInProgress();
cliSemaphore_->release();
return context;
}
}
cliSemaphore_->release();
return NULL;
}
short ExExeUtilAQRTcb::work()
{
// if no parent request, return
if (qparent_.down->isEmpty())
return WORK_OK;
ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
ExExeUtilPrivateState & pstate =
*((ExExeUtilPrivateState*) pentry_down->pstate);
ContextCli *currContext =
getGlobals()->castToExExeStmtGlobals()->castToExMasterStmtGlobals()->
getStatement()->getContext();
AQRInfo * aqr = currContext->aqrInfo();
while (1)
{
switch (step_)
{
case EMPTY_:
{
if (aqrTdb().getTask() == ComTdbExeUtilAQR::GET_)
{
// GET aqr entries and display them
aqr->position();
step_ = RETURN_HEADER_;
}
else
{
step_ = SET_ENTRY_;
}
}
break;
case SET_ENTRY_:
{
if (aqr->setAQREntry(aqrTdb().getTask(),
aqrTdb().sqlcode_, aqrTdb().nskcode_,
aqrTdb().retries_, aqrTdb().delay_,
aqrTdb().type_,
0, NULL, 0, 0))
{
// error
step_ = HANDLE_ERROR_;
break;
}
step_ = DONE_;
}
break;
case RETURN_HEADER_:
{
// if no room in up queue for 4 display rows,
// won't be able to return data/status.
// Come back later.
if ((qparent_.up->getSize() - qparent_.up->getLength()) < 5)
return -1;
moveRowToUpQueue(" ");
moveRowToUpQueue(" SQLCODE PLATFORMERROR RETRIES DELAY TYPE ");
moveRowToUpQueue("============================================================");
moveRowToUpQueue(" ");
step_ = RETURNING_ENTRY_;
}
break;
case RETURNING_ENTRY_:
{
// if no room in up queue, won't be able to return data/status.
// Come back later.
if (qparent_.up->isFull())
return WORK_OK;
Lng32 sqlcode, nskcode, retries, delay, type, intAQR;
Lng32 eof = 0;
eof =
aqr->getNextAQREntry(sqlcode, nskcode, retries, delay, type,
intAQR);
if (eof)
{
step_ = DONE_;
break;
}
// internal aqr entry, no need to display
if (intAQR)
break;
char formattedStr[400];
str_sprintf(formattedStr, "%9d %13d %9d %9d %9d",
sqlcode, nskcode, retries, delay, type);
moveRowToUpQueue(formattedStr);
}
break;
case HANDLE_ERROR_:
{
if (qparent_.up->isFull())
return WORK_OK;
ExHandleErrors(qparent_,
pentry_down,
0,
getGlobals(),
NULL,
(ExeErrorCode)8931,
NULL,
NULL
);
step_ = DONE_;
}
break;
case DONE_:
{
if (qparent_.up->isFull())
return WORK_OK;
// all ok. Return EOF.
ex_queue_entry * up_entry = qparent_.up->getTailEntry();
up_entry->upState.parentIndex =
pentry_down->downState.parentIndex;
up_entry->upState.setMatchNo(0);
up_entry->upState.status = ex_queue::Q_NO_DATA;
// insert into parent
qparent_.up->insert();
step_ = EMPTY_;
qparent_.down->removeHead();
return WORK_OK;
}
break;
} // switch
}
return 0;
}
short ExExeUtilLongRunningTcb::processInitial(Lng32 &rc)
{
Int64 rowsAffected = 0;
setInitialOutputVarPtrList(new(getHeap()) Queue(getHeap()));
setContinuingOutputVarPtrList(new(getHeap()) Queue(getHeap()));
lruStmtAndPartInfo_ = new(getHeap()) char[(UInt32)(lrTdb().getLruStmtLen() + lrTdb().getPredicateLen() + 10)];
ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
ExEspStmtGlobals *espGlob = exeGlob->castToExEspStmtGlobals();
ContextCli *currContext = NULL;
CliGlobals *cliGlobals = NULL;
if (espGlob)
{
cliGlobals = GetCliGlobals();
currContext = cliGlobals->currContext();
}
else
{
currContext = exeGlob->castToExMasterStmtGlobals()->getStatement()->getContext();
}
Int32 espNum = 1;
// we are executing inside an ESP go ahead and set the partition number to the
// ESP instance number. The added one is because ESP instances are 0 based
if (espGlob)
{
espNum = (Int32) espGlob->getMyInstanceNumber() + 1;
}
if (lrTdb().getPredicate() != NULL)
str_sprintf(lruStmtAndPartInfo_,
lrTdb().getLruStmt(),
espNum,
lrTdb().getPredicate());
else
str_sprintf(lruStmtAndPartInfo_,
lrTdb().getLruStmt(),
espNum);
lruStmtWithCKAndPartInfo_ = new(getHeap()) char[(UInt32)(lrTdb().getLruStmtWithCKLen() + lrTdb().getPredicateLen() + 10)];
if (lrTdb().getPredicate() != NULL)
str_sprintf(lruStmtWithCKAndPartInfo_,
lrTdb().getLruStmtWithCK(),
espNum,
lrTdb().getPredicate());
else
str_sprintf(lruStmtWithCKAndPartInfo_,
lrTdb().getLruStmtWithCK(),
espNum);
// All internal queries issued from CliInterface assume that
// they are in ISO_MAPPING.
// For LongRunning we need to send the actual ISO_MAPPING.
// Save it and restore after the prepare
Int32 savedIsoMapping =
cliInterface()->getIsoMapping();
cliInterface()->setIsoMapping
(currContext->getSessionDefaults()->getIsoMappingEnum());
// If the table we are deleting from is an IUD log table,
// we need to set the parserflags to accept the special
// table type and the quoted column names
if (lrTdb().useParserflags())
currContext->setSqlParserFlags(0x3);
rc = cliInterface()->prepareAndExecRowsPrologue(lruStmtAndPartInfo_,
lruStmtWithCKAndPartInfo_,
getInitialOutputVarPtrList(),
getContinuingOutputVarPtrList(),
rowsAffected);
cliInterface()->setIsoMapping(savedIsoMapping);
if (rc < 0)
{
return -1;
}
if (rc >= 0 && rowsAffected > 0)
addRowsDeleted(rowsAffected);
return 0;
}
Int32 runESP(Int32 argc, char** argv, GuaReceiveFastStart *guaReceiveFastStart)
{
// initialize ESP global data
StatsGlobals * statsGlobals;
XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT, XMAX_SETTABLE_RECVLIMIT_H);
CliGlobals *cliGlobals = NULL;
cliGlobals = CliGlobals::createCliGlobals(TRUE); // TRUE indicates a non-master process (WAIT on LREC)
if (cliGlobals == NULL) // Sanity check
NAExit(1); // Abend
Int32 shmid;
statsGlobals = shareStatsSegment(shmid);
cliGlobals->setSharedMemId(shmid);
//Lng32 numCliCalls = cliGlobals->incrNumOfCliCalls();
cliGlobals->setIsESPProcess(TRUE);
NAHeap *espExecutorHeap = cliGlobals->getExecutorMemory();
// must create default context after set IpcEnvironment in CliGlobals first
// because context's ExSqlComp object needs IpcEnvironment
cliGlobals->initiateDefaultContext();
NAHeap *espIpcHeap = cliGlobals->getIpcHeap();
IpcEnvironment *ipcEnvPtr = cliGlobals->getEnvironment();
if (statsGlobals != NULL)
cliGlobals->setMemoryMonitor(statsGlobals->getMemoryMonitor());
else
{
// Start the memory monitor for dynamic memory management
Lng32 memMonitorWindowSize = 10;
Lng32 memMonitorSampleInterval = 10;
MemoryMonitor *memMonitor = new (espExecutorHeap)
MemoryMonitor(memMonitorWindowSize,
memMonitorSampleInterval,
espExecutorHeap);
cliGlobals->setMemoryMonitor(memMonitor);
}
// After CLI globals are initialized but before we begin ESP message
// processing, have the CLI context set its user identity based on
// the OS user identity.
ContextCli *context = cliGlobals->currContext();
ex_assert(context, "Invalid context pointer");
context->initializeUserInfoFromOS();
ExEspFragInstanceDir espFragInstanceDir(cliGlobals,
espExecutorHeap,
(StatsGlobals *)statsGlobals);
ExEspControlMessage espIpcControlMessage(&espFragInstanceDir,
ipcEnvPtr,
espIpcHeap);
// handle startup (command line args, control connection)
DoEspStartup(argc,argv,*ipcEnvPtr,espFragInstanceDir,guaReceiveFastStart);
// the control message stream talks through the control connection
espIpcControlMessage.addRecipient(
ipcEnvPtr->getControlConnection()->getConnection());
// start the first receive operation
espIpcControlMessage.receive(FALSE);
NABoolean timeout;
Int64 prevWaitTime = 0;
// while there are requesters
while (espFragInstanceDir.getNumMasters() > 0)
{
// -----------------------------------------------------------------
// The ESPs most important line of code: DO THE WORK
// -----------------------------------------------------------------
espFragInstanceDir.work(prevWaitTime);
// -----------------------------------------------------------------
// After we have done work, it's necessary to wait for some I/O
// (the frag instance dir work procedure works until it is blocked).
// -----------------------------------------------------------------
ipcEnvPtr->getAllConnections()->
waitOnAll(IpcInfiniteTimeout, TRUE, &timeout, &prevWaitTime); // TRUE means: Called by ESP main
}
// nobody wants us anymore, right now that means that we stop
return 0;
}
//////////////////////////////////////////////////////
// work() for ExTimeoutTcb
//////////////////////////////////////////////////////
short ExTimeoutTcb::work()
{
while (1) {
// if no parent request, return
if (qparent_.down->isEmpty())
return WORK_OK;
// if no room in up queue, won't be able to return data/status.
// Come back later.
if (qparent_.up->isFull()) return WORK_OK;
ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
ExTimeoutPrivateState & pstate =
*((ExTimeoutPrivateState*) pentry_down->pstate);
// Calculate the timeout actual value
Lng32 timeoutValue = 0;
NABoolean goodTimeoutValue = TRUE ;
if (timeoutValueExpr()) {
if ( timeoutValueExpr()->eval(pentry_down->getAtp(), workAtp_)
== ex_expr::EXPR_ERROR ) { // expression did not yield a valid value
handleErrors(pentry_down, pentry_down->getAtp()->getDiagsArea());
goodTimeoutValue = FALSE ;
} else {
tupp TP = workAtp_->getTupp(timeoutTdb().workCriDesc_->noTuples()-1);
timeoutValue = *(Lng32 *)TP.getDataPointer(); // pointer is (char *)
}
}
/****************************************************/
/******** Do the actual SET TIMEOUT work ********/
/** **/
/** The scope of the work is only making changes **/
/** to the global timeout data kept at the context **/
/****************************************************/
// Get the global timeout-data object
ContextCli * currContext = getGlobals()->castToExExeStmtGlobals()->
castToExMasterStmtGlobals()->getStatement()->getContext();
TimeoutData * GlobalTimeouts = currContext->getTimeouts();
#if _DEBUG // For debugging only !!!!!
if ( getenv("DEBUG_TIMEOUT") ) {
ComDiagsArea* diagsArea =
ComDiagsArea::allocate (getGlobals()->getDefaultHeap());
char errmsg[120];
if ( timeoutTdb().isStream() ) { // it was a SET STREAM TIMEOUT
if ( GlobalTimeouts->isStreamTimeoutSet() ) {
sprintf(errmsg, "Stream timeout set to %d\n",
GlobalTimeouts->getStreamTimeout() );
} else sprintf(errmsg, "Stream timeout was NOT SET ! \n");
} // lock timeout -- not stream
else {
if ( theTableName_[0] == '*' ) { // For all tables
sprintf(errmsg, "Number of lock timeouts set: %d\n",
GlobalTimeouts->entries() );
} else {
Lng32 timeoutValue;
NABoolean found =
GlobalTimeouts->getLockTimeout(theTableName_, timeoutValue );
if ( ! found )
sprintf(errmsg, "Lock timeout for table %s was NOT SET ! \n",
theTableName_ );
else sprintf(errmsg, "Lock timeout for table %s is %d \n",
theTableName_ , timeoutValue );
}
}
// emit message as an error ( msg 3066 has no text of its own )
*diagsArea << DgSqlCode(-3066)
<< DgString0(errmsg) ;
ExHandleArkcmpErrors(qparent_, pentry_down, 0, getGlobals(),
diagsArea, (ExeErrorCode) -3066 );
} // end of debugging section
else
#endif
if ( goodTimeoutValue ) {
// Update the globals as needed
if ( timeoutTdb().isStream() ) { // it was a SET STREAM TIMEOUT
if ( timeoutTdb().isReset() ) // it was a RESET
GlobalTimeouts->resetStreamTimeout();
else // it was a SET (with a value)
GlobalTimeouts->setStreamTimeout(timeoutValue);
}
else { // setting a LOCK TIMEOUT
// TBD =============>>> Check if FORALL string includes CAT.SCH ......
if ( theTableName_[0] == '*' ) { // For all tables
if ( timeoutTdb().isReset() ) // it was a RESET
GlobalTimeouts->resetAllLockTimeout();
else GlobalTimeouts->setAllLockTimeout(timeoutValue);
}
else { // per specific table
if ( timeoutTdb().isReset() ) // it was a RESET
GlobalTimeouts->resetTableLockTimeout( theTableName_ );
else GlobalTimeouts->setTableLockTimeout(theTableName_,timeoutValue);
}
}
// execution of every SET TIMEOUT stmt increments the change counter !!
currContext->incrementTimeoutChangeCounter();
// clear up (i.e. deallocate) the global timeout data, if possible
if ( GlobalTimeouts->noLockTimeoutsSet() &&
! GlobalTimeouts->isStreamTimeoutSet() )
currContext->clearTimeoutData();
} // end of if ( goodTimeoutValue )
/********** at this point the actual work is done ******************/
// all ok. Return EOF.
ex_queue_entry * up_entry = qparent_.up->getTailEntry();
up_entry->upState.parentIndex =
pentry_down->downState.parentIndex;
up_entry->upState.setMatchNo(0);
up_entry->upState.status = ex_queue::Q_NO_DATA;
// insert into parent
qparent_.up->insert();
qparent_.down->removeHead();
}
return WORK_OK;
}
