// ****************************************************************************
// method: gatherViewPrivileges
//
// For each referenced object (table or view) directly associated with the new
// view, combine privilege and grantable bitmaps together. The list of
// privileges gathered will be assigned as default privileges as the privilege
// owner values.
//
// TBD: when column privileges are added, need to check only the affected
// columns
//
// Parameters:
// createViewNode - for list of objects and isUpdatable/isInsertable flags
// cliInterface - used to get UID of referenced object
// privilegeBitmap - returns privileges this user has on the view
// grantableBitmap - returns privileges this user can grant
//
// returns:
// 0 - successful
// -1 - user does not have the privilege
// ****************************************************************************
short CmpSeabaseDDL::gatherViewPrivileges (const StmtDDLCreateView * createViewNode,
ExeCliInterface * cliInterface,
PrivMgrBitmap &privilegesBitmap,
PrivMgrBitmap &grantableBitmap)
{
// set all bits to true initially, we will be ANDing with privileges
// from all referenced objects
// default table and view privileges are the same, set up default values
PrivMgr::setTablePrivs(privilegesBitmap);
PrivMgr::setTablePrivs(grantableBitmap);
if (!isAuthorizationEnabled())
return 0;
const ParViewUsages &vu = createViewNode->getViewUsages();
const ParTableUsageList &vtul = vu.getViewTableUsageList();
const ParViewColTableColsUsageList &vctcul = vu.getViewColTableColsUsageList();
// If DB__ROOT, no need to gather privileges
if (!ComUser::isRootUserID() &&
!checkAccessPrivileges(vtul,vctcul,privilegesBitmap,grantableBitmap))
return -1;
// If view is not updatable or insertable, turn off privs in bitmaps
if (!createViewNode->getIsUpdatable())
{
privilegesBitmap.set(UPDATE_PRIV,false);
grantableBitmap.set(UPDATE_PRIV, false);
privilegesBitmap.set(DELETE_PRIV,false);
grantableBitmap.set(DELETE_PRIV, false);
}
if (!createViewNode->getIsInsertable())
{
privilegesBitmap.set(INSERT_PRIV,false);
grantableBitmap.set(INSERT_PRIV, false);
}
return 0;
}
// *****************************************************************************
// * *
// * Function: PrivMgr::isAuthIDGrantedPrivs *
// * *
// * Determines if the specified authorization ID has been granted one or *
// * more privileges. *
// * *
// *****************************************************************************
// * *
// * Parameters: *
// * *
// * <authID> const int32_t In *
// * is the authorization ID. *
// * *
// *****************************************************************************
// * *
// * Returns: bool *
// * *
// * true: Authorization ID has been granted one or more privileges. *
// * false: Authorization ID has not been granted any privileges. *
// * *
// *****************************************************************************
bool PrivMgr::isAuthIDGrantedPrivs(
int32_t authID,
std::vector<PrivClass> privClasses)
{
// Check for empty vector.
if (privClasses.size() == 0)
return false;
// If authorization is not enabled, no privileges were granted to anyone.
if (!isAuthorizationEnabled())
return false;
// Special case of PrivClass::ALL. Caller does not need to change when
// new a new PrivClass is added.
if (privClasses.size() == 1 && privClasses[0] == PrivClass::ALL)
{
PrivMgrPrivileges objectPrivileges(metadataLocation_,pDiags_);
if (objectPrivileges.isAuthIDGrantedPrivs(authID))
return true;
PrivMgrComponentPrivileges componentPrivileges(metadataLocation_,pDiags_);
if (componentPrivileges.isAuthIDGrantedPrivs(authID))
return true;
return false;
}
// Called specified one or more specific PrivClass. Note, ALL is not valid
// in a list, only by itself.
for (size_t pc = 0; pc < privClasses.size(); pc++)
switch (privClasses[pc])
{
case PrivClass::OBJECT:
{
PrivMgrPrivileges objectPrivileges(metadataLocation_,pDiags_);
if (objectPrivileges.isAuthIDGrantedPrivs(authID))
return true;
break;
}
case PrivClass::COMPONENT:
{
PrivMgrComponentPrivileges componentPrivileges(metadataLocation_,pDiags_);
if (componentPrivileges.isAuthIDGrantedPrivs(authID))
return true;
break;
}
case PrivClass::ALL:
default:
{
PRIVMGR_INTERNAL_ERROR("Switch statement in PrivMgr::isAuthIDGrantedPrivs()");
return STATUS_ERROR;
break;
}
}
// No grants of any privileges found for this authorization ID.
return false;
}
// *****************************************************************************
// * *
// * Function: CmpSeabaseDDL::giveSeabaseSchema *
// * *
// * Implements the GIVE SCHEMA command. *
// * *
// *****************************************************************************
// * *
// * Parameters: *
// * *
// * <giveSchemaNode> StmtDDLGiveSchema * In *
// * is a pointer to a create schema parser node. *
// * *
// * <currentCatalogName> NAString & In *
// * is the name of the current catalog. *
// * *
// *****************************************************************************
void CmpSeabaseDDL::giveSeabaseSchema(
StmtDDLGiveSchema * giveSchemaNode,
NAString & currentCatalogName)
{
ComDropBehavior dropBehavior = giveSchemaNode->getDropBehavior();
NAString catalogName = giveSchemaNode->getCatalogName();
NAString schemaName = giveSchemaNode->getSchemaName();
if (catalogName.isNull())
catalogName = currentCatalogName;
ExeCliInterface cliInterface(STMTHEAP, NULL, NULL,
CmpCommon::context()->sqlSession()->getParentQid());
Int32 objectOwnerID = 0;
Int32 schemaOwnerID = 0;
ComObjectType objectType;
Int64 schemaUID = getObjectTypeandOwner(&cliInterface,catalogName.data(),
schemaName.data(),SEABASE_SCHEMA_OBJECTNAME,
objectType,schemaOwnerID);
if (schemaUID == -1)
{
// A Trafodion schema does not exist if the schema object row is not
// present: CATALOG-NAME.SCHEMA-NAME.__SCHEMA__.
*CmpCommon::diags() << DgSqlCode(-CAT_SCHEMA_DOES_NOT_EXIST_ERROR)
<< DgSchemaName(schemaName.data());
return;
}
// *****************************************************************************
// * *
// * A schema owner can give their own schema to another authID, but they *
// * cannot give the objects in a shared schema to another authID. Only *
// * DB__ROOT or a user with the ALTER_SCHEMA privilege can change the owners *
// * of objects in a shared schema. So if the schema is private, or if only *
// * the schema is being given, we do standard authentication checking. But *
// * if giving all the objects in a shared schema, we change the check ID to *
// * the default user to force the ALTER_SCHEMA privilege check. *
// * *
// *****************************************************************************
int32_t checkID = schemaOwnerID;
if (objectType == COM_SHARED_SCHEMA_OBJECT &&
dropBehavior == COM_CASCADE_DROP_BEHAVIOR)
checkID = NA_UserIdDefault;
if (!isDDLOperationAuthorized(SQLOperation::ALTER_SCHEMA,checkID,checkID))
{
*CmpCommon::diags() << DgSqlCode(-CAT_NOT_AUTHORIZED);
return;
}
ComObjectName objName(catalogName,schemaName,NAString("dummy"),COM_TABLE_NAME,TRUE);
if (isSeabaseReservedSchema(objName) &&
!Get_SqlParser_Flags(INTERNAL_QUERY_FROM_EXEUTIL))
{
*CmpCommon::diags() << DgSqlCode(-CAT_USER_CANNOT_DROP_SMD_SCHEMA)
<< DgSchemaName(schemaName.data());
return;
}
bool isVolatile = (memcmp(schemaName.data(),"VOLATILE_SCHEMA",strlen("VOLATILE_SCHEMA")) == 0);
// Can't give a schema whose name begins with VOLATILE_SCHEMA.
if (isVolatile)
{
*CmpCommon::diags() << DgSqlCode(-CAT_RESERVED_METADATA_SCHEMA_NAME)
<< DgTableName(schemaName);
return;
}
int32_t newOwnerID = -1;
if (ComUser::getAuthIDFromAuthName(giveSchemaNode->getAuthID().data(),
newOwnerID) != 0)
{
*CmpCommon::diags() << DgSqlCode(-CAT_AUTHID_DOES_NOT_EXIST_ERROR)
<< DgString0(giveSchemaNode->getAuthID().data());
return;
}
// *****************************************************************************
// * *
// * Drop behavior is only relevant for shared schemas. For shared schemas, *
// * ownership of the schema OR the schema and all its objects may be given to *
// * another authorization ID. For private schemas, all objects are owned by *
// * the schema owner, so the drop behavior is always CASCADE. *
// * *
// * NOTE: The syntax for drop behavior always defaults to RESTRICT; for *
// * private schemas this is simply ignored, as opposed to requiring *
// * users to always specify CASCASE. *
// * *
// *****************************************************************************
Lng32 cliRC = 0;
char buf[4000];
if (objectType == COM_SHARED_SCHEMA_OBJECT &&
dropBehavior == COM_RESTRICT_DROP_BEHAVIOR)
{
str_sprintf(buf,"UPDATE %s.\"%s\".%s "
"SET object_owner = %d "
"WHERE object_UID = %Ld",
getSystemCatalog(),SEABASE_MD_SCHEMA,SEABASE_OBJECTS,
newOwnerID,schemaUID);
cliRC = cliInterface.executeImmediate(buf);
if (cliRC < 0)
cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
return;
}
//
// At this point, we are giving all objects in the schema (as well as the
// schema itself) to the new authorization ID. If authentication is enabled,
// update the privileges first.
//
if (isAuthorizationEnabled())
{
int32_t rc = transferObjectPrivs(getSystemCatalog(),catalogName.data(),
schemaName.data(),newOwnerID,
giveSchemaNode->getAuthID().data());
if (rc != 0)
{
if (CmpCommon::diags()->getNumber(DgSqlCode::ERROR_) == 0)
{
//TODO: add error
}
return;
}
}
// Now update the object owner for all objects in the schema.
str_sprintf(buf,"UPDATE %s.\"%s\".%s "
"SET object_owner = %d "
"WHERE catalog_name = '%s' AND schema_name = '%s'",
getSystemCatalog(),SEABASE_MD_SCHEMA,SEABASE_OBJECTS,
newOwnerID,catalogName.data(),schemaName.data());
cliRC = cliInterface.executeImmediate(buf);
if (cliRC < 0)
{
cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
return;
}
// Verify all objects in the schema have been given to the new owner.
str_sprintf(buf,"SELECT COUNT(*) "
"FROM %s.\"%s\".%s "
"WHERE catalog_name = '%s' AND schema_name = '%s' AND "
"object_name <> '"SEABASE_SCHEMA_OBJECTNAME"' AND "
"object_owner <> %d "
"FOR READ COMMITTED ACCESS",
getSystemCatalog(),SEABASE_MD_SCHEMA,SEABASE_OBJECTS,
catalogName.data(),schemaName.data(),newOwnerID);
int32_t length = 0;
int32_t rowCount = 0;
cliRC = cliInterface.executeImmediate(buf,(char*)&rowCount,&length,NULL);
if (cliRC < 0)
{
cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
return;
}
if (rowCount > 0)
{
SEABASEDDL_INTERNAL_ERROR("Not all objects in schema were given");
return;
}
}
void CmpSeabaseDDL::createSeabaseRoutine(
StmtDDLCreateRoutine * createRoutineNode,
NAString &currCatName,
NAString &currSchName)
{
Lng32 retcode = 0;
ComObjectName routineName(createRoutineNode->getRoutineName());
ComAnsiNamePart currCatAnsiName(currCatName);
ComAnsiNamePart currSchAnsiName(currSchName);
routineName.applyDefaults(currCatAnsiName, currSchAnsiName);
const NAString catalogNamePart =
routineName.getCatalogNamePartAsAnsiString();
const NAString schemaNamePart =
routineName.getSchemaNamePartAsAnsiString(TRUE);
const NAString objectNamePart =
routineName.getObjectNamePartAsAnsiString(TRUE);
const NAString extRoutineName = routineName.getExternalName(TRUE);
ComRoutineType rType = createRoutineNode->getRoutineType();
ComRoutineLanguage language = createRoutineNode->getLanguageType();
ComRoutineParamStyle ddlStyle = createRoutineNode->getParamStyle();
ComRoutineParamStyle style = ddlStyle;
NABoolean isJava = (language == COM_LANGUAGE_JAVA);
// Check to see if user has the authority to create the routine
ExeCliInterface cliInterface(STMTHEAP, NULL, NULL,
CmpCommon::context()->sqlSession()->getParentQid());
Int32 objectOwnerID = SUPER_USER;
Int32 schemaOwnerID = SUPER_USER;
ComSchemaClass schemaClass;
retcode = verifyDDLCreateOperationAuthorized(&cliInterface,
SQLOperation::CREATE_ROUTINE,
catalogNamePart,
schemaNamePart,
schemaClass,
objectOwnerID,
schemaOwnerID);
if (retcode != 0)
{
handleDDLCreateAuthorizationError(retcode,catalogNamePart,schemaNamePart);
return;
}
ExpHbaseInterface * ehi = NULL;
ehi = allocEHI();
if (ehi == NULL)
{
processReturn();
return;
}
retcode = existsInSeabaseMDTable(&cliInterface,
catalogNamePart, schemaNamePart,
objectNamePart, COM_USER_DEFINED_ROUTINE_OBJECT,
TRUE, FALSE);
if (retcode < 0)
{
deallocEHI(ehi);
processReturn();
return;
}
if (retcode == 1) // already exists
{
*CmpCommon::diags() << DgSqlCode(-1390)
<< DgString0(extRoutineName);
deallocEHI(ehi);
processReturn();
return;
}
ComObjectName libName(createRoutineNode->
getLibraryName().getQualifiedNameAsAnsiString());
libName.applyDefaults(currCatAnsiName, currSchAnsiName);
NAString libCatNamePart = libName.getCatalogNamePartAsAnsiString();
NAString libSchNamePart = libName.getSchemaNamePartAsAnsiString(TRUE);
NAString libObjNamePart = libName.getObjectNamePartAsAnsiString(TRUE);
const NAString extLibraryName = libName.getExternalName(TRUE);
char externalPath[512] ;
Lng32 cliRC = 0;
// this call needs to change
Int64 libUID = getObjectUID(&cliInterface,
libCatNamePart,
libSchNamePart,
libObjNamePart,
COM_LIBRARY_OBJECT_LIT);
if (libUID < 0)
{
processReturn();
return;
}
if (libUID == 0) // does not exist
{
*CmpCommon::diags() << DgSqlCode(-1361)
<< DgString0(extLibraryName);
deallocEHI(ehi);
processReturn();
return;
}
// read the library path name from the LIBRARIES metadata table
char * buf = new(STMTHEAP) char[200];
str_sprintf(buf, "select library_filename from %s.\"%s\".%s"
" where library_uid = %Ld for read uncommitted access",
getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_LIBRARIES, libUID);
cliRC = cliInterface.fetchRowsPrologue(buf, TRUE/*no exec*/);
if (cliRC < 0)
{
cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
deallocEHI(ehi);
processReturn();
return;
}
cliRC = cliInterface.clearExecFetchClose(NULL, 0);
if (cliRC < 0)
{
cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
deallocEHI(ehi);
processReturn();
return;
}
if (cliRC == 100) // did not find the row
{
*CmpCommon::diags() << DgSqlCode(-1231)
<< DgString0(extRoutineName);
deallocEHI(ehi);
processReturn();
return;
}
char * ptr = NULL;
Lng32 len = 0;
cliInterface.getPtrAndLen(1, ptr, len);
str_cpy_all(externalPath, ptr, len);
externalPath[len] = '\0';
// determine language and parameter styles based on the library
// type, unless already specified
if (!createRoutineNode->isLanguageTypeSpecified())
{
NAString extPath(externalPath);
size_t lastDot = extPath.last('.');
NAString libSuffix;
if (lastDot != NA_NPOS)
libSuffix = extPath(lastDot,extPath.length()-lastDot);
libSuffix.toUpper();
if (libSuffix == ".JAR")
{
isJava = TRUE;
language = COM_LANGUAGE_JAVA;
}
else if (libSuffix == ".SO" ||
libSuffix == ".DLL")
{
// a known C/C++ library, set
// language and parameter style below
}
else
{
// language not specified and library name
// is inconclusive, issue an error
*CmpCommon::diags() << DgSqlCode( -3284 )
<< DgString0( externalPath );
processReturn();
}
}
// set parameter style and also language, if not already
// specified, based on routine type and type of library
if (isJava)
{
// library is a jar file
if (rType == COM_PROCEDURE_TYPE)
// Java stored procedures use the older Java style
style = COM_STYLE_JAVA_CALL;
else
// Java UDFs use the newer Java object style
style = COM_STYLE_JAVA_OBJ;
}
else
{
// assume the library is a DLL with C or C++ code
if (rType == COM_TABLE_UDF_TYPE &&
(language == COM_LANGUAGE_CPP ||
!createRoutineNode->isLanguageTypeSpecified()))
{
// Table UDFs (TMUDFs) default to the C++ interface
language = COM_LANGUAGE_CPP;
style = COM_STYLE_CPP_OBJ;
}
else if (rType == COM_SCALAR_UDF_TYPE &&
(language == COM_LANGUAGE_C ||
!createRoutineNode->isLanguageTypeSpecified()))
{
// scalar UDFs default to C and SQL parameter style
language = COM_LANGUAGE_C;
style = COM_STYLE_SQL;
}
else
{
// some invalid combination of routine type, language and
// library type
*CmpCommon::diags() << DgSqlCode(-3286);
processReturn();
return;
}
} // C/C++ DLL
if (createRoutineNode->isParamStyleSpecified() &&
ddlStyle != style)
{
// An unsupported PARAMETER STYLE was specified
*CmpCommon::diags() << DgSqlCode(-3280);
processReturn();
return;
}
NAString externalName;
if (language == COM_LANGUAGE_JAVA &&
style == COM_STYLE_JAVA_CALL)
{
// the external name is a Java method signature
externalName = createRoutineNode->getJavaClassName();
externalName += "." ;
externalName += createRoutineNode->getJavaMethodName();
}
else
// the external name is a C/C++ entry point or a
// Java class name
externalName = createRoutineNode->getExternalName();
// Verify that current user has authority to create the routine
// User must be DB__ROOT or have privileges
if (isAuthorizationEnabled() && !ComUser::isRootUserID())
{
// For now, go get privileges directly. If we ever cache routines, then
// make sure privileges are stored in the cache.
NAString privMgrMDLoc;
CONCAT_CATSCH(privMgrMDLoc, getSystemCatalog(), SEABASE_PRIVMGR_SCHEMA);
PrivMgrCommands privInterface(privMgrMDLoc.data(), CmpCommon::diags());
PrivMgrUserPrivs privs;
PrivStatus retcode = privInterface.getPrivileges(libUID, COM_LIBRARY_OBJECT,
ComUser::getCurrentUser(), privs);
if (retcode != STATUS_GOOD)
{
if (CmpCommon::diags()->getNumber(DgSqlCode::ERROR_) == 0)
SEABASEDDL_INTERNAL_ERROR("checking routine privilege");
processReturn();
return;
}
// Requester must have USAGE privilege on the library
NABoolean hasPriv = TRUE;
if ( !privs.hasUsagePriv() )
{
*CmpCommon::diags() << DgSqlCode( -4481 )
<< DgString0( "USAGE" )
<< DgString1( extLibraryName.data());
processReturn();
return;
}
}
ElemDDLParamDefArray &routineParamArray =
createRoutineNode->getParamArray();
Lng32 numParams = routineParamArray.entries();
if ((createRoutineNode->getRoutineType() == COM_SCALAR_UDF_TYPE) &&
(numParams > 32))
{
*CmpCommon::diags() << DgSqlCode( -1550 )
<< DgString0( extRoutineName )
<< DgInt0( numParams );
deallocEHI(ehi);
processReturn();
return;
}
#define MAX_SIGNATURE_LENGTH 8193
// Allocate buffer for generated signature
char sigBuf[MAX_SIGNATURE_LENGTH];
sigBuf[0] = '\0';
if (style == COM_STYLE_JAVA_CALL)
{
// validate routine for Java call based on signature
Lng32 numJavaParam = 0;
ComFSDataType *paramType = new ComFSDataType[numParams];
ComUInt32 *subType = new ComUInt32 [numParams];
ComColumnDirection *direction = new ComColumnDirection[numParams];
NAType *genericType;
// Gather the param attributes for LM from the paramDefArray previously
// populated and from the routineparamList generated from paramDefArray.
for (CollIndex i = 0; (Int32)i < numParams; i++)
{
paramType[i] = (ComFSDataType)routineParamArray[i]->getParamDataType()->getFSDatatype();
subType[i] = 0; // default
// Set subType for special cases detected by LM
switch ( paramType[i] )
{
case COM_SIGNED_BIN16_FSDT :
case COM_SIGNED_BIN32_FSDT :
case COM_SIGNED_BIN64_FSDT :
case COM_UNSIGNED_BIN16_FSDT :
case COM_UNSIGNED_BIN32_FSDT :
case COM_UNSIGNED_BPINT_FSDT :
{
genericType = routineParamArray[i]->getParamDataType() ;
if (genericType->getTypeName() == LiteralNumeric)
subType[i] = genericType->getPrecision();
else
subType[i] = 0 ;
break;
}
case COM_DATETIME_FSDT :
{
genericType = routineParamArray[i]->getParamDataType() ;
DatetimeType & datetimeType = (DatetimeType &) *genericType;
if (datetimeType.getSimpleTypeName() EQU "DATE")
subType[i] = 1 ;
else if (datetimeType.getSimpleTypeName() EQU "TIME")
subType[i] = 2;
else if (datetimeType.getSimpleTypeName() EQU "TIMESTAMP")
subType[i] = 3;
}
} // end switch paramType[i]
direction[i] = (ComColumnDirection) routineParamArray[i]->getParamDirection();
}
// If the syntax specified a signature, pass that to LanguageManager.
NAString specifiedSig( createRoutineNode->getJavaSignature() );
char* optionalSig;
if ( specifiedSig.length() == 0 )
optionalSig = NULL;
else
optionalSig = (char *)specifiedSig.data();
ComBoolean isJavaMain =
((str_cmp_ne(createRoutineNode->getJavaMethodName(), "main") == 0) ? TRUE : FALSE);
LmResult createSigResult;
LmJavaSignature *lmSignature = new (STMTHEAP) LmJavaSignature(NULL,
STMTHEAP);
createSigResult = lmSignature->createSig(paramType, subType, direction,
numParams, COM_UNKNOWN_FSDT, 0,
createRoutineNode->getMaxResults(), optionalSig, isJavaMain, sigBuf,
MAX_SIGNATURE_LENGTH,
CmpCommon::diags());
NADELETE(lmSignature, LmJavaSignature, STMTHEAP);
delete [] paramType;
delete [] subType;
delete [] direction;
// Lm returned error. Lm fills diags area, so no need to worry about diags.
if (createSigResult == LM_ERR)
{
*CmpCommon::diags() << DgSqlCode(-1231)
<< DgString0(extRoutineName);
deallocEHI(ehi);
processReturn();
return;
}
numJavaParam = (isJavaMain ? 1 : numParams);
if (validateRoutine(&cliInterface,
createRoutineNode->getJavaClassName(),
createRoutineNode->getJavaMethodName(),
externalPath,
sigBuf,
numJavaParam,
createRoutineNode->getMaxResults(),
optionalSig))
{
*CmpCommon::diags() << DgSqlCode(-1231)
<< DgString0(extRoutineName);
deallocEHI(ehi);
processReturn();
return;
}
}
else if (style == COM_STYLE_JAVA_OBJ ||
style == COM_STYLE_CPP_OBJ)
{
// validate existence of the C++ or Java class in the library
Int32 routineHandle = NullCliRoutineHandle;
NAString externalPrefix(externalPath);
NAString externalNameForValidation(externalName);
NAString containerName;
if (language == COM_LANGUAGE_C || language == COM_LANGUAGE_CPP)
{
// separate the actual DLL name from the prefix
char separator = '/';
size_t separatorPos = externalPrefix.last(separator);
if (separatorPos != NA_NPOS)
{
containerName = externalPrefix(separatorPos+1,
externalPrefix.length()-separatorPos-1);
externalPrefix.remove(separatorPos,
externalPrefix.length()-separatorPos);
}
else
{
// assume the entire string is a local name
containerName = externalPrefix;
externalPrefix = ".";
}
}
else
{
// For Java, the way the language manager works is that the
// external path is the fully qualified name of the jar and
// the container is the class name (external name). We load
// the container (the class) by searching in the path (the
// jar). The external name is the method name, which in this
// case is the constructor of the class, <init>.
// leave externalPrevix unchanged, fully qualified jar file
containerName = externalName;
externalNameForValidation = "<init>";
}
// use a CLI call to validate that the library contains the routine
if (cliInterface.getRoutine(
NULL, // No InvocationInfo specified in this step
0,
NULL,
0,
(Int32) language,
(Int32) style,
externalNameForValidation.data(),
containerName.data(),
externalPrefix.data(),
extLibraryName.data(),
&routineHandle,
CmpCommon::diags()) != LME_ROUTINE_VALIDATED)
{
if (routineHandle != NullCliRoutineHandle)
cliInterface.putRoutine(routineHandle,
CmpCommon::diags());
CMPASSERT(CmpCommon::diags()->mainSQLCODE() < 0);
processReturn();
return;
}
cliInterface.putRoutine(routineHandle,
CmpCommon::diags());
}
ComTdbVirtTableColumnInfo * colInfoArray = (ComTdbVirtTableColumnInfo*)
new(STMTHEAP) ComTdbVirtTableColumnInfo[numParams];
if (buildColInfoArray(&routineParamArray, colInfoArray))
{
processReturn();
return;
}
ComTdbVirtTableTableInfo * tableInfo = new(STMTHEAP) ComTdbVirtTableTableInfo[1];
tableInfo->tableName = NULL,
tableInfo->createTime = 0;
tableInfo->redefTime = 0;
tableInfo->objUID = 0;
tableInfo->objOwnerID = objectOwnerID;
tableInfo->schemaOwnerID = schemaOwnerID;
tableInfo->isAudited = 1;
tableInfo->validDef = 1;
tableInfo->hbaseCreateOptions = NULL;
tableInfo->numSaltPartns = 0;
tableInfo->rowFormat = COM_UNKNOWN_FORMAT_TYPE;
tableInfo->objectFlags = 0;
Int64 objUID = -1;
if (updateSeabaseMDTable(&cliInterface,
catalogNamePart, schemaNamePart, objectNamePart,
COM_USER_DEFINED_ROUTINE_OBJECT,
"N",
tableInfo,
numParams,
colInfoArray,
0, NULL,
0, NULL,
objUID))
{
deallocEHI(ehi);
processReturn();
return;
}
if (objUID == -1)
{
deallocEHI(ehi);
processReturn();
return;
}
NAString udrType;
getRoutineTypeLit(createRoutineNode->getRoutineType(), udrType);
NAString languageType;
getLanguageTypeLit(language, languageType);
NAString sqlAccess;
getSqlAccessLit(createRoutineNode->getSqlAccess(), sqlAccess);
NAString paramStyle;
getParamStyleLit(style, paramStyle);
NAString transactionAttributes;
getTransAttributesLit(createRoutineNode->getTransactionAttributes(), transactionAttributes);
NAString parallelism;
getParallelismLit(createRoutineNode->getParallelism(), parallelism);
NAString externalSecurity;
getExternalSecurityLit(createRoutineNode->getExternalSecurity(), externalSecurity);
NAString executionMode;
getExecutionModeLit(createRoutineNode->getExecutionMode(), executionMode);
char * query = new(STMTHEAP) char[2000+MAX_SIGNATURE_LENGTH];
str_sprintf(query, "insert into %s.\"%s\".%s values (%Ld, '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', %d, %d, '%s', '%s', '%s', '%s', '%s', %Ld, '%s' )",
getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_ROUTINES,
objUID,
udrType.data(),
languageType.data(),
createRoutineNode->isDeterministic() ? "Y" : "N" ,
sqlAccess.data(),
createRoutineNode->isCallOnNull() ? "Y" : "N" ,
createRoutineNode->isIsolate() ? "Y" : "N" ,
paramStyle.data(),
transactionAttributes.data(),
createRoutineNode->getMaxResults(),
createRoutineNode->getStateAreaSize(),
externalName.data(),
parallelism.data(),
createRoutineNode->getUserVersion().data(),
externalSecurity.data(),
executionMode.data(),
libUID,
sigBuf);
cliRC = cliInterface.executeImmediate(query);
NADELETEBASIC(query, STMTHEAP);
if (cliRC < 0)
{
cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
processReturn();
return;
}
char * query1 = new(STMTHEAP) char[1000];
str_sprintf(query1, "insert into %s.\"%s\".%s values (%Ld, %Ld)",
getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_LIBRARIES_USAGE,
libUID, objUID);
cliRC = cliInterface.executeImmediate(query1);
NADELETEBASIC(query1, STMTHEAP);
if (cliRC < 0)
{
cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
processReturn();
return;
}
// hope to remove this call soon by setting the valid flag to Y sooner
if (updateObjectValidDef(&cliInterface,
catalogNamePart, schemaNamePart, objectNamePart,
COM_USER_DEFINED_ROUTINE_OBJECT_LIT,
"Y"))
{
deallocEHI(ehi);
processReturn();
return;
}
processReturn();
return;
}
void CmpSeabaseDDL::createSeabaseLibrary(
StmtDDLCreateLibrary * createLibraryNode,
NAString &currCatName,
NAString &currSchName)
{
Lng32 retcode = 0;
ComObjectName libraryName(createLibraryNode->getLibraryName());
ComAnsiNamePart currCatAnsiName(currCatName);
ComAnsiNamePart currSchAnsiName(currSchName);
libraryName.applyDefaults(currCatAnsiName, currSchAnsiName);
const NAString catalogNamePart =
libraryName.getCatalogNamePartAsAnsiString();
const NAString schemaNamePart =
libraryName.getSchemaNamePartAsAnsiString(TRUE);
const NAString objectNamePart =
libraryName.getObjectNamePartAsAnsiString(TRUE);
const NAString extLibraryName = libraryName.getExternalName(TRUE);
const NAString extNameForHbase = catalogNamePart + "." + schemaNamePart +
"." + objectNamePart;
// Verify that the requester has MANAGE_LIBRARY privilege.
if (isAuthorizationEnabled() && !ComUser::isRootUserID())
{
NAString privMgrMDLoc;
CONCAT_CATSCH(privMgrMDLoc, getSystemCatalog(), SEABASE_PRIVMGR_SCHEMA);
PrivMgrComponentPrivileges componentPrivileges(std::string(privMgrMDLoc.data()),CmpCommon::diags());
if (!componentPrivileges.hasSQLPriv
(ComUser::getCurrentUser(),SQLOperation::MANAGE_LIBRARY,true))
{
*CmpCommon::diags() << DgSqlCode(-CAT_NOT_AUTHORIZED);
processReturn ();
return;
}
}
// Check to see if user has the authority to create the library
ExeCliInterface cliInterface(STMTHEAP, NULL, NULL,
CmpCommon::context()->sqlSession()->getParentQid());
Int32 objectOwnerID = SUPER_USER;
Int32 schemaOwnerID = SUPER_USER;
ComSchemaClass schemaClass;
retcode = verifyDDLCreateOperationAuthorized(&cliInterface,
SQLOperation::CREATE_LIBRARY,
catalogNamePart,
schemaNamePart,
schemaClass,
objectOwnerID,
schemaOwnerID);
if (retcode != 0)
{
handleDDLCreateAuthorizationError(retcode,catalogNamePart,schemaNamePart);
return;
}
ExpHbaseInterface * ehi = NULL;
ehi = allocEHI();
if (ehi == NULL)
{
processReturn();
return;
}
retcode = existsInSeabaseMDTable(&cliInterface,
catalogNamePart, schemaNamePart,
objectNamePart, COM_LIBRARY_OBJECT,
TRUE, FALSE);
if (retcode < 0)
{
deallocEHI(ehi);
processReturn();
return;
}
if (retcode == 1) // already exists
{
*CmpCommon::diags() << DgSqlCode(-1390)
<< DgString0(extLibraryName);
deallocEHI(ehi);
processReturn();
return;
}
NAString libFileName = createLibraryNode->getFilename() ;
// strip blank spaces
libFileName = libFileName.strip(NAString::both, ' ');
if (validateLibraryFileExists(libFileName, FALSE))
{
deallocEHI(ehi);
processReturn();
return;
}
ComTdbVirtTableTableInfo * tableInfo = new(STMTHEAP) ComTdbVirtTableTableInfo[1];
tableInfo->tableName = NULL,
tableInfo->createTime = 0;
tableInfo->redefTime = 0;
tableInfo->objUID = 0;
tableInfo->objOwnerID = objectOwnerID;
tableInfo->schemaOwnerID = schemaOwnerID;
tableInfo->isAudited = 1;
tableInfo->validDef = 1;
tableInfo->hbaseCreateOptions = NULL;
tableInfo->numSaltPartns = 0;
tableInfo->rowFormat = COM_UNKNOWN_FORMAT_TYPE;
tableInfo->objectFlags = 0;
Int64 objUID = -1;
if (updateSeabaseMDTable(&cliInterface,
catalogNamePart, schemaNamePart, objectNamePart,
COM_LIBRARY_OBJECT,
"N",
tableInfo,
0,
NULL,
0,
NULL,
0, NULL,
objUID))
{
deallocEHI(ehi);
processReturn();
return;
}
if (objUID == -1)
{
deallocEHI(ehi);
processReturn();
return;
}
char * query = new(STMTHEAP) char[1000];
str_sprintf(query, "insert into %s.\"%s\".%s values (%Ld, '%s', %d)",
getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_LIBRARIES,
objUID,
libFileName.data(),
createLibraryNode->getVersion());
Lng32 cliRC = cliInterface.executeImmediate(query);
NADELETEBASIC(query, STMTHEAP);
if (cliRC < 0)
{
cliInterface.retrieveSQLDiagnostics(CmpCommon::diags());
processReturn();
return;
}
// hope to remove this call soon by setting thevalid flag to Y sooner
if (updateObjectValidDef(&cliInterface,
catalogNamePart, schemaNamePart, objectNamePart,
COM_LIBRARY_OBJECT_LIT,
"Y"))
{
deallocEHI(ehi);
processReturn();
return;
}
processReturn();
return;
}
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;
}
