//---------------------------------------------------------------------- // Name : sortReceive // // Parameters : ... // // Description : // // Return Value : // SORT_SUCCESS if everything goes on well. // SORT_FAILURE if any error encounterd. // //---------------------------------------------------------------------- Lng32 SortUtil::sortReceive(void*& record,ULng32& len,void*& tupp) { NABoolean status; status = sortAlgo_->sortReceive(record, len, tupp); if ((len == 0) && (!config_->partialSort_)) { if(scratch_) { ScratchFileMap* tempFilesMap; tempFilesMap = scratch_->getScrFilesMap(); //stats_.scrNumReads_ = tempFilesMap->totalNumOfReads(); //stats_.scrNumAwaitio_ = tempFilesMap->totalNumOfAwaitio(); scratch_->getTotalIoWaitTime(stats_.ioWaitTime_); } stats_.numCompares_ += sortAlgo_->getNumOfCompares(); Int64 currentTimeJ = NA_JulianTimestamp(); stats_.elapsedTime_ = currentTimeJ - stats_.beginSortTime_; if (config_->logInfoEvent()) { char msg[500]; str_sprintf(msg, "Sort elapsed time : %Ld; Num runs : %d; runsize :%d", stats_.elapsedTime_,stats_.numInitRuns_,sortAlgo_->getRunSize()); SQLMXLoggingArea::logExecRtInfo(NULL, 0,msg, explainNodeId_); } } return status; }
void CompilationStatsData :: translateToExternalFormat(SQL_COMPILATION_STATS_DATA *query_cmp_data) { query_cmp_data->compileStartTime = compileStartTime(); query_cmp_data->compileEndTime = compileEndTime(); if ( query_cmp_data->compileEndTime == 0) { query_cmp_data->compileEndTime = NA_ConvertTimestamp(NA_JulianTimestamp()) ; } str_cpy_all(query_cmp_data->compilerId, compilerId(), COMPILER_ID_LEN); query_cmp_data->cmpCpuTotal = cmpCpuTotal(); query_cmp_data->cmpCpuBinder = cmpCpuBinder(); query_cmp_data->cmpCpuNormalizer = cmpCpuNormalizer(); query_cmp_data->cmpCpuAnalyzer = cmpCpuAnalyzer(); query_cmp_data->cmpCpuOptimizer = cmpCpuOptimizer(); query_cmp_data->cmpCpuGenerator = cmpCpuGenerator(); query_cmp_data->metadataCacheHits = metadataCacheHits(); query_cmp_data->metadataCacheLookups = metadataCacheLookups(); query_cmp_data->queryCacheState = queryCacheState(); query_cmp_data->histogramCacheHits = histogramCacheHits(); query_cmp_data->histogramCacheLookups = histogramCacheLookups(); query_cmp_data->stmtHeapSize = stmtHeapSize(); }
void MdamIntervalList::logEvent(const Lng32 functionId, const Lng32 intervalCount, const Int64 otherListId, const Lng32 callerTag) const { Int64 eventTimestamp = NA_JulianTimestamp(); printf(" %I64i %I64i %li %li %I64i %li\n", eventTimestamp, intervalListId_, functionId, intervalCount, otherListId, callerTag); }
short ExExeUtilTcb::executeQuery(char * task, char * object, char * query, NABoolean displayStartTime, NABoolean displayEndTime, short &rc, short * warning, Lng32 * ec, NABoolean moveErrorRow, NABoolean continueOnError, NABoolean monitorThis) { short retcode = 0; char buf[BUFFER_SIZE]; while (1) { switch (pqStep_) { case PROLOGUE_: { warning_ = 0; startTime_ = NA_JulianTimestamp(); elapsedTime_ = 0; if (displayStartTime) { getStatusString(task, "Started", object, buf); if (moveRowToUpQueue(buf, 0, &rc)) return 1; } pqStep_ = EXECUTE_; rc = WORK_RESCHEDULE_AND_RETURN; return 1; } break; case EXECUTE_: { retcode = cliInterface()->fetchRowsPrologue(query,FALSE,monitorThis); if (retcode < 0) { pqStep_ = ERROR_RETURN_; break; } pqStep_ = FETCH_ROW_; } break; case FETCH_ROW_: { retcode = (short)cliInterface()->fetch(); if (retcode < 0) { pqStep_ = ERROR_RETURN_; break; } if ((retcode > 0) && (retcode != 100)) warning_ = retcode; if ((retcode != 100) && (cliInterface()->outputBuf())) pqStep_ = RETURN_ROW_; else pqStep_ = CLOSE_; } break; case RETURN_ROW_: { char * ptr; Lng32 len; cliInterface()->getPtrAndLen(1, ptr, len); retcode = moveRowToUpQueue(ptr, len, &rc); if (retcode) return 1; pqStep_ = FETCH_ROW_; } break; case CLOSE_: { retcode = cliInterface()->fetchRowsEpilogue(""); if (retcode < 0) { pqStep_ = ERROR_RETURN_; break; } pqStep_ = EPILOGUE_; } break; case EPILOGUE_: { endTime_ = NA_JulianTimestamp(); elapsedTime_ = endTime_ - startTime_; if (displayEndTime) { char timeBuf[200]; getTimeAsString(elapsedTime_, timeBuf); getStatusString(task, "Ended", object, buf, timeBuf); if (moveRowToUpQueue(buf, 0, &rc)) return 1; } pqStep_ = ALL_DONE_; rc = WORK_RESCHEDULE_AND_RETURN; return 1; } break; case ERROR_RETURN_: { Lng32 sqlcode = 0; char * stringParam1 = NULL; Lng32 intParam1 = ComDiags_UnInitialized_Int; retcode = (short)cliInterface()->retrieveSQLDiagnostics(getDiagsArea()); if (moveErrorRow) { if (retcode == 0) { ComDiagsArea * da = getDiagsArea(); sqlcode = (short)da->mainSQLCODE(); ComCondition * cc; if (sqlcode < 0) cc = da->getErrorEntry(1); else cc = da->getWarningEntry(1); if (sqlcode < 0 && ec != NULL) *ec = sqlcode; if (cc->getOptionalStringCharSet(0) == CharInfo::ISO88591 || cc->getOptionalStringCharSet(0) == CharInfo::UTF8) stringParam1 = (char*)cc->getOptionalString(0); else stringParam1 = NULL; intParam1 = cc->getOptionalInteger(0); } else { sqlcode = retcode; } Lng32 errorBufLen = 200 + (stringParam1 ? strlen(stringParam1) : 0); char * errorBuf = new(getHeap()) char[errorBufLen]; str_sprintf(errorBuf, "%d", sqlcode); if (stringParam1) str_sprintf(&errorBuf[strlen(errorBuf)], ", %s", stringParam1); if (intParam1 != ComDiags_UnInitialized_Int) str_sprintf(&errorBuf[strlen(errorBuf)], ", %d", intParam1); char * outBuf = new(getHeap()) char[errorBufLen+400]; getStatusString(task, "Error", NULL, outBuf, NULL, NULL, errorBuf); NADELETEBASIC(errorBuf, getHeap()); if ((moveErrorRow) && (moveRowToUpQueue(outBuf, 0, &rc))) { NADELETEBASIC(outBuf, getHeap()); return 1; } NADELETEBASIC(outBuf, getHeap()); } // close cursor, etc. Ignore errors. cliInterface()->fetchRowsEpilogue(""); if (continueOnError) { pqStep_ = ALL_DONE_; rc = WORK_RESCHEDULE_AND_RETURN; return 1; } else { pqStep_ = PROLOGUE_; return -1; } } break; case ALL_DONE_: { pqStep_ = PROLOGUE_; if (warning) *warning = warning_; return 0; } break; } } }
ex_expr::exp_return_type ExpLOBiud::insertDesc(char *op_data[], CollHeap*h, ComDiagsArea** diagsArea) { Lng32 rc; Lng32 lobOperStatus = checkLobOperStatus(); if (lobOperStatus == DO_NOTHING_) return ex_expr::EXPR_OK; char * result = op_data[0]; // get the lob name where data need to be inserted char tgtLobNameBuf[100]; char * tgtLobName = ExpGetLOBname(objectUID_, lobNum(), tgtLobNameBuf, 100); if (tgtLobName == NULL) return ex_expr::EXPR_ERROR; // call function with the lobname and source value // to insert it in the LOB. // Get back offset and len of the LOB. Int64 descSyskey = 0; char * lobHandle = NULL; Lng32 handleLen = 0; char lobHandleBuf[LOB_HANDLE_LEN]; // if (getExeGlobals()->lobGlobals()->getCurrLobOperInProgress()) if (lobOperStatus == CHECK_STATUS_) { lobHandle = lobHandleSaved_; handleLen = lobHandleLenSaved_; } else { Int64 descTS = NA_JulianTimestamp(); lobHandle = lobHandleBuf; ExpLOBoper::genLOBhandle(objectUID_, lobNum(), (short)lobStorageType(), -1, descTS, -1, descSchNameLen_, descSchName(), handleLen, lobHandle); } LobsSubOper so = Lob_None; if (fromFile()) so = Lob_File; else if (fromString() || fromLoad()) so = Lob_Memory; else if (fromLob()) so = Lob_Foreign_Lob; else if (fromBuffer()) so = Lob_Buffer; Lng32 waitedOp = 0; #ifdef __EID waitedOp = 0; // nowaited op from EID/TSE process #else waitedOp = 1; #endif //temptemp. Remove after ExLobsOper adds nowaited support. waitedOp = 1; // temp. Pass lobLen. When ExLobsOper fixes it so len is not needed during // lob desc update, then remove this. Int64 lobLen = getOperand(1)->getLength(); blackBoxLen_ = 0; if (fromExternal()) { blackBoxLen_ = getOperand(1)->getLength(); str_cpy_and_null(blackBox_, op_data[1], (Lng32)blackBoxLen_, '\0', ' ', TRUE); } Lng32 cliError = 0; char * lobData = NULL; lobData= new(h) char[lobLen]; //send lobData only if it's a lob_file operation if (so == Lob_File) { str_cpy_and_null(lobData,op_data[1],lobLen,'\0',' ',TRUE); } if (so == Lob_Buffer) { memcpy(&lobLen, op_data[2],sizeof(Int64)); } LobsOper lo ; if (lobOperStatus == CHECK_STATUS_) lo = Lob_Check_Status; else if (lobHandle == NULL) lo = Lob_InsertDataSimple; else lo = Lob_InsertDesc; rc = ExpLOBInterfaceInsert (getExeGlobals()->lobGlobal(), tgtLobName, lobStorageLocation(), lobStorageType(), getLobHdfsServer(), getLobHdfsPort(), handleLen, lobHandle, &outHandleLen_, outLobHandle_, blackBoxLen_, blackBox_, requestTag_, getExeGlobals()->lobGlobals()->xnId(), descSyskey, lo, &cliError, so, waitedOp, lobData, lobLen, getLobMaxSize(), getLobMaxChunkMemSize(),getLobGCLimit()); if (rc == LOB_ACCESS_PREEMPT) { // save the handle so it could be used after return from preempt lobHandleLenSaved_ = handleLen; str_cpy_all(lobHandleSaved_, lobHandle, handleLen); return ex_expr::EXPR_PREEMPT; } if (rc < 0) { Lng32 intParam1 = -rc; ExRaiseSqlError(h, diagsArea, (ExeErrorCode)(8442), NULL, &intParam1, &cliError, NULL, (char*)"ExpLOBInterfaceInsert", getLobErrStr(intParam1)); return ex_expr::EXPR_ERROR; } // extract and update lob handle with the returned values if (outHandleLen_ > 0) { ExpLOBoper::extractFromLOBhandle(NULL, NULL, NULL, NULL, &descSyskey, NULL, NULL, NULL, outLobHandle_); ExpLOBoper::updLOBhandle(descSyskey, 0, lobHandle); } str_cpy_all(result, lobHandle, handleLen); getOperand(0)->setVarLength(handleLen, op_data[-MAX_OPERANDS]); if (NOT fromExternal()) { getExeGlobals()->lobGlobals()->lobLoadInfo()-> setLobHandle(lobNum(), handleLen, lobHandle); } return ex_expr::EXPR_OK; }
// ***************************************************************************** // * * // * Function: CmpSeabaseDDL::addSchemaObject * // * * // * Inserts a schema object row into the OBJECTS table. * // * * // ***************************************************************************** // * * // * Parameters: * // * * // * <cliInterface> ExeCliInterface & In * // * is a reference to an Executor CLI interface handle. * // * * // * <schemaName> const ComSchemaName & In * // * is a reference to a ComSchemaName instance. The catalog name must be * // * set. * // * * // * <schemaClass> ComSchemaClass In * // * is the class (private or shared) of the schema to be added. * // * * // * <ownerID> Int32 In * // * is the authorization ID that will own the schema. * // * * // * <ignoreIfExists> NABoolean In * // * do not return an error is schema already exists * // ***************************************************************************** // * * // * Returns: PrivStatus * // * * // * 0: Schema as added * // * -1: Schema was not added. A CLI error is put into the diags area. * // * * // ***************************************************************************** int CmpSeabaseDDL::addSchemaObject( ExeCliInterface & cliInterface, const ComSchemaName & schemaName, ComSchemaClass schemaClass, Int32 ownerID, NABoolean ignoreIfExists) { NAString catalogName = schemaName.getCatalogNamePartAsAnsiString(); ComAnsiNamePart schemaNameAsComAnsi = schemaName.getSchemaNamePart(); NAString schemaNamePart = schemaNameAsComAnsi.getInternalName(); ComObjectName objName(catalogName,schemaNamePart,NAString(SEABASE_SCHEMA_OBJECTNAME), COM_TABLE_NAME,TRUE); if (isSeabaseReservedSchema(objName) && !Get_SqlParser_Flags(INTERNAL_QUERY_FROM_EXEUTIL)) { *CmpCommon::diags() << DgSqlCode(-CAT_RESERVED_METADATA_SCHEMA_NAME) << DgSchemaName(schemaName.getExternalName().data()); return -1; } NAString objectNamePart = objName.getObjectNamePartAsAnsiString(TRUE); Lng32 retcode = existsInSeabaseMDTable(&cliInterface,catalogName,schemaNamePart, objectNamePart, COM_UNKNOWN_OBJECT, FALSE); if (retcode < 0) return -1; if (retcode == 1 ) // already exists { if (ignoreIfExists) return 0; else *CmpCommon::diags() << DgSqlCode(-CAT_SCHEMA_ALREADY_EXISTS) << DgSchemaName(schemaName.getExternalName().data()); return -1; } char buf[4000]; ComUID schemaUID; schemaUID.make_UID(); Int64 schemaObjectUID = schemaUID.get_value(); Int64 createTime = NA_JulianTimestamp(); NAString quotedSchName; NAString quotedObjName; ToQuotedString(quotedSchName,schemaNamePart,FALSE); ToQuotedString(quotedObjName,NAString(SEABASE_SCHEMA_OBJECTNAME),FALSE); char schemaObjectLit[3] = {0}; switch (schemaClass) { case COM_SCHEMA_CLASS_PRIVATE: { strncpy(schemaObjectLit,COM_PRIVATE_SCHEMA_OBJECT_LIT,2); break; } case COM_SCHEMA_CLASS_SHARED: { strncpy(schemaObjectLit,COM_SHARED_SCHEMA_OBJECT_LIT,2); break; } case COM_SCHEMA_CLASS_DEFAULT: default: { // Schemas are private by default, but could choose a different // default class here based on CQD or other attribute. strncpy(schemaObjectLit,COM_PRIVATE_SCHEMA_OBJECT_LIT,2); break; } } str_sprintf(buf, "insert into %s.\"%s\".%s values ('%s', '%s', '%s', '%s', %Ld, %Ld, %Ld, '%s', '%s', %d, %d, 0)", getSystemCatalog(),SEABASE_MD_SCHEMA,SEABASE_OBJECTS, catalogName.data(), quotedSchName.data(), quotedObjName.data(), schemaObjectLit, schemaObjectUID, createTime, createTime, COM_YES_LIT, // valid_def COM_NO_LIT, // droppable ownerID,ownerID); Int32 cliRC = cliInterface.executeImmediate(buf); if (cliRC < 0) { cliInterface.retrieveSQLDiagnostics(CmpCommon::diags()); return -1; } return 0; }
MdamIntervalList::MdamIntervalList(const Lng32 callerTag) : firstIntervalPtr_(0), lastIntervalPtr_(0), intervalListId_(NA_JulianTimestamp()) { logEvent(5,0,-1,callerTag); }
// ---------------------------------------------------------------------------- // Method: registerUser // // registers a user in the Trafodion metadata // // Input: parse tree containing a definition of the user // Output: the global diags area is set up with the result // ---------------------------------------------------------------------------- void CmpSeabaseDDLuser::registerUser(StmtDDLRegisterUser * pNode) { // Set up a global try/catch loop to catch unexpected errors try { // Verify user is authorized verifyAuthority(); // Verify that the specified user name is not reserved // TBD - add the isCatman concept if (isAuthNameReserved(pNode->getDbUserName())) { *CmpCommon::diags() << DgSqlCode (-CAT_AUTH_NAME_RESERVED) << DgString0(pNode->getDbUserName().data()); DDLException excp (CAT_AUTH_NAME_RESERVED, NULL, 0); excp.throwException(); } // set up class members from parse node setAuthDbName(pNode->getDbUserName()); setAuthExtName(pNode->getExternalUserName()); setAuthImmutable(pNode->isImmutable()); setAuthType(COM_USER_CLASS); // we are a user setAuthValid(true); // assume a valid user Int64 createTime = NA_JulianTimestamp(); setAuthCreateTime(createTime); setAuthRedefTime(createTime); // make redef time the same as create time // Make sure db user has not already been registered if (authExists()) { *CmpCommon::diags() << DgSqlCode(-CAT_AUTHID_ALREADY_EXISTS) << DgString0(getAuthDbName().data()); DDLException excp (CAT_AUTHID_ALREADY_EXISTS, NULL, 0); excp.throwException(); } // Make sure external user has not already been registered if (authExists(true)) { *CmpCommon::diags() << DgSqlCode(-CAT_LDAP_USER_ALREADY_EXISTS) << DgString0(getAuthExtName().data()); DDLException excp (CAT_LDAP_USER_ALREADY_EXISTS, NULL, 0); excp.throwException(); } DBUserAuth::AuthenticationConfiguration configurationNumber = DBUserAuth::DefaultConfiguration; DBUserAuth::AuthenticationConfiguration foundConfigurationNumber = DBUserAuth::DefaultConfiguration; if (!validateExternalUsername(pNode->getExternalUserName().data(), configurationNumber, foundConfigurationNumber)) return; // Get a unique auth ID number // TBD - check a parserflag (or something) to add DB__ROOT Int32 userID = 0; if (getAuthDbName() == DB__ROOT) userID = SUPER_USER; else userID = getUniqueUserID(); setAuthID (userID); // If the BY clause was specified, then register the user on behalf of the // authorization ID specified in this clause. // Need to translate the creator name to its authID if (pNode->getOwner() == NULL) { // get effective user from the Context // TBD - replace this call with SQL_EXEC_ call Int32 *pUserID = GetCliGlobals()->currContext()->getDatabaseUserID(); setAuthCreator(*pUserID); } else { const NAString creatorName = pNode->getOwner()->getAuthorizationIdentifier(); // TBD: get the authID for the creatorName // TBD: verify creator can register users setAuthCreator(NA_UserIdDefault); } // Add the user to AUTHS table insertRow(); } catch (...) { // At this time, an error should be in the diags area. // If there is no error, set up an internal error Int32 numErrors = CmpCommon::diags()->getNumber(DgSqlCode::ERROR_); if (numErrors == 0) *CmpCommon::diags() << DgSqlCode (-CAT_INTERNAL_EXCEPTION_ERROR) << DgInt0(__LINE__) << DgString0("register user"); } }
ExWorkProcRetcode ExCancelTcb::work() { ExMasterStmtGlobals *masterGlobals = getGlobals()->castToExExeStmtGlobals()->castToExMasterStmtGlobals(); CliGlobals *cliGlobals = masterGlobals->getCliGlobals(); while ((qparent_.down->isEmpty() == FALSE) && (qparent_.up->isFull() == FALSE)) { ex_queue_entry *pentry_down = qparent_.down->getHeadEntry(); switch (step_) { case NOT_STARTED: { if (pentry_down->downState.request == ex_queue::GET_NOMORE) step_ = DONE; else { retryCount_ = 0; // Priv checking is done during compilation. To support // REVOKE, prevent a prepared CANCEL/SUSPEND/ACTIVATE // that was compiled more than 1 second ago from executing // by raising the 8734 error to force an AQR. Int64 microSecondsSinceCompile = NA_JulianTimestamp() - masterGlobals->getStatement()->getCompileEndTime(); if (microSecondsSinceCompile > 1000*1000) { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *diagsArea << DgSqlCode(-CLI_INVALID_QUERY_PRIVS); reportError(diagsArea); step_ = DONE; break; } // Figure out which MXSSMP broker to use. if (cancelTdb().getAction() == ComTdbCancel::CancelByPname) { int nid = -1; int rc = msg_mon_get_process_info(cancelTdb().getCancelPname(), &nid, &pid_); switch (rc) { case XZFIL_ERR_OK: cpu_ = (short) nid; break; case XZFIL_ERR_NOTFOUND: case XZFIL_ERR_BADNAME: case XZFIL_ERR_NOSUCHDEV: { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *diagsArea << DgSqlCode(-EXE_CANCEL_PROCESS_NOT_FOUND); *diagsArea << DgString0(cancelTdb().getCancelPname()); reportError(diagsArea); step_ = DONE; break; } default: { char buf[200]; str_sprintf(buf, "Unexpected error %d returned from " "msg_mon_get_process_info", rc); ex_assert(0, buf); } } if (step_ != NOT_STARTED) break; } else if (cancelTdb().getAction() == ComTdbCancel::CancelByNidPid) { cpu_ = (short) cancelTdb().getCancelNid(); pid_ = cancelTdb().getCancelPid(); // check that process exists, if not report error. char processName[MS_MON_MAX_PROCESS_NAME]; int rc = msg_mon_get_process_name(cpu_, pid_, processName); if (XZFIL_ERR_OK == rc) ; // good. nid & pid are valid. else { if ((XZFIL_ERR_NOTFOUND != rc) && (XZFIL_ERR_BADNAME != rc) && (XZFIL_ERR_NOSUCHDEV != rc)) { // Log rc in case it needs investigation later. char buf[200]; str_sprintf(buf, "Unexpected error %d returned from " "msg_mon_get_process_name", rc); SQLMXLoggingArea::logExecRtInfo(__FILE__, __LINE__, buf, 0); } char nid_pid_str[32]; str_sprintf(nid_pid_str, "%d, %d", cpu_, pid_); ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *diagsArea << DgSqlCode(-EXE_CANCEL_PROCESS_NOT_FOUND); *diagsArea << DgString0(nid_pid_str); reportError(diagsArea); step_ = DONE; break; } } else { char * qid = cancelTdb().qid_; Lng32 qid_len = str_len(qid); // This static method is defined in SqlStats.cpp. It side-effects // the nodeName and cpu_ according to the input qid. if (getMasterCpu( qid, qid_len, nodeName_, sizeof(nodeName_) - 1, cpu_) == -1) { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *diagsArea << DgSqlCode(-EXE_RTS_INVALID_QID); reportError(diagsArea); step_ = DONE; break; } } // Testpoints for hard to reproduce problems: bool fakeError8028 = false; fakeError8028 = (getenv("HP_FAKE_ERROR_8028") != NULL); if ((cliGlobals->getCbServerClass() == NULL) || fakeError8028) { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *diagsArea << DgSqlCode(-EXE_CANCEL_PROCESS_NOT_FOUND); *diagsArea << DgString0("$ZSM000"); reportError(diagsArea); step_ = DONE; break; } ComDiagsArea *diagsArea = NULL; bool fakeError2024 = false; fakeError2024 = (getenv("HP_FAKE_ERROR_2024") != NULL); if (fakeError2024) { cbServer_ = NULL; diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); if (getenv("HP_FAKE_ERROR_8142")) { *diagsArea << DgSqlCode(-8142); *diagsArea << DgString0(__FILE__); *diagsArea << DgString1("cbServer_ is NULL"); } else *diagsArea << DgSqlCode(-2024); } else cbServer_ = cliGlobals->getCbServerClass()->allocateServerProcess( &diagsArea, cliGlobals->getEnvironment()->getHeap(), nodeName_, cpu_, IPC_PRIORITY_DONT_CARE, FALSE, // usesTransactions TRUE, // waitedCreation 2 // maxNowaitRequests -- cancel+(1 extra). ); if (cbServer_ == NULL || cbServer_->getControlConnection() == NULL) { ex_assert(diagsArea != NULL, "allocateServerProcess failed, but no diags"); // look for SQLCode 2024 // "*** ERROR[2024] Server Process $0~string0 // is not running or could not be created. Operating System // Error $1~int0 was returned." // Remap to cancel-specfic error 8028. if (diagsArea->contains(-2024) && cancelTdb().actionIsCancel()) { diagsArea->deleteError(diagsArea->returnIndex(-2024)); reportError(diagsArea, true, EXE_CANCEL_PROCESS_NOT_FOUND, nodeName_, cpu_); } else reportError(diagsArea); step_ = DONE; break; } // the reportError method was not called -- see break above. if (diagsArea != NULL) diagsArea->decrRefCount(); //Create the stream on the IpcHeap, since we don't dispose // of it immediately. We just add it to the list of completed // messages in the IpcEnv, and it is disposed of later. cancelStream_ = new (cliGlobals->getIpcHeap()) CancelMsgStream(cliGlobals->getEnvironment(), this); cancelStream_->addRecipient(cbServer_->getControlConnection()); } step_ = SEND_MESSAGE; break; } // end case NOT_STARTED #pragma warning (disable : 4291) case SEND_MESSAGE: { RtsHandle rtsHandle = (RtsHandle) this; if (cancelTdb().actionIsCancel()) { Int64 cancelStartTime = JULIANTIMESTAMP(); Lng32 firstEscalationInterval = cliGlobals->currContext()-> getSessionDefaults()->getCancelEscalationInterval(); Lng32 secondEscalationInterval = cliGlobals->currContext()-> getSessionDefaults()->getCancelEscalationMxosrvrInterval(); NABoolean cancelEscalationSaveabend = cliGlobals->currContext()-> getSessionDefaults()->getCancelEscalationSaveabend(); bool cancelLogging = (TRUE == cliGlobals->currContext()-> getSessionDefaults()->getCancelLogging()); CancelQueryRequest *cancelMsg = new (cliGlobals->getIpcHeap()) CancelQueryRequest(rtsHandle, cliGlobals->getIpcHeap(), cancelStartTime, firstEscalationInterval, secondEscalationInterval, cancelEscalationSaveabend, cancelTdb().getCommentText(), str_len(cancelTdb().getCommentText()), cancelLogging, cancelTdb().action_ != ComTdbCancel::CancelByQid, pid_, cancelTdb().getCancelPidBlockThreshold()); #pragma warning (default : 4291) *cancelStream_ << *cancelMsg; cancelMsg->decrRefCount(); } else if (ComTdbCancel::Suspend == cancelTdb().action_) { bool suspendLogging = (TRUE == cliGlobals->currContext()-> getSessionDefaults()->getSuspendLogging()); #pragma warning (disable : 4291) SuspendQueryRequest * suspendMsg = new (cliGlobals->getIpcHeap()) SuspendQueryRequest(rtsHandle, cliGlobals->getIpcHeap(), ComTdbCancel::Force == cancelTdb().forced_, suspendLogging); #pragma warning (default : 4291) *cancelStream_ << *suspendMsg; suspendMsg->decrRefCount(); } else { ex_assert( ComTdbCancel::Activate == cancelTdb().action_, "invalid action for ExCancelTcb"); bool suspendLogging = (TRUE == cliGlobals->currContext()-> getSessionDefaults()->getSuspendLogging()); #pragma warning (disable : 4291) ActivateQueryRequest * activateMsg = new (cliGlobals->getIpcHeap()) ActivateQueryRequest(rtsHandle, cliGlobals->getIpcHeap(), suspendLogging); #pragma warning (default : 4291) *cancelStream_ << *activateMsg; activateMsg->decrRefCount(); } if ((cancelTdb().getAction() != ComTdbCancel::CancelByPname) && (cancelTdb().getAction() != ComTdbCancel::CancelByNidPid)) { char * qid = cancelTdb().qid_; Lng32 qid_len = str_len(qid); #pragma warning (disable : 4291) RtsQueryId *rtsQueryId = new (cliGlobals->getIpcHeap()) RtsQueryId( cliGlobals->getIpcHeap(), qid, qid_len); #pragma warning (default : 4291) *cancelStream_ << *rtsQueryId; rtsQueryId->decrRefCount(); } // send a no-wait request to the cancel broker. cancelStream_->send(FALSE); step_ = GET_REPLY; // Come back when I/O completes. return WORK_OK; break; } // end case SEND_MESSAGE case GET_REPLY: { // Handle general IPC error. bool fakeError201 = false; fakeError201 = (getenv("HP_FAKE_ERROR_201") != NULL); if ((cbServer_->getControlConnection()->getErrorInfo() != 0) || fakeError201) { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); cbServer_->getControlConnection()-> populateDiagsArea( diagsArea, getGlobals()->getDefaultHeap()); if (fakeError201) { *diagsArea << DgSqlCode(-2034) << DgInt0(201) << DgString0("I say") << DgString1("control broker"); } if (diagsArea->contains(-8921)) { // Should not get timeout error 8921. Get a core-file // of the SSMP and this process too so that this can be // debugged. cbServer_->getControlConnection()-> dumpAndStopOtherEnd(true, false); genLinuxCorefile("Unexpected timeout error"); } reportError(diagsArea); step_ = DONE; break; } // See if stream has the reply yet. if (!cancelStream_->moreObjects()) return WORK_OK; #pragma warning (disable : 4291) ControlQueryReply *reply = new (cliGlobals->getIpcHeap()) ControlQueryReply(INVALID_RTS_HANDLE, cliGlobals->getIpcHeap()); #pragma warning (default : 4291) *cancelStream_ >> *reply; if (reply->didAttemptControl()) { // yeaah! cancelStream_->clearAllObjects(); } else { if (cancelStream_->moreObjects() && cancelStream_->getNextObjType() == IPC_SQL_DIAG_AREA) { ComDiagsArea *diagsArea = ComDiagsArea::allocate(getGlobals()->getDefaultHeap()); *cancelStream_ >> *diagsArea; cancelStream_->clearAllObjects(); if ( retryQidNotActive_ && (diagsArea->mainSQLCODE() == -EXE_SUSPEND_QID_NOT_ACTIVE) && (++retryCount_ <= 60)) { SQLMXLoggingArea::logExecRtInfo(__FILE__, __LINE__, "Retrying error 8672.", 0); DELAY(500); diagsArea->decrRefCount(); step_ = SEND_MESSAGE; break; } reportError(diagsArea); } else ex_assert(0, "Control failed, but no diagnostics."); } step_ = DONE; break; } case DONE: { if (cancelStream_) { cancelStream_->addToCompletedList(); cancelStream_ = NULL; } if (cbServer_) { cbServer_->release(); cbServer_ = NULL; } ex_queue_entry * up_entry = qparent_.up->getTailEntry(); up_entry->copyAtp(pentry_down); up_entry->upState.parentIndex = pentry_down->downState.parentIndex; up_entry->upState.downIndex = qparent_.down->getHeadIndex(); up_entry->upState.setMatchNo(1); up_entry->upState.status = ex_queue::Q_NO_DATA; qparent_.up->insert(); qparent_.down->removeHead(); step_ = NOT_STARTED; break; } default: ex_assert( 0, "Unknown step_."); }