// Lookup the other table involved in this RI relationship, // and find the other constraint in the other NATable constraint list. // I.e., if called by a UniqueConstraint, this looks in the referencing table's // refConstraints to find the FK constraint passed in riInfo; // if called by a RefConstraint, this looks in the referenced table's // uniqueConstraints to find the UC constraint passed in riInfo. // AbstractRIConstraint *AbstractRIConstraint::findConstraint( BindWA *bindWA, const ComplementaryRIConstraint &riInfo) const { // Lookup errors should be impossible, due to Ansi transaction semantics // during compilation of a query, so no need for fancy diags, just assert // (should only happen if catalog corrupt or txn seriously haywire) CorrName tempName(riInfo.tableName_); NATable *naTable = bindWA->getNATable(tempName, FALSE); if (!naTable) return NULL; const AbstractRIConstraintList otherConstraints = (getOperatorType() == ITM_UNIQUE_CONSTRAINT) ? naTable->getRefConstraints() : naTable->getUniqueConstraints(); // The find() from Collections template doesn't work for us, so roll our own AbstractRIConstraint *c; for (CollIndex i = 0; i < otherConstraints.entries(); i++) { c = otherConstraints[i]; if (c->getConstraintName() == riInfo.constraintName_) return c; } *CmpCommon::diags() << DgSqlCode(-4353) << DgTableName(naTable->getTableName().getQualifiedNameAsAnsiString()) ; bindWA->setErrStatus(); return NULL; } // AbstractRIConstraint::findConstraint
////////////////////////////////////////////////////////////////////////////// // Verify that all the tables in the delta definition list are indeed used // by this MV. ////////////////////////////////////////////////////////////////////////////// NABoolean Refresh::verifyDeltaDefinition(BindWA *bindWA, MVInfoForDML *mvInfo) const { const DeltaDefinitionPtrList *deltaDefs = getDeltaDefList(); if (deltaDefs == NULL) return FALSE; for (CollIndex i=0; i<deltaDefs->entries(); i++) { const QualifiedName *tableName = deltaDefs->at(i)->getTableName(); if (mvInfo->findUsedInfoForTable(*tableName) == NULL) { // 12314 Table $0~TableName is not used by this materialized view. *CmpCommon::diags() << DgSqlCode(-12314) << DgTableName(tableName->getQualifiedNameAsString()); bindWA->setErrStatus(); return TRUE; } } 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; } }
// ***************************************************************************** // * * // * Function: CmpSeabaseDDL::dropSeabaseSchema * // * * // * Implements the DROP SCHEMA command. * // * * // ***************************************************************************** // * * // * Parameters: * // * * // * <dropSchemaNode> StmtDDLDropSchema * In * // * is a pointer to a create schema parser node. * // * * // ***************************************************************************** void CmpSeabaseDDL::dropSeabaseSchema(StmtDDLDropSchema * dropSchemaNode) { Lng32 cliRC = 0; ComSchemaName schemaName(dropSchemaNode->getSchemaName()); NAString catName = schemaName.getCatalogNamePartAsAnsiString(); ComAnsiNamePart schNameAsComAnsi = schemaName.getSchemaNamePart(); NAString schName = schNameAsComAnsi.getInternalName(); ExeCliInterface cliInterface(STMTHEAP, NULL, NULL, CmpCommon::context()->sqlSession()->getParentQid()); Int32 objectOwnerID = 0; Int32 schemaOwnerID = 0; ComObjectType objectType; Int64 schemaUID = getObjectTypeandOwner(&cliInterface,catName.data(),schName.data(), SEABASE_SCHEMA_OBJECTNAME,objectType,schemaOwnerID); // if schemaUID == -1, then either the schema does not exist or an unexpected error occurred if (schemaUID == -1) { // If an error occurred, return if (CmpCommon::diags()->getNumber(DgSqlCode::ERROR_) > 0) return; // schema does not exist and IF EXISTS specified, then ignore and continue if (dropSchemaNode->dropIfExists()) return; // 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.getExternalName().data()); return; } if (!isDDLOperationAuthorized(SQLOperation::DROP_SCHEMA, schemaOwnerID,schemaOwnerID)) { *CmpCommon::diags() << DgSqlCode(-CAT_NOT_AUTHORIZED); return; } ComObjectName objName(catName,schName,NAString("dummy"),COM_TABLE_NAME,TRUE); if ((isSeabaseReservedSchema(objName) || (schName == SEABASE_SYSTEM_SCHEMA)) && !Get_SqlParser_Flags(INTERNAL_QUERY_FROM_EXEUTIL)) { *CmpCommon::diags() << DgSqlCode(-CAT_USER_CANNOT_DROP_SMD_SCHEMA) << DgSchemaName(schemaName.getExternalName().data()); return; } bool isVolatile = (memcmp(schName.data(),"VOLATILE_SCHEMA",strlen("VOLATILE_SCHEMA")) == 0); // Can't drop a schema whose name begins with VOLATILE_SCHEMA unless the // keyword VOLATILE was specified in the DROP SCHEMA command. if (isVolatile && !dropSchemaNode->isVolatile()) { *CmpCommon::diags() << DgSqlCode(-CAT_RESERVED_METADATA_SCHEMA_NAME) << DgTableName(schName); return; } // Get a list of all objects in the schema, excluding the schema object itself. char query[4000]; str_sprintf(query,"SELECT TRIM(object_name), TRIM(object_type) " "FROM %s.\"%s\".%s " "WHERE catalog_name = '%s' AND schema_name = '%s' AND " "object_name <> '"SEABASE_SCHEMA_OBJECTNAME"'" "FOR READ COMMITTED ACCESS", getSystemCatalog(),SEABASE_MD_SCHEMA,SEABASE_OBJECTS, (char*)catName.data(),(char*)schName.data()); Queue * objectsQueue = NULL; cliRC = cliInterface.fetchAllRows(objectsQueue, query, 0, FALSE, FALSE, TRUE); if (cliRC < 0) { cliInterface.retrieveSQLDiagnostics(CmpCommon::diags()); return; } objectsQueue->position(); if ((dropSchemaNode->getDropBehavior() == COM_RESTRICT_DROP_BEHAVIOR) && (objectsQueue->numEntries() > 0)) { OutputInfo * oi = (OutputInfo*)objectsQueue->getCurr(); *CmpCommon::diags() << DgSqlCode(-CAT_SCHEMA_IS_NOT_EMPTY) << DgTableName(oi->get(0)); return; } bool someObjectsCouldNotBeDropped = false; // Drop libraries, procedures (SPJs), UDFs (functions), and views objectsQueue->position(); for (int idx = 0; idx < objectsQueue->numEntries(); idx++) { OutputInfo * vi = (OutputInfo*)objectsQueue->getNext(); char * objName = vi->get(0); NAString objectTypeLit = vi->get(1); ComObjectType objectType = PrivMgr::ObjectLitToEnum(objectTypeLit.data()); char buf[1000]; NAString objectTypeString; NAString cascade = " "; switch (objectType) { // These object types are handled later and can be ignored for now. case COM_BASE_TABLE_OBJECT: case COM_INDEX_OBJECT: case COM_CHECK_CONSTRAINT_OBJECT: case COM_NOT_NULL_CONSTRAINT_OBJECT: case COM_PRIMARY_KEY_CONSTRAINT_OBJECT: case COM_REFERENTIAL_CONSTRAINT_OBJECT: case COM_SEQUENCE_GENERATOR_OBJECT: case COM_UNIQUE_CONSTRAINT_OBJECT: { continue; } case COM_LIBRARY_OBJECT: { objectTypeString = "LIBRARY"; cascade = "CASCADE"; break; } case COM_STORED_PROCEDURE_OBJECT: { objectTypeString = "PROCEDURE"; break; } case COM_USER_DEFINED_ROUTINE_OBJECT: { objectTypeString = "FUNCTION"; cascade = "CASCADE"; break; } case COM_VIEW_OBJECT: { objectTypeString = "VIEW"; cascade = "CASCADE"; break; } // These object types should not be seen. case COM_MV_OBJECT: case COM_MVRG_OBJECT: case COM_TRIGGER_OBJECT: case COM_LOB_TABLE_OBJECT: case COM_TRIGGER_TABLE_OBJECT: case COM_SYNONYM_OBJECT: case COM_PRIVATE_SCHEMA_OBJECT: case COM_SHARED_SCHEMA_OBJECT: case COM_EXCEPTION_TABLE_OBJECT: case COM_LOCK_OBJECT: case COM_MODULE_OBJECT: default: SEABASEDDL_INTERNAL_ERROR("Unrecognized object type in schema"); return; } str_sprintf(buf, "drop %s \"%s\".\"%s\".\"%s\" %s", objectTypeString.data(),(char*)catName.data(),(char*)schName.data(), objName,cascade.data()); cliRC = cliInterface.executeImmediate(buf); if (cliRC < 0 && cliRC != -CAT_OBJECT_DOES_NOT_EXIST_IN_TRAFODION) someObjectsCouldNotBeDropped = true; } // Drop all tables in the schema. This will also drop any associated constraints. // Drop of histogram tables is deferred. bool histExists = false; objectsQueue->position(); for (int idx = 0; idx < objectsQueue->numEntries(); idx++) { OutputInfo * vi = (OutputInfo*)objectsQueue->getNext(); NAString objName = vi->get(0); NAString objType = vi->get(1); // drop user objects first if (objType == COM_BASE_TABLE_OBJECT_LIT) { if (!(objName == HBASE_HIST_NAME || objName == HBASE_HISTINT_NAME)) { if (dropOneTable(cliInterface,(char*)catName.data(), (char*)schName.data(),(char*)objName.data(), isVolatile)) someObjectsCouldNotBeDropped = true; } else histExists = true; } } // Drop any remaining indexes. str_sprintf(query,"SELECT TRIM(object_name), TRIM(object_type) " "FROM %s.\"%s\".%s " "WHERE catalog_name = '%s' AND " " schema_name = '%s' AND " " object_type = '%s' " "FOR READ COMMITTED ACCESS ", getSystemCatalog(),SEABASE_MD_SCHEMA,SEABASE_OBJECTS, (char*)catName.data(),(char*)schName.data(), COM_INDEX_OBJECT_LIT); cliRC = cliInterface.fetchAllRows(objectsQueue,query,0,FALSE,FALSE,TRUE); if (cliRC < 0) { cliInterface.retrieveSQLDiagnostics(CmpCommon::diags()); return; } objectsQueue->position(); for (int idx = 0; idx < objectsQueue->numEntries(); idx++) { OutputInfo * vi = (OutputInfo*)objectsQueue->getNext(); char * objName = vi->get(0); NAString objType = vi->get(1); if (objType == COM_INDEX_OBJECT_LIT) { char buf [1000]; str_sprintf(buf, "DROP INDEX \"%s\".\"%s\".\"%s\" CASCADE", (char*)catName.data(), (char*)schName.data(), objName); cliRC = cliInterface.executeImmediate(buf); if (cliRC < 0 && cliRC != -CAT_OBJECT_DOES_NOT_EXIST_IN_TRAFODION) someObjectsCouldNotBeDropped = true; } } // Drop any remaining sequences. str_sprintf(query,"SELECT TRIM(object_name), TRIM(object_type) " "FROM %s.\"%s\".%s " "WHERE catalog_name = '%s' AND " " schema_name = '%s' AND " " object_type = '%s' " "FOR READ COMMITTED ACCESS ", getSystemCatalog(),SEABASE_MD_SCHEMA,SEABASE_OBJECTS, (char*)catName.data(),(char*)schName.data(), COM_SEQUENCE_GENERATOR_OBJECT_LIT); cliRC = cliInterface.fetchAllRows(objectsQueue,query,0,FALSE,FALSE,TRUE); if (cliRC < 0) { cliInterface.retrieveSQLDiagnostics(CmpCommon::diags()); return; } objectsQueue->position(); for (int idx = 0; idx < objectsQueue->numEntries(); idx++) { OutputInfo * vi = (OutputInfo*)objectsQueue->getNext(); char * objName = vi->get(0); NAString objType = vi->get(1); if (objType == COM_SEQUENCE_GENERATOR_OBJECT_LIT) { char buf [1000]; str_sprintf(buf, "DROP SEQUENCE \"%s\".\"%s\".\"%s\"", (char*)catName.data(), (char*)schName.data(), objName); cliRC = cliInterface.executeImmediate(buf); if (cliRC < 0 && cliRC != -CAT_OBJECT_DOES_NOT_EXIST_IN_TRAFODION) someObjectsCouldNotBeDropped = true; } } // For volatile schemas, sometimes only the objects get dropped. // If the dropObjectsOnly flag is set, just exit now, we are done. if (dropSchemaNode->dropObjectsOnly()) return; // Now drop any histogram objects if (histExists) { if (dropOneTable(cliInterface,(char*)catName.data(),(char*)schName.data(), (char*)HBASE_HISTINT_NAME,false)) someObjectsCouldNotBeDropped = true; if (dropOneTable(cliInterface,(char*)catName.data(),(char*)schName.data(), (char*)HBASE_HIST_NAME,false)) someObjectsCouldNotBeDropped = true; } if (someObjectsCouldNotBeDropped) { CmpCommon::diags()->clear(); *CmpCommon::diags() << DgSqlCode(-CAT_UNABLE_TO_DROP_SCHEMA) << DgSchemaName(catName + "." + schName); return; } // Verify all objects in the schema have been dropped. str_sprintf(query,"SELECT COUNT(*) " "FROM %s.\"%s\".%s " "WHERE catalog_name = '%s' AND schema_name = '%s' AND " "object_name <> '"SEABASE_SCHEMA_OBJECTNAME"'" "FOR READ COMMITTED ACCESS", getSystemCatalog(),SEABASE_MD_SCHEMA,SEABASE_OBJECTS, (char*)catName.data(),(char*)schName.data()); int32_t length = 0; int32_t rowCount = 0; cliRC = cliInterface.executeImmediate(query,(char*)&rowCount,&length,NULL); if (cliRC < 0) { cliInterface.retrieveSQLDiagnostics(CmpCommon::diags()); return; } if (rowCount > 0) { CmpCommon::diags()->clear(); *CmpCommon::diags() << DgSqlCode(-CAT_UNABLE_TO_DROP_SCHEMA) << DgSchemaName(catName + "." + schName); return; } // After all objects in the schema have been dropped, drop the schema object itself. char buf [1000]; str_sprintf(buf,"DELETE FROM %s.\"%s\".%s " "WHERE CATALOG_NAME = '%s' AND SCHEMA_NAME = '%s' AND " "OBJECT_NAME = '"SEABASE_SCHEMA_OBJECTNAME"'", getSystemCatalog(),SEABASE_MD_SCHEMA,SEABASE_OBJECTS, (char*)catName.data(),(char*)schName.data()); cliRC = cliInterface.executeImmediate(buf); if (cliRC < 0) *CmpCommon::diags() << DgSqlCode(-CAT_UNABLE_TO_DROP_SCHEMA) << DgSchemaName(catName + "." + schName); }
// ----------------------------------------------------------------------- // 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 CmpSeabaseDDL::dropSeabaseRoutine(StmtDDLDropRoutine * dropRoutineNode, NAString &currCatName, NAString &currSchName) { Lng32 retcode = 0; ComObjectName routineName(dropRoutineNode->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); ExpHbaseInterface * ehi = NULL; ExeCliInterface cliInterface(STMTHEAP, NULL, NULL, CmpCommon::context()->sqlSession()->getParentQid()); 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 == 0) // does not exist { *CmpCommon::diags() << DgSqlCode(-1389) << DgString0(extRoutineName); deallocEHI(ehi); processReturn(); return; } // get objectOwner Int64 objUID = 0; Int32 objectOwnerID = 0; Int32 schemaOwnerID = 0; Int64 objectFlags = 0; // see if routine is cached BindWA bindWA(ActiveSchemaDB(), CmpCommon::context(), FALSE/*inDDL*/); NARoutineDB *pRoutineDBCache = ActiveSchemaDB()->getNARoutineDB(); QualifiedName qualRoutineName(routineName, STMTHEAP); NARoutineDBKey key(qualRoutineName, STMTHEAP); NARoutine *cachedNARoutine = pRoutineDBCache->get(&bindWA, &key); if (cachedNARoutine) { objUID = cachedNARoutine->getRoutineID(); objectOwnerID = cachedNARoutine->getObjectOwner(); schemaOwnerID = cachedNARoutine->getSchemaOwner(); } else { objUID = getObjectInfo(&cliInterface, catalogNamePart.data(), schemaNamePart.data(), objectNamePart.data(), COM_USER_DEFINED_ROUTINE_OBJECT, objectOwnerID,schemaOwnerID,objectFlags); if (objUID < 0 || objectOwnerID == 0 || schemaOwnerID == 0) { deallocEHI(ehi); processReturn(); return; } } // Verify user has privilege to drop routine if (!isDDLOperationAuthorized(SQLOperation::DROP_ROUTINE,objectOwnerID,schemaOwnerID)) { *CmpCommon::diags() << DgSqlCode(-CAT_NOT_AUTHORIZED); deallocEHI(ehi); processReturn (); return; } // Determine if this function is referenced by any other objects. Lng32 cliRC = 0; Queue * usingViewsQueue = NULL; if (dropRoutineNode->getDropBehavior() == COM_RESTRICT_DROP_BEHAVIOR) { NAString usingObjName; cliRC = getUsingObject(&cliInterface, objUID, usingObjName); if (cliRC < 0) { deallocEHI(ehi); processReturn(); return; } if (cliRC != 100) // found an object { *CmpCommon::diags() << DgSqlCode(-CAT_DEPENDENT_VIEW_EXISTS) << DgTableName(usingObjName); deallocEHI(ehi); processReturn(); return; } } else if (dropRoutineNode->getDropBehavior() == COM_CASCADE_DROP_BEHAVIOR) { cliRC = getUsingViews(&cliInterface, objUID, usingViewsQueue); if (cliRC < 0) { deallocEHI(ehi); processReturn(); return; } } if (usingViewsQueue) { usingViewsQueue->position(); for (int idx = 0; idx < usingViewsQueue->numEntries(); idx++) { OutputInfo * vi = (OutputInfo*)usingViewsQueue->getNext(); char * viewName = vi->get(0); if (dropOneTableorView(cliInterface,viewName,COM_VIEW_OBJECT,false)) { deallocEHI(ehi); processReturn(); return; } } } // Removed routine from metadata if (dropSeabaseObject(ehi, dropRoutineNode->getRoutineName(), currCatName, currSchName, COM_USER_DEFINED_ROUTINE_OBJECT, TRUE, FALSE)) { deallocEHI(ehi); processReturn(); return; } // Remove cached entries in other processes pRoutineDBCache->removeNARoutine(qualRoutineName, NARoutineDB::REMOVE_FROM_ALL_USERS, objUID); deallocEHI(ehi); processReturn(); return; }
void CmpSeabaseDDL::dropSeabaseView( StmtDDLDropView * dropViewNode, NAString &currCatName, NAString &currSchName) { Lng32 cliRC = 0; Lng32 retcode = 0; const NAString &tabName = dropViewNode->getViewName(); ComObjectName viewName(tabName); 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); ExeCliInterface cliInterface(STMTHEAP, NULL, NULL, CmpCommon::context()->sqlSession()->getParentQid()); ExpHbaseInterface * ehi = allocEHI(); if (ehi == NULL) return; if ((isSeabaseReservedSchema(viewName)) && (!Get_SqlParser_Flags(INTERNAL_QUERY_FROM_EXEUTIL))) { *CmpCommon::diags() << DgSqlCode(-1119) << DgTableName(extViewName); deallocEHI(ehi); processReturn(); return; } retcode = existsInSeabaseMDTable(&cliInterface, catalogNamePart, schemaNamePart, objectNamePart, COM_VIEW_OBJECT, TRUE, FALSE); if (retcode < 0) { deallocEHI(ehi); processReturn(); return; } if (retcode == 0) // does not exist { *CmpCommon::diags() << DgSqlCode(-1389) << DgString0(extViewName); deallocEHI(ehi); processReturn(); return; } 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 drop view"); deallocEHI(ehi); processReturn(); return; } // Verify user can perform operation if (!isDDLOperationAuthorized(SQLOperation::DROP_VIEW,objectOwnerID,schemaOwnerID)) { *CmpCommon::diags() << DgSqlCode(-CAT_NOT_AUTHORIZED); deallocEHI(ehi); processReturn (); return; } Queue * usingViewsQueue = NULL; if (dropViewNode->getDropBehavior() == COM_RESTRICT_DROP_BEHAVIOR) { NAString usingObjName; cliRC = getUsingObject(&cliInterface, objUID, usingObjName); if (cliRC < 0) { deallocEHI(ehi); processReturn(); return; } if (cliRC != 100) // found an object { *CmpCommon::diags() << DgSqlCode(-1047) << DgTableName(usingObjName); deallocEHI(ehi); processReturn(); return; } } else if (dropViewNode->getDropBehavior() == COM_CASCADE_DROP_BEHAVIOR) { cliRC = getUsingViews(&cliInterface, objUID, usingViewsQueue); if (cliRC < 0) { deallocEHI(ehi); processReturn(); return; } } // get the list of all tables referenced by the view. Save this list so // referenced tables can be removed from cache later NAList<objectRefdByMe> tablesRefdList; short status = getListOfReferencedTables(&cliInterface, objUID, tablesRefdList); if (usingViewsQueue) { usingViewsQueue->position(); for (int idx = 0; idx < usingViewsQueue->numEntries(); idx++) { OutputInfo * vi = (OutputInfo*)usingViewsQueue->getNext(); char * viewName = vi->get(0); if (dropSeabaseObject(ehi, viewName, currCatName, currSchName, COM_VIEW_OBJECT)) { deallocEHI(ehi); processReturn(); return; } } } if (dropSeabaseObject(ehi, tabName, currCatName, currSchName, COM_VIEW_OBJECT)) { deallocEHI(ehi); processReturn(); return; } // clear view definition from my cache only. CorrName cn(objectNamePart, STMTHEAP, schemaNamePart, catalogNamePart); ActiveSchemaDB()->getNATableDB()->removeNATable(cn, NATableDB::REMOVE_MINE_ONLY, COM_VIEW_OBJECT); // clear view from all other caches here. This compensates for a // scenario where the object UID is not available in removeNATable, // and the look up failed too. Solution is just to use the objectUID // here. SQL_QIKEY qiKey; qiKey.operation[0] = 'O'; qiKey.operation[1] = 'R'; qiKey.ddlObjectUID = objUID; SQL_EXEC_SetSecInvalidKeys(1, &qiKey); // Now remove referenced tables from cache. // When a query that references a view is compiled, all views are converted // to the underlying base tables. Query plans are generated to access the // tables, and the views are no longer relevant. // When dropping a view, query plans that reference the dropped view will // continue to work if the plans are cached. This code removes the // referenced tables from caches to force recompilations so dropped views // are noticed. for (CollIndex i = 0; i < tablesRefdList.entries(); i++) { CorrName cn(tablesRefdList[i].objectName, STMTHEAP, tablesRefdList[i].schemaName, tablesRefdList[i].catalogName); ActiveSchemaDB()->getNATableDB()->removeNATable(cn, NATableDB::REMOVE_FROM_ALL_USERS, COM_BASE_TABLE_OBJECT); } deallocEHI(ehi); 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; }