void addDllErrors(ComDiagsArea &diags,
const char *operation,
NABoolean isWarningOnly)
{
Int32 errorCode = 0;
Int32 errorDetail = 0;
char *errorString = (char *)"";
#ifndef LMCOMMON_CANNOT_CALL_DLOPEN
// dlresultcode() is not applicable to Linux
errorString = dlerror();
#endif
// Remove trailing period and linefeed characters from the message
// string
ComUInt32 msglen = 0;
while (errorString && (msglen = strlen(errorString)) > 0)
{
ComUInt32 idx = msglen - 1;
if (errorString[idx] == '\n' || errorString[idx] == '\r' ||
errorString[idx] == '.')
errorString[idx] = 0;
else
break;
}
diags << DgSqlCode((isWarningOnly ? LME_DLFCN_ERROR : -LME_DLFCN_ERROR))
<< DgString0(operation)
<< DgInt0(errorCode)
<< DgInt1(errorDetail)
<< DgString1(errorString);
}
short CmpSeabaseDDL::buildViewColInfo(StmtDDLCreateView * createViewParseNode,
ElemDDLColDefArray *colDefArray)
{
// Builds the list of ElemDDLColDef parse nodes from the list of
// NAType parse nodes derived from the query expression parse sub-tree
// and the list of ElemDDLColViewDef parse nodes from the parse tree.
// This extra step is needed to invoke (reuse) global func CatBuildColumnList.
CMPASSERT(createViewParseNode->getQueryExpression()->
getOperatorType() EQU REL_ROOT);
RelRoot * pQueryExpr = (RelRoot *)createViewParseNode->getQueryExpression();
const ValueIdList &valIdList = pQueryExpr->compExpr(); // select-list
CMPASSERT(valIdList.entries() > 0);
CollIndex numOfCols(createViewParseNode->getViewColDefArray().entries());
if (numOfCols NEQ valIdList.entries())
{
*CmpCommon::diags() << DgSqlCode(-1108) //CAT_NUM_OF_VIEW_COLS_NOT_MATCHED
<< DgInt0(numOfCols)
<< DgInt1(valIdList.entries());
return -1;
}
const ElemDDLColViewDefArray &viewColDefArray = createViewParseNode->
getViewColDefArray();
for (CollIndex i = 0; i < numOfCols; i++)
{
// ANSI 11.19 SR8
if (viewColDefArray[i]->getColumnName().isNull())
{
*CmpCommon::diags() << DgSqlCode(-1099) //CAT_VIEW_COLUMN_UNNAMED
<< DgInt0(i+1);
return -1;
}
colDefArray->insert(new (STMTHEAP) ElemDDLColDef
( viewColDefArray[i]->getColumnName()
, (NAType *)&valIdList[i].getType()
, NULL // default value (n/a for view def)
, NULL // col attr list (not needed)
, STMTHEAP));
if (viewColDefArray[i]->isHeadingSpecified())
{
(*colDefArray)[i]->setIsHeadingSpecified(TRUE);
(*colDefArray)[i]->setHeading(viewColDefArray[i]->getHeading());
}
}
return 0;
}
// ----------------------------------------------------------------------------
// static method: getAuthNameFromAuthID
//
// Converts the authorization ID into its corresponding database name
//
// authID - ID to convert
// authName - returned name
//
// returns:
// true - conversion successful
// false - conversion failed, ComDiags setup with error information
// ----------------------------------------------------------------------------
bool PrivMgr::getAuthNameFromAuthID(
const int32_t authID,
std::string &authName)
{
switch (authID)
{
case SYSTEM_AUTH_ID:
authName = SYSTEM_AUTH_NAME;
break;
case PUBLIC_AUTH_ID:
authName = PUBLIC_AUTH_NAME;
break;
case SUPER_USER:
authName = DB__ROOT;
break;
case DB_ROOTROLE_ID:
authName = DB_ROOTROLE_NAME;
break;
case HIVE_ROLE_ID:
authName = DB__HIVEROLE;
break;
case HBASE_ROLE_ID:
authName = DB__HBASEROLE;
break;
default:
{
int32_t length = 0;
char authNameFromMD[MAX_DBUSERNAME_LEN + 1];
Int16 retcode = ComUser::getAuthNameFromAuthID(authID,authNameFromMD,
MAX_DBUSERNAME_LEN,length);
if (retcode != 0)
{
*CmpCommon::diags() << DgSqlCode(-20235)
<< DgInt0(retcode)
<< DgInt1(authID);
return false;
}
authName = authNameFromMD;
}
}
return true;
}
// *****************************************************************************
// * *
// * Function: CmpSeabaseDDL::describeSchema *
// * *
// * Provides text for SHOWDDL SCHEMA comnmand. *
// * *
// *****************************************************************************
// * *
// * Parameters: *
// * *
// * <catalogName> const NAString & In *
// * is a reference to a catalog name. *
// * *
// * <schemaName> const NAString & In *
// * is a reference to a schema name. *
// * *
// * <output> NAString & Out *
// * passes back text for the SHOWDDL SCHEMA command, specifically the *
// * command to create the specified schema. *
// * *
// *****************************************************************************
// * *
// * Returns: bool *
// * *
// * true: Text returned for specified schema. *
// * false: Could not retrieve information for specified schema. *
// * *
// *****************************************************************************
bool CmpSeabaseDDL::describeSchema(
const NAString & catalogName,
const NAString & schemaName,
NAString & output)
{
ExeCliInterface cliInterface(STMTHEAP, NULL, NULL,
CmpCommon::context()->sqlSession()->getParentQid());
ComSchemaClass schemaClass;
Int32 objectOwner;
Int32 schemaOwner;
ComObjectType objectType;
CmpSeabaseDDL cmpSBD(STMTHEAP);
if (cmpSBD.switchCompiler())
{
*CmpCommon::diags() << DgSqlCode(-CAT_UNABLE_TO_RETRIEVE_PRIVS);
return false;
}
Int64 schemaUID = getObjectTypeandOwner(&cliInterface,
catalogName.data(),
schemaName.data(),
SEABASE_SCHEMA_OBJECTNAME,
objectType,
objectOwner);
if (schemaUID < 0)
{
*CmpCommon::diags() << DgSqlCode(-CAT_SCHEMA_DOES_NOT_EXIST_ERROR)
<< DgSchemaName(catalogName + "." + schemaName);
cmpSBD.switchBackCompiler();
return false;
}
char username[MAX_USERNAME_LEN+1];
Int32 lActualLen = 0;
Int16 status = ComUser::getAuthNameFromAuthID(objectOwner,username,
MAX_USERNAME_LEN,lActualLen);
if (status != FEOK)
{
*CmpCommon::diags() << DgSqlCode(-20235) // Error converting user ID.
<< DgInt0(status)
<< DgInt1(objectOwner);
cmpSBD.switchBackCompiler();
return false;
}
// Generate output text
output = "CREATE ";
switch (objectType)
{
case COM_PRIVATE_SCHEMA_OBJECT:
output += "PRIVATE";
break;
case COM_SHARED_SCHEMA_OBJECT:
output += "SHARED";
break;
default:
return false;
}
output += " SCHEMA \"";
output += catalogName.data();
output += "\".\"";
output += schemaName.data();
// AUTHORIZATION clause is rarely used, but include it for replay.
output += "\" AUTHORIZATION \"";
output += username;
output += "\";";
cmpSBD.switchBackCompiler();
return true;
}
//////////////////////////////////////////////////////
// work() for ExExeUtilLongRunningTcb
//////////////////////////////////////////////////////
short ExExeUtilLongRunningTcb::work()
{
short rc = 0;
Lng32 cliRC = 0;
Int64 rowsDeleted = 0;
Int64 transactions = 0;
// 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();
ExExeUtilPrivateState & pstate =
*((ExExeUtilPrivateState*) pentry_down->pstate);
// Get the globals stucture of the ESP if this is an ESP
ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
ExEspStmtGlobals *espGlob = exeGlob->castToExEspStmtGlobals();
Int32 espNum = 1;
// this is an ESP?
if (espGlob != NULL)
{
espNum = (Int32) espGlob->getMyInstanceNumber();
}
while (1)
{
switch (step_)
{
case INITIAL_:
{
step_ = LONG_RUNNING_;
}
break;
case LONG_RUNNING_:
{
rc = doLongRunning();
if ((rc < 0) || (rc == 100))
{
finalizeDoLongRunning();
if (rc <0)
step_ = ERROR_;
else // rc == 100 - done with all the transactions.
step_ = DONE_;
}
// continue in LONG_RUNNING_ state if (rc >= 0) - success and warning.
}
break;
case DONE_:
{
if (qparent_.up->isFull())
return WORK_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;
// before sending the Q_NO_DATA, send the rowcount as well thro'
// the diagsArea.
getDiagsArea()->setRowCount(getRowsDeleted());
ComDiagsArea *diagsArea = getDiagAreaFromUpQueueTail();
if (lrTdb().longRunningQueryPlan())
{
(*diagsArea) << DgSqlCode(8450)
<< DgString0((char*)exeUtilTdb().getTableName())
<< DgInt0(espNum)
<< DgInt1((Lng32)getTransactionCount());
}
// insert into parent
qparent_.up->insert();
//pstate.matches_ = 0;
// reset the parameters.
step_ = INITIAL_;
transactions_ = 0;
rowsDeleted_ = 0;
initial_ = 1;
// clear diags if any
if (getDiagsArea())
{
getDiagsArea()->clear();
}
qparent_.down->removeHead();
return WORK_OK;
}
break;
case ERROR_:
{
if (qparent_.up->isFull())
return WORK_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_SQLERROR;
// get rows deleted so far.
getDiagsArea()->setRowCount(getRowsDeleted());
ComDiagsArea *diagsArea = up_entry->getDiagsArea();
if (diagsArea == NULL)
diagsArea =
ComDiagsArea::allocate(this->getGlobals()->getDefaultHeap());
else
diagsArea->incrRefCount (); // setDiagsArea call below will decr ref count
if (getDiagsArea())
diagsArea->mergeAfter(*getDiagsArea());
up_entry->setDiagsArea (diagsArea);
// insert into parent
qparent_.up->insert();
// clear diags if any, since we already sent the information
// up and don't want to send it again as part of DONE_
if (getDiagsArea())
{
rowsDeleted_ = 0;
getDiagsArea()->clear();
}
step_ = DONE_;
}
break;
} // switch
} // while
}
Int32 ValidatePOSTableSizes::validate(const char *value,
const NADefaults *nad,
Int32 attrEnum,
Int32 errOrWarn,
float *) const
{
char tempStr[1000]; // max length of ATTR_VALUE
if ( strlen(value) == 0 ) return TRUE; // empty string ATTR_VALUE is OK
if ( strlen(value) > 1000 )
{
*CmpCommon::diags() << DgSqlCode(ERRWARN(2055))
<< DgString0(value)
<< DgString1(nad->lookupAttrName(attrEnum, errOrWarn));
return FALSE;
}
strcpy(tempStr, value);
const char *token, *sep = " ,";
token = strtok(tempStr, sep);
float initialSize = -1;
float maxSize = -1;
ValidateUInt uint;
if (token != NULL)
{
// check if the first value is an unsigned int
if (!uint.validate(token, nad, attrEnum, -1))
return FALSE;
else
{
sscanf(token, "%g", &initialSize);
token = strtok(NULL, sep);
if (token != NULL)
{
// check if the second value is an unsigned int
if (!uint.validate(token, nad, attrEnum, -1))
return FALSE;
else
{
// if there is a third value or max table size is smaller than
// initial table size raise an error
sscanf(token, "%g", &maxSize);
token = strtok(NULL, sep);
if (token != NULL || maxSize < initialSize)
{
*CmpCommon::diags() << DgSqlCode(ERRWARN(2055))
<< DgString0(value)
<< DgString1(nad->lookupAttrName(attrEnum, errOrWarn));
if (maxSize < initialSize)
{
*CmpCommon::diags() << DgSqlCode(ERRWARN(2077))
<< DgInt0((Lng32)maxSize)
<< DgInt1((Lng32)initialSize);
}
return FALSE;
}
}
}
}
}
else
{
*CmpCommon::diags() << DgSqlCode(ERRWARN(2055))
<< DgString0(value)
<< DgString1(nad->lookupAttrName(attrEnum, errOrWarn));
return FALSE;
}
return TRUE;
}
// -----------------------------------------------------------------------
// Method for creating NAType from desc_struct.
// -----------------------------------------------------------------------
NABoolean NAColumn::createNAType(columns_desc_struct *column_desc /*IN*/,
const NATable *table /*IN*/,
NAType *&type /*OUT*/,
NAMemory *heap /*IN*/,
Lng32 * errorCode
)
{
//
// Compute the NAType for this column
//
#define REC_INTERVAL REC_MIN_INTERVAL
DataType datatype = column_desc->datatype;
if (REC_MIN_INTERVAL <= datatype && datatype <= REC_MAX_INTERVAL)
datatype = REC_INTERVAL;
Lng32 charCount = column_desc->length;
if ( DFS2REC::isAnyCharacter(column_desc->datatype) )
{
if ( CharInfo::isCharSetSupported(column_desc->character_set) == FALSE ) {
if (!errorCode)
{
*CmpCommon::diags() << DgSqlCode(-4082)
<< DgTableName(makeTableName(table, column_desc));
}
else
{
*errorCode = 4082;
}
return TRUE; // error
}
if ( CharInfo::is_NCHAR_MP(column_desc->character_set) )
charCount /= SQL_DBCHAR_SIZE;
}
switch (datatype)
{
case REC_BPINT_UNSIGNED :
type = new (heap)
SQLBPInt(column_desc->precision, column_desc->null_flag, FALSE, heap);
break;
case REC_BIN8_SIGNED:
if (column_desc->precision > 0)
type = new (heap)
SQLNumeric(column_desc->length,
column_desc->precision,
column_desc->scale,
TRUE,
column_desc->null_flag,
heap
);
else
type = new (heap)
SQLTiny(TRUE,
column_desc->null_flag,
heap
);
break;
case REC_BIN8_UNSIGNED:
if (column_desc->precision > 0)
type = new (heap)
SQLNumeric(column_desc->length,
column_desc->precision,
column_desc->scale,
FALSE,
column_desc->null_flag,
heap
);
else
type = new (heap)
SQLTiny(FALSE,
column_desc->null_flag,
heap
);
break;
case REC_BIN16_SIGNED:
if (column_desc->precision > 0)
type = new (heap)
SQLNumeric(column_desc->length,
column_desc->precision,
column_desc->scale,
TRUE,
column_desc->null_flag,
heap
);
else
type = new (heap)
SQLSmall(TRUE,
column_desc->null_flag,
heap
);
break;
case REC_BIN16_UNSIGNED:
if (column_desc->precision > 0)
type = new (heap)
SQLNumeric(column_desc->length,
column_desc->precision,
column_desc->scale,
FALSE,
column_desc->null_flag,
heap
);
else
type = new (heap)
SQLSmall(FALSE,
column_desc->null_flag,
heap
);
break;
case REC_BIN32_SIGNED:
if (column_desc->precision > 0)
type = new (heap)
SQLNumeric(column_desc->length,
column_desc->precision,
column_desc->scale,
TRUE,
column_desc->null_flag,
heap
);
else
type = new (heap)
SQLInt(TRUE,
column_desc->null_flag,
heap
);
break;
case REC_BIN32_UNSIGNED:
if (column_desc->precision > 0)
type = new (heap)
SQLNumeric(column_desc->length,
column_desc->precision,
column_desc->scale,
FALSE,
column_desc->null_flag,
heap
);
else
type = new (heap)
SQLInt(FALSE,
column_desc->null_flag,
heap
);
break;
case REC_BIN64_SIGNED:
if (column_desc->precision > 0)
type = new (heap)
SQLNumeric(column_desc->length,
column_desc->precision,
column_desc->scale,
TRUE,
column_desc->null_flag,
heap
);
else
type = new (heap)
SQLLargeInt(TRUE,
column_desc->null_flag,
heap
);
break;
case REC_BIN64_UNSIGNED:
if (column_desc->precision > 0)
type = new (heap)
SQLNumeric(column_desc->length,
column_desc->precision,
column_desc->scale,
FALSE,
column_desc->null_flag,
heap
);
else
type = new (heap)
SQLLargeInt(FALSE,
column_desc->null_flag,
heap
);
break;
case REC_DECIMAL_UNSIGNED:
type = new (heap)
SQLDecimal(column_desc->length,
column_desc->scale,
FALSE,
column_desc->null_flag,
heap
);
break;
case REC_DECIMAL_LSE:
type = new (heap)
SQLDecimal(column_desc->length,
column_desc->scale,
TRUE,
column_desc->null_flag,
heap
);
break;
case REC_NUM_BIG_UNSIGNED:
type = new (heap)
SQLBigNum(column_desc->precision,
column_desc->scale,
TRUE, // is a real bignum
FALSE,
column_desc->null_flag,
heap
);
break;
case REC_NUM_BIG_SIGNED:
type = new (heap)
SQLBigNum(column_desc->precision,
column_desc->scale,
TRUE, // is a real bignum
TRUE,
column_desc->null_flag,
heap
);
break;
case REC_FLOAT32:
type = new (heap)
SQLReal(column_desc->null_flag, heap, column_desc->precision);
break;
case REC_FLOAT64:
type = new (heap)
SQLDoublePrecision(column_desc->null_flag, heap, column_desc->precision);
break;
case REC_BYTE_F_DOUBLE:
charCount /= SQL_DBCHAR_SIZE; // divide the storage length by 2
type = new (heap)
SQLChar(charCount,
column_desc->null_flag,
column_desc->upshift,
column_desc->caseinsensitive,
FALSE,
column_desc->character_set,
column_desc->collation_sequence,
CharInfo::IMPLICIT
);
break;
case REC_BYTE_F_ASCII:
if (column_desc->character_set == CharInfo::UTF8 ||
(column_desc->character_set == CharInfo::SJIS &&
column_desc->encoding_charset == CharInfo::SJIS))
{
Lng32 maxBytesPerChar = CharInfo::maxBytesPerChar(column_desc->character_set);
Lng32 sizeInChars = charCount ; // Applies when CharLenUnit == BYTES
if ( column_desc->precision > 0 )
sizeInChars = column_desc->precision;
type = new (heap)
SQLChar(CharLenInfo(sizeInChars, charCount/*in_bytes*/),
column_desc->null_flag,
column_desc->upshift,
column_desc->caseinsensitive,
FALSE, // varLenFlag
column_desc->character_set,
column_desc->collation_sequence,
CharInfo::IMPLICIT, // Coercibility
column_desc->encoding_charset
);
}
else // keep the old behavior
type = new (heap)
SQLChar(charCount,
column_desc->null_flag,
column_desc->upshift,
column_desc->caseinsensitive,
FALSE,
column_desc->character_set,
column_desc->collation_sequence,
CharInfo::IMPLICIT
);
break;
case REC_BYTE_V_DOUBLE:
charCount /= SQL_DBCHAR_SIZE; // divide the storage length by 2
// fall thru
case REC_BYTE_V_ASCII:
if (column_desc->character_set == CharInfo::SJIS ||
column_desc->character_set == CharInfo::UTF8)
{
Lng32 maxBytesPerChar = CharInfo::maxBytesPerChar(column_desc->character_set);
Lng32 sizeInChars = charCount ; // Applies when CharLenUnit == BYTES
if ( column_desc->precision > 0 )
sizeInChars = column_desc->precision;
type = new (heap)
SQLVarChar(CharLenInfo(sizeInChars, charCount/*in_bytes*/),
column_desc->null_flag,
column_desc->upshift,
column_desc->caseinsensitive,
column_desc->character_set,
column_desc->collation_sequence,
CharInfo::IMPLICIT, // Coercibility
column_desc->encoding_charset
);
}
else // keep the old behavior
type = new (heap)
SQLVarChar(charCount,
column_desc->null_flag,
column_desc->upshift,
column_desc->caseinsensitive,
column_desc->character_set,
column_desc->collation_sequence,
CharInfo::IMPLICIT
);
break;
case REC_BYTE_V_ASCII_LONG:
type = new (heap)
SQLLongVarChar(charCount,
FALSE,
column_desc->null_flag,
column_desc->upshift,
column_desc->caseinsensitive,
column_desc->character_set,
column_desc->collation_sequence,
CharInfo::IMPLICIT
);
break;
case REC_DATETIME:
type = DatetimeType::constructSubtype(
column_desc->null_flag,
column_desc->datetimestart,
column_desc->datetimeend,
column_desc->datetimefractprec,
heap
);
CMPASSERT(type);
if (!type->isSupportedType())
{
column_desc->defaultClass = COM_NO_DEFAULT; // can't set a default for these, either.
// 4030 Column is an unsupported combination of datetime fields
if (!errorCode)
{
*CmpCommon::diags() << DgSqlCode(4030)
<< DgColumnName(makeColumnName(table, column_desc))
<< DgInt0(column_desc->datetimestart)
<< DgInt1(column_desc->datetimeend)
<< DgInt2(column_desc->datetimefractprec);
}
else
{
*errorCode = 4030;
}
}
break;
case REC_INTERVAL:
type = new (heap)
SQLInterval(column_desc->null_flag,
column_desc->datetimestart,
column_desc->intervalleadingprec,
column_desc->datetimeend,
column_desc->datetimefractprec,
heap
);
CMPASSERT(type);
if (! ((SQLInterval *)type)->checkValid(CmpCommon::diags()))
return TRUE; // error
if (!type->isSupportedType())
{
column_desc->defaultClass = COM_NO_DEFAULT; // can't set a default for these, either.
if (!errorCode)
*CmpCommon::diags() << DgSqlCode(3044) << DgString0(column_desc->colname);
else
*errorCode = 3044;
}
break;
case REC_BLOB :
type = new (heap)
SQLBlob(column_desc->precision, Lob_Invalid_Storage,
column_desc->null_flag);
break;
case REC_CLOB :
type = new (heap)
SQLClob(column_desc->precision, Lob_Invalid_Storage,
column_desc->null_flag);
break;
default:
{
// 4031 Column %s is an unknown data type, %d.
if (!errorCode)
{
*CmpCommon::diags() << DgSqlCode(-4031)
<< DgColumnName(makeColumnName(table, column_desc))
<< DgInt0(column_desc->datatype);
}
else
{
*errorCode = 4031;
}
return TRUE; // error
}
} // end switch (column_desc->datatype)
CMPASSERT(type);
if (type->getTypeQualifier() == NA_CHARACTER_TYPE) {
CharInfo::Collation co = ((CharType *)type)->getCollation();
// a "mini-cache" to avoid proc call, for perf
static THREAD_P CharInfo::Collation cachedCO = CharInfo::UNKNOWN_COLLATION;
static THREAD_P Int32 cachedFlags = CollationInfo::ALL_NEGATIVE_SYNTAX_FLAGS;
if (cachedCO != co) {
cachedCO = co;
cachedFlags = CharInfo::getCollationFlags(co);
}
if (cachedFlags & CollationInfo::ALL_NEGATIVE_SYNTAX_FLAGS) {
//
//## The NCHAR/COLLATE NSK-Rel1 project is forced to disallow all user-
// defined collations here. What we can't handle is:
// - full support! knowledge of how to really collate!
// - safe predicate-ability of collated columns, namely
// . ORDER/SEQUENCE/SORT BY
// MIN/MAX
// < <= > >=
// These *would* have been disallowed by the
// CollationInfo::ORDERED_CMP_ILLEGAL flag.
// . DISTINCT
// GROUP BY
// = <>
// These *would* have been disallowed by the
// CollationInfo::EQ_NE_CMP_ILLEGAL flag.
// . SELECTing a collated column which is a table or index key
// We *would* have done full table scan only, based on flag
// . INS/UPD/DEL involving a collated column which is a key
// We *would* have had to disallow this, based on flag;
// otherwise we would position in wrong and corrupt either
// our partitioning or b-trees or both.
// See the "MPcollate.doc" document, and
// see sqlcomp/DefaultValidator.cpp ValidateCollationList comments.
//
{
// 4069 Column TBL.COL uses unsupported collation COLLAT.
if (!errorCode)
{
*CmpCommon::diags() << DgSqlCode(-4069)
<< DgColumnName(makeColumnName(table, column_desc));
}
else
{
*errorCode= 4069;
}
return TRUE; // error
}
}
}
return FALSE; // no error
} // createNAType()
void processALoadMessage(UdrGlobals *UdrGlob,
UdrServerReplyStream &msgStream,
UdrLoadMsg &request,
IpcEnvironment &env)
{
const char *moduleName = "processALoadMessage";
char errorText[MAXERRTEXT];
ComDiagsArea *diags = ComDiagsArea::allocate(UdrGlob->getIpcHeap());
doMessageBox(UdrGlob, TRACE_SHOW_DIALOGS,
UdrGlob->showLoad_, moduleName);
NABoolean showLoadLogic = (UdrGlob->verbose_ &&
UdrGlob->traceLevel_ >= TRACE_IPMS &&
UdrGlob->showLoad_);
if (showLoadLogic)
{
ServerDebug("[UdrServ (%s)] Processing load request", moduleName);
}
// UDR_LOAD message always comes with transaction and they are out
// side Enter Tx and Exit Tx pair. Make sure we are under correct
// transaction.
msgStream.activateCurrentMsgTransaction();
//
// Check to see if the incoming UDR handle has already been seen
//
NABoolean handleAlreadyExists = FALSE;
SPInfo *sp = UdrGlob->getSPList()->spFind(request.getHandle());
if (sp)
{
handleAlreadyExists = TRUE;
if (showLoadLogic)
{
ServerDebug(" Duplicate handle arrived");
ServerDebug(" SPInfoState is %s", sp->getSPInfoStateString());
}
if (sp->getSPInfoState() != SPInfo::UNLOADING)
{
//
// An SPInfo exists but it is not one of the token instances to
// represent an out-of-sequence LOAD/UNLOAD. This is an internal
// error. Something has been botched in the message protocol.
//
char buf[100];
convertInt64ToAscii(request.getHandle(), buf);
*diags << DgSqlCode(-UDR_ERR_DUPLICATE_LOADS);
*diags << DgString0(buf);
}
else
{
// The LOAD/UNLOAD requests for this handle arrived
// out-of-sequence. Nothing to do at this point. An empty reply
// will be generated later in this function.
}
}
if (!handleAlreadyExists)
{
if (!UdrHandleIsValid(request.getHandle()))
{
*diags << DgSqlCode(-UDR_ERR_MISSING_UDRHANDLE);
*diags << DgString0("Load Message");
}
else
{
//
// First process the metadata in the LOAD requests and then
// contact Language Manager to load the SP.
//
sp = processLoadParameters(UdrGlob, request, *diags);
if (showLoadLogic)
{
ServerDebug("[UdrServ (%s)] About to call LM::getRoutine",
moduleName);
}
if (sp == NULL)
{
*diags << DgSqlCode(-UDR_ERR_UNABLE_TO_ALLOCATE_MEMORY);
*diags << DgString0("SPInfo");
}
else
{
UdrGlob->setCurrSP(sp);
LmRoutine *lmRoutine;
LmResult lmResult;
LmLanguageManager *lm =
UdrGlob->getOrCreateLM(lmResult, sp->getLanguage(), diags);
LmHandle emitRowFuncPtr;
if (sp->getParamStyle() == COM_STYLE_CPP_OBJ)
emitRowFuncPtr = (LmHandle)&SpInfoEmitRowCpp;
else
emitRowFuncPtr = (LmHandle)&SpInfoEmitRow;
if (lm)
{
if (sp->getParamStyle() == COM_STYLE_JAVA_OBJ ||
sp->getParamStyle() == COM_STYLE_CPP_OBJ)
{
lmResult = lm->getObjRoutine(
request.getUDRSerInvocationInfo(),
request.getUDRSerInvocationInfoLen(),
request.getUDRSerPlanInfo(),
request.getUDRSerPlanInfoLen(),
sp->getLanguage(),
sp->getParamStyle(),
sp->getExternalName(),
sp->getContainerName(),
sp->getExternalPathName(),
sp->getLibrarySqlName(),
&lmRoutine,
diags);
if (lmRoutine)
{
LmRoutineCppObj *objRoutine =
static_cast<LmRoutineCppObj *>(lmRoutine);
if (sp->getParamStyle() == COM_STYLE_CPP_OBJ)
// set function pointers for functions provided
// by tdm_udrserv
objRoutine->setFunctionPtrs(SpInfoGetNextRow,
SpInfoEmitRowCpp);
// add items to the UDRInvocationInfo that are not
// known at compile time (total # of instances is
// kind of known, but we want to give the executor a
// chance to change it)
lmRoutine->setRuntimeInfo(request.getParentQid(),
request.getNumInstances(),
request.getInstanceNum());
#ifndef NDEBUG
int debugLoop = 2;
if (objRoutine->getInvocationInfo()->getDebugFlags() &
tmudr::UDRInvocationInfo::DEBUG_LOAD_MSG_LOOP)
debugLoop = 1;
// go into a loop to allow the user to attach a debugger,
// if requested, set debugLoop = 2 in the debugger to get out
while (debugLoop < 2)
debugLoop = 1-debugLoop;
#endif
}
}
else
lmResult = lm->getRoutine(sp->getNumParameters(),
sp->getLmParameters(),
sp->getNumTables(),
sp->getLmTables(),
sp->getReturnValue(),
sp->getParamStyle(),
sp->getTransactionAttrs(),
sp->getSQLAccessMode(),
sp->getParentQid(),
sp->getRequestRowSize(),
sp->getReplyRowSize(),
sp->getSqlName(),
sp->getExternalName(),
sp->getRoutineSig(),
sp->getContainerName(),
sp->getExternalPathName(),
sp->getLibrarySqlName(),
UdrGlob->getCurrentUserName(),
UdrGlob->getSessionUserName(),
sp->getExternalSecurity(),
sp->getRoutineOwnerId(),
&lmRoutine,
(LmHandle)&SpInfoGetNextRow,
emitRowFuncPtr,
sp->getMaxNumResultSets(),
diags);
}
if (lmResult == LM_OK)
{
if (lmRoutine == NULL)
{
*diags << DgSqlCode(-UDR_ERR_MISSING_LMROUTINE);
*diags << DgString0("error: returned a null LM handle");
*diags << DgInt1((Int32)0);
}
else
{
sp->setLMHandle(lmRoutine);
// Retrieve any optional data from UdrLoadMsg.
copyRoutineOptionalData(request, sp);
reportLoadResults(UdrGlob, sp, lmRoutine);
sp->setSPInfoState(SPInfo::LOADED);
}
} // lmResult == LM_OK
if (showLoadLogic)
{
if (lmResult == LM_OK)
{
sprintf(errorText,
"[UdrServ (%.30s)] LM::getRoutine was successful.",
moduleName);
}
else
{
sprintf(errorText,
"[UdrServ (%.30s)] LM::getRoutine resulted in error.",
moduleName);
}
ServerDebug(errorText);
doMessageBox(UdrGlob, TRACE_SHOW_DIALOGS,
UdrGlob->showMain_, errorText);
}
if (sp && !(sp->isLoaded()))
{
sp->setSPInfoState(SPInfo::LOAD_FAILED);
}
} // if (sp == NULL) else ...
} // if (handle is not valid) else ...
} // !handleAlreadyExists
// build a reply and send it
msgStream.clearAllObjects();
UdrLoadReply *reply = new (UdrGlob->getIpcHeap())
UdrLoadReply(UdrGlob->getIpcHeap());
if (reply == NULL)
{ // no reply buffer build...
controlErrorReply(UdrGlob, msgStream, UDR_ERR_MESSAGE_PROCESSING,
INVOKE_ERR_NO_REPLY_BUFFER, NULL);
return;
}
// Only return a valid UDR Handle if diagnostics are not present and
// no LM errors occurred. We also return a valid handle if this LOAD
// arrived out-of-sequence after the UNLOAD and no diagnostics have
// been generated yet.
if (diags && diags->getNumber() > 0)
{
reply->setHandle(INVALID_UDR_HANDLE);
}
else if (sp)
{
if (sp->isLoaded() || handleAlreadyExists)
{
reply->setHandle(sp->getUdrHandle());
}
else
{
reply->setHandle(INVALID_UDR_HANDLE);
}
}
msgStream << *reply;
if (diags && diags->getNumber() > 0)
{
msgStream << *diags;
UdrGlob->numErrUDR_++;
UdrGlob->numErrSP_++;
UdrGlob->numErrLoadSP_++;
if (showLoadLogic)
dumpDiagnostics(diags, 2);
}
if (showLoadLogic)
{
ServerDebug("[UdrServ (%s)] About to send LOAD reply", moduleName);
}
#ifdef NA_DEBUG_C_RUNTIME
if (UdrGlob && UdrGlob->getJavaLM())
{
sleepIfPropertySet(*(UdrGlob->getJavaLM()),
"MXUDR_LOAD_DELAY", diags);
}
#endif // NA_DEBUG_C_RUNTIME
sendControlReply(UdrGlob, msgStream, sp);
if (diags)
{
diags->decrRefCount();
}
reply->decrRefCount();
} // processALoadMessage
void CmpSeabaseDDL::createSeabaseView(
StmtDDLCreateView * createViewNode,
NAString &currCatName, NAString &currSchName)
{
Lng32 retcode = 0;
Lng32 cliRC = 0;
ComObjectName viewName(createViewNode->getViewName());
ComAnsiNamePart currCatAnsiName(currCatName);
ComAnsiNamePart currSchAnsiName(currSchName);
viewName.applyDefaults(currCatAnsiName, currSchAnsiName);
const NAString catalogNamePart = viewName.getCatalogNamePartAsAnsiString();
const NAString schemaNamePart = viewName.getSchemaNamePartAsAnsiString(TRUE);
const NAString objectNamePart = viewName.getObjectNamePartAsAnsiString(TRUE);
const NAString extViewName = viewName.getExternalName(TRUE);
const NAString extNameForHbase = catalogNamePart + "." + schemaNamePart + "." + objectNamePart;
ExeCliInterface cliInterface(STMTHEAP, NULL, NULL,
CmpCommon::context()->sqlSession()->getParentQid());
Int32 objectOwnerID = SUPER_USER;
Int32 schemaOwnerID = SUPER_USER;
ComSchemaClass schemaClass;
retcode = verifyDDLCreateOperationAuthorized(&cliInterface,
SQLOperation::CREATE_VIEW,
catalogNamePart,
schemaNamePart,
schemaClass,
objectOwnerID,
schemaOwnerID);
if (retcode != 0)
{
handleDDLCreateAuthorizationError(retcode,catalogNamePart,schemaNamePart);
return;
}
ExpHbaseInterface * ehi = NULL;
ehi = allocEHI();
if (ehi == NULL)
{
processReturn();
return;
}
if ((isSeabaseReservedSchema(viewName)) &&
(!Get_SqlParser_Flags(INTERNAL_QUERY_FROM_EXEUTIL)))
{
*CmpCommon::diags() << DgSqlCode(-1118)
<< DgTableName(extViewName);
deallocEHI(ehi);
return;
}
//if metadata views are being created and seabase is uninitialized, then this
//indicates that these views are being created during 'initialize trafodion'
//and this compiler contains stale version.
//Reload version info.
//
if ((isSeabaseMD(viewName)) &&
(CmpCommon::context()->isUninitializedSeabase()))
{
CmpCommon::context()->setIsUninitializedSeabase(FALSE);
CmpCommon::context()->uninitializedSeabaseErrNum() = 0;
}
retcode = existsInSeabaseMDTable(&cliInterface,
catalogNamePart, schemaNamePart, objectNamePart,
COM_UNKNOWN_OBJECT, FALSE, FALSE);
if (retcode < 0)
{
deallocEHI(ehi);
processReturn();
return;
}
if (retcode == 1) // already exists
{
if (NOT ((createViewNode->isCreateOrReplaceViewCascade())||
(createViewNode->isCreateOrReplaceView())))
{
*CmpCommon::diags() << DgSqlCode(-1390)
<< DgString0(extViewName);
deallocEHI(ehi);
processReturn();
return;
}
}
char * query = NULL;
int64_t objectUID = -1;
std::vector<ObjectPrivsRow> viewPrivsRows;
bool replacingView = false;
if ((retcode == 1) && // exists
((createViewNode->isCreateOrReplaceViewCascade())||
(createViewNode->isCreateOrReplaceView())))
{
// Replace view. Drop this view and recreate it.
Int32 objectOwnerID = 0;
Int32 schemaOwnerID = 0;
Int64 objUID = getObjectUIDandOwners(&cliInterface,
catalogNamePart.data(), schemaNamePart.data(),
objectNamePart.data(),
COM_VIEW_OBJECT,
objectOwnerID,schemaOwnerID);
if (objUID < 0 || objectOwnerID == 0)
{
if (CmpCommon::diags()->getNumber(DgSqlCode::ERROR_) == 0)
SEABASEDDL_INTERNAL_ERROR("getting object UID and owner for create or replace view");
deallocEHI(ehi);
processReturn();
return;
}
if (isAuthorizationEnabled())
{
// Verify user can perform operation
if (!isDDLOperationAuthorized(SQLOperation::ALTER_VIEW,objectOwnerID,schemaOwnerID))
{
*CmpCommon::diags() << DgSqlCode(-CAT_NOT_AUTHORIZED);
deallocEHI(ehi);
processReturn ();
return;
}
// Initiate the privilege manager interface class
NAString privMgrMDLoc;
CONCAT_CATSCH(privMgrMDLoc,getSystemCatalog(),SEABASE_PRIVMGR_SCHEMA);
PrivMgrCommands privInterface(std::string(privMgrMDLoc.data()),
CmpCommon::diags());
PrivStatus privStatus = privInterface.getPrivRowsForObject(objUID,viewPrivsRows);
if (privStatus != PrivStatus::STATUS_GOOD)
{
SEABASEDDL_INTERNAL_ERROR("Unable to retrieve privileges for replaced view");
deallocEHI(ehi);
processReturn();
return;
}
}
if (dropOneTableorView(cliInterface,extViewName.data(),COM_VIEW_OBJECT,false))
{
deallocEHI(ehi);
processReturn();
return;
}
replacingView = true;
}
// Gather the object and grantable privileges that the view creator has.
// This code also verifies that the current user has the necessary
// privileges to create the view.
PrivMgrBitmap privilegesBitmap;
PrivMgrBitmap grantableBitmap;
privilegesBitmap.set();
grantableBitmap.set();
if (gatherViewPrivileges(createViewNode,
&cliInterface,
privilegesBitmap,
grantableBitmap))
{
processReturn();
deallocEHI(ehi);
return;
}
NAString viewText(STMTHEAP);
buildViewText(createViewNode, viewText);
NAString newViewText(STMTHEAP);
for (Lng32 i = 0; i < viewText.length(); i++)
{
if (viewText.data()[i] == '\'')
newViewText += "''";
else
newViewText += viewText.data()[i];
}
ElemDDLColDefArray colDefArray(STMTHEAP);
if (buildViewColInfo(createViewNode, &colDefArray))
{
deallocEHI(ehi);
processReturn();
return;
}
Lng32 numCols = colDefArray.entries();
ComTdbVirtTableColumnInfo * colInfoArray =
new(STMTHEAP) ComTdbVirtTableColumnInfo[numCols];
if (buildColInfoArray(COM_VIEW_OBJECT, &colDefArray, colInfoArray, FALSE, 0, FALSE))
{
deallocEHI(ehi);
processReturn();
return;
}
Int64 objUID = -1;
if (updateSeabaseMDTable(&cliInterface,
catalogNamePart, schemaNamePart, objectNamePart,
COM_VIEW_OBJECT,
"N",
NULL,
numCols,
colInfoArray,
0, NULL,
0, NULL,
objectOwnerID,
schemaOwnerID,
objUID))
{
deallocEHI(ehi);
processReturn();
return;
}
if (objUID < 0)
{
deallocEHI(ehi);
processReturn();
return;
}
// grant privileges for view
if (isAuthorizationEnabled())
{
char authName[MAX_AUTHNAME_LEN+1];
Int32 lActualLen = 0;
Int16 status = ComUser::getAuthNameFromAuthID( (Int32) objectOwnerID
, (char *)&authName
, MAX_AUTHNAME_LEN
, lActualLen );
if (status != FEOK)
{
*CmpCommon::diags() << DgSqlCode(-20235)
<< DgInt0(status)
<< DgInt1(objectOwnerID);
deallocEHI(ehi);
processReturn();
return;
}
// Initiate the privilege manager interface class
NAString privMgrMDLoc;
CONCAT_CATSCH(privMgrMDLoc, getSystemCatalog(), SEABASE_PRIVMGR_SCHEMA);
PrivMgrCommands privInterface(std::string(privMgrMDLoc.data()),
CmpCommon::diags());
retcode = privInterface.grantObjectPrivilege
(objUID, std::string(extViewName.data()), COM_VIEW_OBJECT,
objectOwnerID, std::string(authName),
privilegesBitmap, grantableBitmap);
if (retcode != STATUS_GOOD && retcode != STATUS_WARNING)
{
deallocEHI(ehi);
processReturn();
return;
}
if (replacingView)
{
PrivStatus privStatus = privInterface.insertPrivRowsForObject(objUID,viewPrivsRows);
if (privStatus != PrivStatus::STATUS_GOOD)
{
SEABASEDDL_INTERNAL_ERROR("Unable to restore privileges for replaced view");
deallocEHI(ehi);
processReturn();
return;
}
}
}
query = new(STMTHEAP) char[newViewText.length() + 1000];
str_sprintf(query, "upsert into %s.\"%s\".%s values (%Ld, '%s', %d, %d, 0)",
getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_VIEWS,
objUID,
computeCheckOption(createViewNode),
(createViewNode->getIsUpdatable() ? 1 : 0),
(createViewNode->getIsInsertable() ? 1 : 0));
cliRC = cliInterface.executeImmediate(query);
NADELETEBASIC(query, STMTHEAP);
if (cliRC < 0)
{
if (cliRC == -8402)
// string overflow, view text does not fit into metadata table
*CmpCommon::diags() << DgSqlCode(-1198);
else
cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
deallocEHI(ehi);
processReturn();
return;
}
if (updateTextTable(&cliInterface, objUID, COM_VIEW_TEXT, 0, newViewText))
{
deallocEHI(ehi);
processReturn();
return;
}
if (updateViewUsage(createViewNode, objUID, &cliInterface))
{
deallocEHI(ehi);
processReturn();
return;
}
if (updateObjectValidDef(&cliInterface,
catalogNamePart, schemaNamePart, objectNamePart,
COM_VIEW_OBJECT_LIT,
"Y"))
{
deallocEHI(ehi);
processReturn();
return;
}
CorrName cn(objectNamePart, STMTHEAP, schemaNamePart, catalogNamePart);
ActiveSchemaDB()->getNATableDB()->removeNATable(cn,
NATableDB::REMOVE_MINE_ONLY, COM_VIEW_OBJECT);
deallocEHI(ehi);
processReturn();
return;
}
static void CmpSPERROR2Diags(const SP_ERROR_STRUCT* spError,
ComDiagsArea* diags)
{
if ( !diags )
return;
if (spError[0].error == arkcmpErrorISPMergeCatDiags)
{
// Special error message to indicate that errors should really be
// merged in from the catalog manager diags area.
// not supported, raise unsupported error instead
*diags << DgSqlCode(-4222)
<< DgString0("CmpSPERROR2Diags");
return;
}
for ( Int32 i=0; i< SP_MAX_ERROR_STRUCTS; i++)
{
const SP_ERROR_STRUCT* pSET = &(spError[i]);
if (pSET->error)
{
*diags << DgSqlCode(pSET->error);
if(pSET->error == -20067) { //IDS_UTILITIES_BADSYNTAX = 20067
// If utilities parser returned syntax error for syntax based
// utilities, error IDS_UTILITIES_BADSYNTAX is returned by
// utilities code to mxmcp.
// pSET->optionalString[1] has the utilities command from command line.
// pSET->optionalInteger[0] has the approximate position of error in
// the syntax of the utilities command given by user in command line.
// The approximate error position is returned by utilities parser.
// Function StoreSyntaxError(.....) takes the information to put a
// caret (^) in the approximate position of the command and the
// information is saved in diags.
StoreSyntaxError(pSET->optionalString[1], // const char * input_str
pSET->optionalInteger[0], // Int32 input_pos
*diags, // ComDiagsArea & diagsArea
0, // Int32 dgStrNum
CharInfo::UTF8, // CharInfo::CharSet input_str_cs
CharInfo::UTF8); // CharInfo::CharSet terminal_cs
}
else{
if ( pSET->optionalString[0] &&
pSET->optionalString[0] != (char *) ComDiags_UnInitialized_Int )
*diags << DgString0(pSET->optionalString[0]);
if ( pSET->optionalString[1] &&
pSET->optionalString[1] != (char *)ComDiags_UnInitialized_Int )
*diags << DgString1(pSET->optionalString[1]);
if ( pSET->optionalString[2] &&
pSET->optionalString[2] != (char *)ComDiags_UnInitialized_Int )
*diags << DgString2(pSET->optionalString[2]);
if ( pSET->optionalString[3] &&
pSET->optionalString[3] != (char *)ComDiags_UnInitialized_Int )
*diags << DgString3(pSET->optionalString[3]);
if ( pSET->optionalString[4] &&
pSET->optionalString[4] != (char *)ComDiags_UnInitialized_Int )
*diags << DgString4(pSET->optionalString[4]);
if ( pSET->optionalInteger[0] != ComDiags_UnInitialized_Int )
*diags << DgInt0(pSET->optionalInteger[0]);
if ( pSET->optionalInteger[1] != ComDiags_UnInitialized_Int )
*diags << DgInt1(pSET->optionalInteger[1]);
if ( pSET->optionalInteger[2] != ComDiags_UnInitialized_Int )
*diags << DgInt2(pSET->optionalInteger[2]);
if ( pSET->optionalInteger[3] != ComDiags_UnInitialized_Int )
*diags << DgInt3(pSET->optionalInteger[3]);
if ( pSET->optionalInteger[4] != ComDiags_UnInitialized_Int )
*diags << DgInt4(pSET->optionalInteger[4]);
}
}
else if ( i==0 )
{
// this is the case that ISP implementation does not return any
// SP_ERROR_STRUCT info back, but does return with error status.
*diags << DgSqlCode(arkcmpErrorISPNoSPError);
break;
}
else
// no more SP_ERROR_STRUCT.
break;
}
}