// seed random number generator
static void seedIt()
{
if (seeded_)
return;
// else
Lng32 seed = CmpCommon::getDefaultLong(FLOAT_ESP_RANDOM_NUM_SEED);
if (!random_)
random_ = new(GetCliGlobals()->exCollHeap()) RandomSequence();
CLISemaphore * sema = GetCliGlobals()->getSemaphore();
sema->get();
if (!seeded_) {
if (seed == 0) {
TimeVal tim;
GETTIMEOFDAY(&tim, 0);
seed = tim.tv_usec;
}
seed = seed % 65535;
random_->initialize(seed);
seeded_ = TRUE;
}
sema->release();
}
SP_STATUS HybridQueryCacheStatStoredProcedure::sp_Process(SP_PROCESS_ACTION action,
SP_ROW_DATA inputData ,
SP_EXTRACT_FUNCPTR eFunc ,
SP_ROW_DATA outputData ,
SP_FORMAT_FUNCPTR fFunc,
SP_KEY_VALUE keys,
SP_KEYVALUE_FUNCPTR kFunc,
SP_PROCESS_HANDLE* spProcHandle,
SP_HANDLE spObj/* spHandle */,
SP_ERROR_STRUCT* error )
{
switch (action) {
case SP_PROC_OPEN:
{
HybridQueryCacheStatsISPIterator * it = new (GetCliGlobals()->exCollHeap()) HybridQueryCacheStatsISPIterator(inputData, eFunc, error,
GetCliGlobals()->currContext()->getCmpContextInfo(), GetCliGlobals()->exCollHeap());
*spProcHandle = it;
return SP_SUCCESS;
}
break;
case SP_PROC_FETCH:
{
HybridQueryCacheStatsISPIterator* it = (HybridQueryCacheStatsISPIterator *)(*spProcHandle);
if (!it) {
return SP_FAIL;
}
HybridQueryCacheStats stats;
if(!it->getNext(stats))
return SP_SUCCESS;
fFunc(0, outputData, sizeof(stats.nHKeys), &(stats.nHKeys), 0);
fFunc(1, outputData, sizeof(stats.nSKeys), &(stats.nSKeys), 0);
fFunc(2, outputData, sizeof(stats.nMaxValuesPerKey), &(stats.nMaxValuesPerKey), 0);
fFunc(3, outputData, sizeof(stats.nHashTableBuckets), &(stats.nHashTableBuckets), 0);
return SP_MOREDATA;
}
break;
case SP_PROC_CLOSE: {
NADELETEBASIC((HybridQueryCacheStatsISPIterator *)(*spProcHandle), GetCliGlobals()->exCollHeap());
return SP_SUCCESS;
}
break;
default: break;
} // switch
return SP_SUCCESS;
}
HVC_RetCode HiveClient_JNI::getRedefTime(const char* schName,
const char* tabName,
Int64& redefTime)
{
QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "Enter HiveClient_JNI::getRedefTime(%s, %s, %lld).", schName, tabName, redefTime);
if (initJNIEnv() != JOI_OK)
return HVC_ERROR_INIT_PARAM;
if (getInstance() == NULL)
return HVC_ERROR_INIT_PARAM;
jstring js_schName = jenv_->NewStringUTF(schName);
if (js_schName == NULL)
{
GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_GET_REDEFTIME_PARAM));
jenv_->PopLocalFrame(NULL);
return HVC_ERROR_GET_REDEFTIME_PARAM;
}
jstring js_tabName = jenv_->NewStringUTF(tabName);
if (js_tabName == NULL)
{
GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_GET_REDEFTIME_PARAM));
jenv_->PopLocalFrame(NULL);
return HVC_ERROR_GET_REDEFTIME_PARAM;
}
// jlong getRedefTime(java.lang.String, java.lang.String);
tsRecentJMFromJNI = JavaMethods_[JM_GET_RDT].jm_full_name;
jlong jresult = jenv_->CallStaticLongMethod(javaClass_,
JavaMethods_[JM_GET_RDT].methodID,
js_schName, js_tabName);
if (jenv_->ExceptionCheck())
{
getExceptionDetails(__FILE__, __LINE__, "HiveClient_JNI::getRedefTime()");
jenv_->PopLocalFrame(NULL);
return HVC_ERROR_GET_REDEFTIME_EXCEPTION;
}
QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "Exit HiveClient_JNI::getRedefTime(%s, %s, %lld).", schName, tabName, redefTime);
if (jresult <= 0) {
jenv_->PopLocalFrame(NULL);
return HVC_DONE; // Table does not exist
}
redefTime = jresult ;
jenv_->PopLocalFrame(NULL);
return HVC_OK; // Table exists.
}
CmpStatement::ReturnStatus
CmpStatement::process (const CmpMessageSetTrans& statement)
{
CmpCommon::transMode()->updateTransMode((TransMode *)statement.data());
GetCliGlobals()-> updateTransMode((TransMode *)statement.data());
return CmpStatement_SUCCESS;
}
NABoolean HHDFSTableStats::connectHDFS(const NAString &host, Int32 port)
{
NABoolean result = TRUE;
// establish connection to HDFS . Conect to the connection cached in the context.
fs_ = ((GetCliGlobals()->currContext())->getHdfsServerConnection((char *)host.data(),port));
if (fs_ == NULL)
{
NAString errMsg("hdfsConnect to ");
errMsg += host;
errMsg += ":";
errMsg += port;
errMsg += " failed";
diags_.recordError(errMsg, "HHDFSTableStats::connectHDFS");
result = FALSE;
}
currHdfsHost_ = host;
currHdfsPort_ = port;
// }
return result;
}
HDFS_Client_RetCode HdfsClient::hdfsCleanUnloadPath( const NAString& uldPath)
{
QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsCleanUnloadPath(%s) called.",
uldPath.data());
if (initJNIEnv() != JOI_OK)
return HDFS_CLIENT_ERROR_HDFS_CLEANUP_PARAM;
if (getInstance() == NULL)
return HDFS_CLIENT_ERROR_HDFS_CLEANUP_PARAM;
jstring js_UldPath = jenv_->NewStringUTF(uldPath.data());
if (js_UldPath == NULL) {
GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_CLEANUP_PARAM));
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HDFS_CLEANUP_PARAM;
}
tsRecentJMFromJNI = JavaMethods_[JM_HDFS_CLEAN_UNLOAD_PATH].jm_full_name;
jboolean jresult = jenv_->CallStaticBooleanMethod(javaClass_, JavaMethods_[JM_HDFS_CLEAN_UNLOAD_PATH].methodID, js_UldPath);
if (jenv_->ExceptionCheck())
{
getExceptionDetails();
logError(CAT_SQL_HDFS, __FILE__, __LINE__);
logError(CAT_SQL_HDFS, "HdfsClient::hdfsCleanUnloadPath()", getLastError());
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HDFS_CLEANUP_EXCEPTION;
}
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_OK;
}
// ----------------------------------------------------------------------------
// method: getCurrentUsername
//
// Returns a pointer to the current database username
// ----------------------------------------------------------------------------
const char * ComUser::getCurrentUsername()
{
return GetCliGlobals()->currContext()->getDatabaseUserName();
}
NABoolean isParentQueryCanceled()
{
NABoolean isCanceled = FALSE;
CliGlobals *cliGlobals = GetCliGlobals();
StatsGlobals *statsGlobals = cliGlobals->getStatsGlobals();
const char *parentQid = CmpCommon::context()->sqlSession()->getParentQid();
if (statsGlobals && parentQid)
{
short savedPriority, savedStopMode;
statsGlobals->getStatsSemaphore(cliGlobals->getSemId(),
cliGlobals->myPin(), savedPriority, savedStopMode,
FALSE /*shouldTimeout*/);
StmtStats *ss = statsGlobals->getMasterStmtStats(parentQid,
strlen(parentQid), RtsQueryId::ANY_QUERY_);
if (ss)
{
ExMasterStats *masterStats = ss->getMasterStats();
if (masterStats && masterStats->getCanceledTime() != -1)
isCanceled = TRUE;
}
statsGlobals->releaseStatsSemaphore(cliGlobals->getSemId(),
cliGlobals->myPin(), savedPriority, savedStopMode);
}
return isCanceled;
}
HDFS_Client_RetCode HdfsClient::hdfsMergeFiles( const NAString& srcPath,
const NAString& dstPath)
{
QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsMergeFiles(%s, %s) called.",
srcPath.data(), dstPath.data());
if (initJNIEnv() != JOI_OK)
return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM;
if (getInstance() == NULL)
return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM;
jstring js_SrcPath = jenv_->NewStringUTF(srcPath.data());
if (js_SrcPath == NULL) {
GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM));
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM;
}
jstring js_DstPath= jenv_->NewStringUTF(dstPath.data());
if (js_DstPath == NULL) {
GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM));
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM;
}
tsRecentJMFromJNI = JavaMethods_[JM_HDFS_MERGE_FILES].jm_full_name;
jboolean jresult = jenv_->CallStaticBooleanMethod(javaClass_, JavaMethods_[JM_HDFS_MERGE_FILES].methodID, js_SrcPath, js_DstPath);
if (jenv_->ExceptionCheck())
{
getExceptionDetails();
logError(CAT_SQL_HDFS, __FILE__, __LINE__);
logError(CAT_SQL_HDFS, "HdfsClient::hdfsMergeFiles()", getLastError());
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_EXCEPTION;
}
if (jresult == false)
{
logError(CAT_SQL_HDFS, "HdfsClient::hdfsMergeFiles()", getLastError());
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_EXCEPTION;
}
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_OK;
}
SP_STATUS NARoutineCacheStatStoredProcedure::sp_ProcessRoutine(
SP_PROCESS_ACTION action,
SP_ROW_DATA inputData,
SP_EXTRACT_FUNCPTR eFunc,
SP_ROW_DATA outputData,
SP_FORMAT_FUNCPTR fFunc,
SP_KEY_VALUE keys,
SP_KEYVALUE_FUNCPTR kFunc,
SP_PROCESS_HANDLE *spProcHandle,
SP_HANDLE spObj,
SP_ERROR_STRUCT *error)
{
if (action == SP_PROC_OPEN) {
NARoutineCacheStatsISPIterator * it = new (GetCliGlobals()->exCollHeap())
NARoutineCacheStatsISPIterator(inputData, eFunc, error,
GetCliGlobals()->currContext()->getCmpContextInfo(),
GetCliGlobals()->exCollHeap());
*spProcHandle = it;
return SP_SUCCESS;
}
if (action == SP_PROC_FETCH) {
NARoutineCacheStatsISPIterator* it = (NARoutineCacheStatsISPIterator *)(*spProcHandle);
if (!it) {
return SP_FAIL;
}
NARoutineCacheStats stats;
if(!it->getNext(stats))
return SP_SUCCESS;
fFunc(0, outputData, sizeof(ULng32), &(stats.numLookups), 0);
fFunc(1, outputData, sizeof(ULng32), &(stats.numCacheHits), 0);
fFunc(2, outputData, sizeof(ULng32), &(stats.numEntries), 0);
fFunc(3, outputData, sizeof(ULng32), &(stats.currentCacheSize), 0);
fFunc(4, outputData, sizeof(ULng32), &(stats.highWaterMark), 0);
fFunc(5, outputData, sizeof(ULng32), &(stats.maxCacheSize), 0);
return SP_MOREDATA;
}
if (action == SP_PROC_CLOSE) {
if (*spProcHandle)
NADELETEBASIC((NARoutineCacheStatsISPIterator *)(*spProcHandle), GetCliGlobals()->exCollHeap());
return SP_SUCCESS;
}
return SP_SUCCESS;
}
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);
}
}
static double srandom()
{
seedIt();
double rv;
CLISemaphore * sema = GetCliGlobals()->getSemaphore();
sema->get();
rv = random_->random();
sema->release();
return rv;
};
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);
}
}
HVC_RetCode HiveClient_JNI::exists(const char* schName, const char* tabName)
{
QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HiveClient_JNI::exists(%s, %s) called.", schName, tabName);
if (initJNIEnv() != JOI_OK)
return HVC_ERROR_INIT_PARAM;
if (getInstance() == NULL)
return HVC_ERROR_INIT_PARAM;
jstring js_schName = jenv_->NewStringUTF(schName);
if (js_schName == NULL)
{
GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_EXISTS_PARAM));
jenv_->PopLocalFrame(NULL);
return HVC_ERROR_EXISTS_PARAM;
}
jstring js_tabName = jenv_->NewStringUTF(tabName);
if (js_tabName == NULL)
{
GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_EXISTS_PARAM));
jenv_->PopLocalFrame(NULL);
return HVC_ERROR_EXISTS_PARAM;
}
// boolean exists(java.lang.String, java.lang.String);
tsRecentJMFromJNI = JavaMethods_[JM_EXISTS].jm_full_name;
jboolean jresult = jenv_->CallStaticBooleanMethod(javaClass_, JavaMethods_[JM_EXISTS].methodID, js_schName, js_tabName);
if (jenv_->ExceptionCheck())
{
getExceptionDetails(__FILE__, __LINE__, "HiveClient_JNI::exists()");
jenv_->PopLocalFrame(NULL);
return HVC_ERROR_EXISTS_EXCEPTION;
}
if (jresult == false) {
jenv_->PopLocalFrame(NULL);
return HVC_DONE; // Table does not exist
}
jenv_->PopLocalFrame(NULL);
return HVC_OK; // Table exists.
}
SP_STATUS QueryCacheDeleteStoredProcedure::sp_Process(
SP_PROCESS_ACTION action,
SP_ROW_DATA inputData,
SP_EXTRACT_FUNCPTR eFunc,
SP_ROW_DATA outputData,
SP_FORMAT_FUNCPTR fFunc,
SP_KEY_VALUE keys,
SP_KEYVALUE_FUNCPTR kFunc,
SP_PROCESS_HANDLE *spProcHandle,
SP_HANDLE spObj,
SP_ERROR_STRUCT *error)
{
SP_STATUS status = SP_SUCCESS;
switch (action)
{
case SP_PROC_OPEN:
{
QueryCacheDeleter* deleter = new (GetCliGlobals()->exCollHeap()) QueryCacheDeleter(inputData, eFunc, error,
GetCliGlobals()->currContext()->getCmpContextInfo(), GetCliGlobals()->exCollHeap());
*spProcHandle = deleter;
}
break;
case SP_PROC_FETCH:
{
QueryCacheDeleter* deleter = (QueryCacheDeleter*)(*spProcHandle);
if (deleter == NULL )
{
status = SP_FAIL;
break;
}
//clear all specified QueryCache
deleter->doDelete();
}
break;
case SP_PROC_CLOSE:
NADELETEBASIC((QueryCacheDeleter *)(*spProcHandle), GetCliGlobals()->exCollHeap());
break;
}
return status;
}
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;
}
NABoolean HiveMetaData::recordError(Int32 errCode,
const char *errMethodName)
{
if (errCode != HVC_OK)
{
errCode_ = errCode;
if (client_)
errCodeStr_ = client_->getErrorText((HVC_RetCode)errCode_);
errMethodName_ = errMethodName;
errDetail_ = GetCliGlobals()->getJniErrorStrPtr();
return FALSE;
}
return TRUE;
}
// ----------------------------------------------------------------------------
// method: verifyAuthority
//
// makes sure user has privilege to perform operation
//
// Input: none
//
// Output: an exception is generated if user does not have authority
// ----------------------------------------------------------------------------
void CmpSeabaseDDLauth::verifyAuthority()
{
// get effective user from the Context
// TBD - replace this call with SQL_EXEC_ call
const char *databaseUserName = GetCliGlobals()->currContext()->getDatabaseUserName();
NAString userNameStr = databaseUserName;
NAString rootNameStr = ComUser::getRootUserName();
if (rootNameStr != userNameStr)
{
*CmpCommon::diags() << DgSqlCode (-CAT_NOT_AUTHORIZED);
UserException excp (NULL, 0);
excp.throwException();
}
}
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);
}
Int32 HdfsClient::hdfsWrite(const char* data, Int64 len, HDFS_Client_RetCode &hdfsClientRetcode)
{
QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsWrite(%ld) called.", len);
if (initJNIEnv() != JOI_OK) {
hdfsClientRetcode = HDFS_CLIENT_ERROR_HDFS_WRITE_EXCEPTION;
return 0;
}
//Write the requisite bytes into the file
jbyteArray jbArray = jenv_->NewByteArray( len);
if (!jbArray) {
GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_WRITE_PARAM));
jenv_->PopLocalFrame(NULL);
hdfsClientRetcode = HDFS_CLIENT_ERROR_HDFS_WRITE_PARAM;
return 0;
}
jenv_->SetByteArrayRegion(jbArray, 0, len, (const jbyte*)data);
if (hdfsStats_ != NULL)
hdfsStats_->getHdfsTimer().start();
tsRecentJMFromJNI = JavaMethods_[JM_HDFS_WRITE].jm_full_name;
// Java method returns the cumulative bytes written
jint totalBytesWritten = jenv_->CallIntMethod(javaObj_, JavaMethods_[JM_HDFS_WRITE].methodID, jbArray);
if (hdfsStats_ != NULL) {
hdfsStats_->incMaxHdfsIOTime(hdfsStats_->getHdfsTimer().stop());
hdfsStats_->incHdfsCalls();
}
if (jenv_->ExceptionCheck())
{
getExceptionDetails();
logError(CAT_SQL_HDFS, __FILE__, __LINE__);
logError(CAT_SQL_HDFS, "HdfsClient::hdfsWrite()", getLastError());
jenv_->PopLocalFrame(NULL);
hdfsClientRetcode = HDFS_CLIENT_ERROR_HDFS_WRITE_EXCEPTION;
return 0;
}
jenv_->PopLocalFrame(NULL);
hdfsClientRetcode = HDFS_CLIENT_OK;
Int32 bytesWritten = totalBytesWritten - totalBytesWritten_;
totalBytesWritten_ = totalBytesWritten;
return bytesWritten;
}
HDFS_Client_RetCode HdfsClient::hdfsCreate(const char* path, NABoolean overwrite, NABoolean compress)
{
QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsCreate(%s) called.", path);
if (initJNIEnv() != JOI_OK)
return HDFS_CLIENT_ERROR_HDFS_CREATE_PARAM;
setPath(path);
jstring js_path = jenv_->NewStringUTF(path);
if (js_path == NULL) {
GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_CREATE_PARAM));
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HDFS_CREATE_PARAM;
}
jboolean j_compress = compress;
jboolean j_overwrite = overwrite;
if (hdfsStats_ != NULL)
hdfsStats_->getHdfsTimer().start();
tsRecentJMFromJNI = JavaMethods_[JM_HDFS_CREATE].jm_full_name;
jboolean jresult = jenv_->CallBooleanMethod(javaObj_, JavaMethods_[JM_HDFS_CREATE].methodID, js_path, j_overwrite, j_compress);
if (hdfsStats_ != NULL) {
hdfsStats_->incMaxHdfsIOTime(hdfsStats_->getHdfsTimer().stop());
hdfsStats_->incHdfsCalls();
}
if (jenv_->ExceptionCheck())
{
getExceptionDetails();
logError(CAT_SQL_HDFS, __FILE__, __LINE__);
logError(CAT_SQL_HDFS, "HdfsClient::hdfsCreate()", getLastError());
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HDFS_CREATE_EXCEPTION;
}
if (jresult == false)
{
logError(CAT_SQL_HDFS, "HdfsClient::hdfsCreate()", getLastError());
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HDFS_CREATE_PARAM;
}
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_OK;
}
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;
}
_callable void removeProcess()
{
CliGlobals *cliGlobals = GetCliGlobals();
StatsGlobals *statsGlobals = cliGlobals->getStatsGlobals();
if (statsGlobals != NULL)
{
int error = statsGlobals->getStatsSemaphore(cliGlobals->getSemId(),
cliGlobals->myPin());
if (error == 0)
{
statsGlobals->removeProcess(cliGlobals->myPin());
statsGlobals->releaseStatsSemaphore(cliGlobals->getSemId(), cliGlobals->myPin());
statsGlobals->logProcessDeath(cliGlobals->myCpu(), cliGlobals->myPin(), "Normal process death");
}
else if (error == 4011)
{
// BINSEM_LOCK_ timed out. Halt the CPU
PROCESSOR_HALT_ (SQL_FS_INTERNAL_ERROR);
}
}
}
short ExExeUtilLongRunningTcb::finalizeDoLongRunning()
{
// Close the statements
Lng32 rc = cliInterface()->prepareAndExecRowsEpilogue();
NADELETE(initialOutputVarPtrList_, Queue, getHeap());
NADELETE(continuingOutputVarPtrList_, Queue, getHeap());
NADELETEBASIC(lruStmtAndPartInfo_, getHeap());
NADELETEBASIC(lruStmtWithCKAndPartInfo_, getHeap());
// if this is an ESP, deallocate transaction
CliGlobals *cliGlobals = GetCliGlobals();
if (cliGlobals->isESPProcess())
{
NADELETEBASIC(currTransaction_, getHeap());
currTransaction_ = NULL;
}
return 0;
}
Int32 HdfsClient::hdfsRead(const char* data, Int64 len, HDFS_Client_RetCode &hdfsClientRetcode)
{
QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsWrite(%ld) called.", len);
if (initJNIEnv() != JOI_OK) {
hdfsClientRetcode = HDFS_CLIENT_ERROR_HDFS_READ_EXCEPTION;
return 0;
}
jobject j_buf = jenv_->NewDirectByteBuffer((BYTE *)data, len);
if (j_buf == NULL) {
GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_READ_PARAM));
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HDFS_READ_PARAM;
}
if (hdfsStats_ != NULL)
hdfsStats_->getHdfsTimer().start();
tsRecentJMFromJNI = JavaMethods_[JM_HDFS_READ].jm_full_name;
jint bytesRead = 0;
bytesRead = jenv_->CallIntMethod(javaObj_, JavaMethods_[JM_HDFS_READ].methodID, j_buf);
if (hdfsStats_ != NULL) {
hdfsStats_->incMaxHdfsIOTime(hdfsStats_->getHdfsTimer().stop());
hdfsStats_->incHdfsCalls();
}
if (jenv_->ExceptionCheck())
{
getExceptionDetails();
logError(CAT_SQL_HDFS, __FILE__, __LINE__);
logError(CAT_SQL_HDFS, "HdfsClient::hdfsRead()", getLastError());
jenv_->PopLocalFrame(NULL);
hdfsClientRetcode = HDFS_CLIENT_ERROR_HDFS_READ_EXCEPTION;
return 0;
}
jenv_->PopLocalFrame(NULL);
hdfsClientRetcode = HDFS_CLIENT_OK;
return bytesRead;
}
HDFS_Client_RetCode HdfsClient::getHiveTableMaxModificationTs( Int64& maxModificationTs, const char * tableDirPaths, int levelDeep)
{
QRLogger::log(CAT_SQL_HBASE, LL_DEBUG, "Enter HDFSClient_JNI::getHiveTableMaxModificationTs(%s) called.",tableDirPaths);
if (initJNIEnv() != JOI_OK)
return HDFS_CLIENT_ERROR_HIVE_TBL_MAX_MODIFICATION_TS_PARAM;
if (getInstance() == NULL)
return HDFS_CLIENT_ERROR_HIVE_TBL_MAX_MODIFICATION_TS_PARAM;
jstring js_tableDirPaths = jenv_->NewStringUTF(tableDirPaths);
if (js_tableDirPaths == NULL)
{
GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HIVE_TBL_MAX_MODIFICATION_TS_PARAM));
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HIVE_TBL_MAX_MODIFICATION_TS_PARAM;
}
jint jlevelDeep = levelDeep;
tsRecentJMFromJNI = JavaMethods_[JM_HIVE_TBL_MAX_MODIFICATION_TS].jm_full_name;
jlong jresult = jenv_->CallStaticLongMethod(javaClass_,
JavaMethods_[JM_HIVE_TBL_MAX_MODIFICATION_TS].methodID,
js_tableDirPaths, jlevelDeep);
jenv_->DeleteLocalRef(js_tableDirPaths);
if (jenv_->ExceptionCheck())
{
getExceptionDetails(jenv_);
logError(CAT_SQL_HBASE, __FILE__, __LINE__);
logError(CAT_SQL_HBASE, "HDFSClientI::getHiveTableMaxModificationTs()", getLastError());
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_ERROR_HIVE_TBL_MAX_MODIFICATION_TS_EXCEPTION;
}
QRLogger::log(CAT_SQL_HBASE, LL_DEBUG,
"Exit HDFSClient_JNI::getHiveTableMaxModificationTs() called.");
maxModificationTs = jresult;
jenv_->PopLocalFrame(NULL);
return HDFS_CLIENT_OK;
}
NABoolean JavaObjectInterface::getExceptionDetails(JNIEnv *jenv)
{
NAString error_msg(heap_);
if (jenv == NULL)
jenv = jenv_;
CliGlobals *cliGlobals = GetCliGlobals();
if (jenv == NULL)
{
error_msg = "Internal Error - Unable to obtain jenv";
cli_globals->setJniErrorStr(error_msg);
return FALSE;
}
if (gThrowableClass == NULL)
{
jenv->ExceptionDescribe();
error_msg = "Internal Error - Unable to find Throwable class";
cli_globals->setJniErrorStr(error_msg);
return FALSE;
}
jthrowable a_exception = jenv->ExceptionOccurred();
if (a_exception != NULL)
jenv->ExceptionClear();
else
{
error_msg = "No java exception was thrown";
cli_globals->setJniErrorStr(error_msg);
return FALSE;
}
jstring msg_obj =
(jstring) jenv->CallObjectMethod(a_exception,
gThrowableToStringMethodID);
const char *msg_str;
if (msg_obj != NULL)
{
msg_str = jenv->GetStringUTFChars(msg_obj, 0);
// Start the error message in a new line
error_msg = "\n";
error_msg += msg_str;
jenv->ReleaseStringUTFChars(msg_obj, msg_str);
jenv->DeleteLocalRef(msg_obj);
}
else
msg_str = "Exception is thrown, but tostring is null";
// Get the stack trace
jobjectArray frames =
(jobjectArray) jenv->CallObjectMethod(
a_exception,
gGetStackTraceMethodID);
if (frames == NULL)
{
cli_globals->setJniErrorStr(error_msg);
return TRUE;
}
jsize frames_length = jenv->GetArrayLength(frames);
jsize i = 0;
for (i = 0; i < frames_length; i++)
{
jobject frame = jenv->GetObjectArrayElement(frames, i);
msg_obj = (jstring) jenv->CallObjectMethod(frame,
gStackFrameToStringMethodID);
if (msg_obj != NULL)
{
msg_str = jenv->GetStringUTFChars(msg_obj, 0);
error_msg += "\n";
error_msg += msg_str;
jenv->ReleaseStringUTFChars(msg_obj, msg_str);
jenv->DeleteLocalRef(msg_obj);
jenv->DeleteLocalRef(frame);
}
}
error_msg += "\n";
cli_globals->setJniErrorStr(error_msg);
return TRUE;
}
JOI_RetCode JavaObjectInterface::initJVM()
{
jint result;
if (jvm_ == NULL)
{
jsize jvm_count = 0;
// Is there an existing JVM already created?
result = JNI_GetCreatedJavaVMs (&jvm_, 1, &jvm_count);
if (result != JNI_OK)
{
GetCliGlobals()->setJniErrorStr(getErrorText(JOI_ERROR_CHECK_JVM));
return JOI_ERROR_CHECK_JVM;
}
if (jvm_count == 0)
{
// No - create a new one.
result = createJVM();
if (result != JNI_OK)
{
GetCliGlobals()->setJniErrorStr(getErrorText(JOI_ERROR_CHECK_JVM));
return JOI_ERROR_CREATE_JVM;
}
needToDetach_ = false;
QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_DEBUG, "Created a new JVM.");
}
char *jniHandleCapacityStr = getenv("TRAF_JNIHANDLE_CAPACITY");
if (jniHandleCapacityStr != NULL)
jniHandleCapacity_ = atoi(jniHandleCapacityStr);
if (jniHandleCapacity_ == 0)
jniHandleCapacity_ = TRAF_DEFAULT_JNIHANDLE_CAPACITY;
}
if (jenv_ == NULL)
{
// We found a JVM, can we use it?
result = jvm_->GetEnv((void**) &jenv_, JNI_VERSION_1_6);
switch (result)
{
case JNI_OK:
QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_DEBUG, "Attached to an existing JVM.");
break;
case JNI_EDETACHED:
result = jvm_->AttachCurrentThread((void**) &jenv_, NULL);
if (result != JNI_OK)
return JOI_ERROR_ATTACH_JVM;
needToDetach_ = true;
QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_DEBUG, "Attached to an existing JVM from another thread.");
break;
case JNI_EVERSION:
QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_DEBUG, "Attaching to a JVM of the wrong version.");
GetCliGlobals()->setJniErrorStr(getErrorText(JOI_ERROR_JVM_VERSION));
return JOI_ERROR_JVM_VERSION;
break;
default:
QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_DEBUG, "Unknown error Attaching to an existing JVM.");
GetCliGlobals()->setJniErrorStr(getErrorText(JOI_ERROR_ATTACH_JVM));
return JOI_ERROR_ATTACH_JVM;
break;
}
}
jclass lJavaClass;
if (gThrowableClass == NULL)
{
lJavaClass = jenv_->FindClass("java/lang/Throwable");
if (lJavaClass != NULL)
{
gThrowableClass = (jclass)jenv_->NewGlobalRef(lJavaClass);
jenv_->DeleteLocalRef(lJavaClass);
gGetStackTraceMethodID = jenv_->GetMethodID(gThrowableClass,
"getStackTrace",
"()[Ljava/lang/StackTraceElement;");
gThrowableToStringMethodID = jenv_->GetMethodID(gThrowableClass,
"toString",
"()Ljava/lang/String;");
}
}
if (gStackTraceClass == NULL)
{
lJavaClass = (jclass)jenv_->FindClass("java/lang/StackTraceElement");
if (lJavaClass != NULL)
{
gStackTraceClass = (jclass)jenv_->NewGlobalRef(lJavaClass);
jenv_->DeleteLocalRef(lJavaClass);
gStackFrameToStringMethodID = jenv_->GetMethodID(gStackTraceClass,
"toString",
"()Ljava/lang/String;");
}
}
return JOI_OK;
}
//////////////////////////////////////////////////////////////////////////////
// Create a new JVM instance.
//////////////////////////////////////////////////////////////////////////////
int JavaObjectInterface::createJVM()
{
JavaVMInitArgs jvm_args;
JavaVMOption jvm_options[MAX_NO_JVM_OPTIONS];
char* classPathArg = buildClassPath();
int numJVMOptions = 0;
jvm_options[numJVMOptions].optionString = classPathArg;
QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_DEBUG, "Using classpath: %s",
jvm_options[numJVMOptions].optionString);
numJVMOptions++;
char maxHeapOptions[64];
bool passMaxHeapToJVM = true;
int maxHeapEnvvarMB = DEFAULT_JVM_MAX_HEAP_SIZE;
const char *maxHeapSizeStr = getenv("JVM_MAX_HEAP_SIZE_MB");
if (maxHeapSizeStr)
{
maxHeapEnvvarMB = atoi(maxHeapSizeStr);
if (maxHeapEnvvarMB <= 0)
passMaxHeapToJVM = false;
}
if (passMaxHeapToJVM)
{
sprintf(maxHeapOptions, "-Xmx%dm", maxHeapEnvvarMB);
jvm_options[numJVMOptions].optionString = maxHeapOptions;
QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_DEBUG,
"Max heap option: %s",
jvm_options[numJVMOptions].optionString);
numJVMOptions++;
}
char initHeapOptions[64];
const char *initHeapSizeStr = getenv("JVM_INIT_HEAP_SIZE_MB");
if (initHeapSizeStr)
{
const int initHeapEnvvarMB = atoi(initHeapSizeStr);
if (initHeapEnvvarMB > 0)
{
sprintf(initHeapOptions, "-Xms%dm", initHeapEnvvarMB);
jvm_options[numJVMOptions].optionString = initHeapOptions;
QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_DEBUG,
"Init heap option: %s",
jvm_options[numJVMOptions].optionString);
numJVMOptions++;
}
}
int debugPort = 0;
const char *debugPortStr = getenv("JVM_DEBUG_PORT");
if (debugPortStr != NULL)
debugPort = atoi(debugPortStr);
if (debugPort > 0
#ifdef NDEBUG
// in a release build, only DB__ROOT can debug a process
&& ComUser::isRootUserID()
#endif
)
{
const char *debugTimeoutStr = getenv("JVM_DEBUG_TIMEOUT");
if (debugTimeoutStr != NULL)
debugTimeout_ = atoi(debugTimeoutStr);
const char *suspendOnDebug = getenv("JVM_SUSPEND_ON_DEBUG");
char debugOptions[300];
debugPort_ = debugPort;
// to allow debugging multiple processes at the same time,
// specify a port that is a multiple of 1000 and the code will
// add pid mod 1000 to the port number to use
if (debugPort_ % 1000 == 0)
debugPort_ += (GetCliGlobals()->myPin() % 1000);
sprintf(debugOptions,"-agentlib:jdwp=transport=dt_socket,address=%d,server=y,timeout=%d",
debugPort_, debugTimeout_);
if (suspendOnDebug != NULL)
strcat(debugOptions, ",suspend=y");
else
strcat(debugOptions, ",suspend=n");
jvm_options[numJVMOptions].optionString = debugOptions;
QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_WARN,
"Debugging JVM with options: %s",
jvm_options[numJVMOptions].optionString);
numJVMOptions++;
}
const char *oomOption = "-XX:+HeapDumpOnOutOfMemoryError";
jvm_options[numJVMOptions].optionString = (char *)oomOption;
numJVMOptions++;
char *mySqRoot = getenv("MY_SQROOT");
int len;
char *oomDumpDir = NULL;
if (mySqRoot != NULL)
{
len = strlen(mySqRoot);
oomDumpDir = new (heap_) char[len+50];
strcpy(oomDumpDir, "-XX:HeapDumpPath=");
strcat(oomDumpDir, mySqRoot);
strcat(oomDumpDir, "/logs");
jvm_options[numJVMOptions].optionString = (char *)oomDumpDir;
numJVMOptions++;
}
jvm_args.version = JNI_VERSION_1_6;
jvm_args.options = jvm_options;
jvm_args.nOptions = numJVMOptions;
jvm_args.ignoreUnrecognized = 1;
int ret = JNI_CreateJavaVM(&jvm_, (void**)&jenv_, &jvm_args);
free(classPathArg);
return ret;
}
// Code that does SEGMENT_REVEAL_ appears in three places:
// switchToPriv() in cli/CliLayerForNsk.cpp
// QfoRevealSegs() in QuasiFileManager.cpp
// stopCatcher() in cli/CliLayerForNsk.cpp
short QfoRevealSegs(CliGlobals *&cliGlobals)
{
cliGlobals = GetCliGlobals();
cliGlobals->incrNumOfCliCalls();
return 0;
}
