| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| |
| /* -*-C++-*- |
| ***************************************************************************** |
| * |
| * File: CmpSeabaseDDLcleanup.cpp |
| * Description: Implements cleanup of metadata. |
| * |
| * |
| * Created: |
| * Language: C++ |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| |
| #include "CmpSeabaseDDLincludes.h" |
| #include "CmpDDLCatErrorCodes.h" |
| #include "CmpSeabaseDDLcleanup.h" |
| #include "ExpLOB.h" |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // Methods related to cleanup of objects from metadata. |
| ////////////////////////////////////////////////////////////////////////// |
| CmpSeabaseMDcleanup::CmpSeabaseMDcleanup(NAHeap *heap) |
| : CmpSeabaseDDL(heap), |
| objUID_(-1), |
| objectOwner_(-1), |
| indexesUIDlist_(NULL), |
| uniqueConstrUIDlist_(NULL), |
| refConstrUIDlist_(NULL), |
| seqUIDlist_(NULL), |
| usingViewsList_(NULL), |
| numLOBs_(0), |
| lobNumList_(NULL), |
| lobTypList_(NULL), |
| lobLocList_(NULL), |
| stopOnError_(FALSE), |
| cleanupMetadataEntries_(FALSE), |
| checkOnly_(FALSE), |
| returnDetails_(FALSE), |
| currReturnEntry_(0), |
| numOrphanMetadataEntries_(0), |
| numOrphanHbaseEntries_(0), |
| numOrphanObjectsEntries_(0), |
| numOrphanViewsEntries_(0), |
| numInconsistentHiveEntries_(0), |
| isHive_(FALSE) |
| {}; |
| |
| Int64 CmpSeabaseMDcleanup::getCleanupObjectUID( |
| ExeCliInterface *cliInterface, |
| const char * catName, |
| const char * schName, |
| const char * objName, |
| const char * inObjType, |
| char * outObjType, |
| Int32 &objectOwner) |
| { |
| Lng32 cliRC = 0; |
| Int64 objUID = -1; |
| objectOwner = -1; |
| |
| ExeCliInterface cqdCliInterface(STMTHEAP); |
| |
| // find object uid of this object from OBJECTS table |
| char shapeBuf[1000]; |
| str_sprintf(shapeBuf, "control query shape scan (path '%s.\"%s\".%s')", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS) ; |
| if (cqdCliInterface.setCQS(shapeBuf)) |
| { |
| cqdCliInterface.retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| objUID = getObjectUID(cliInterface, catName, schName, objName, |
| (strcmp(inObjType, COM_UNKNOWN_OBJECT_LIT) == 0 ? NULL : inObjType), |
| NULL, outObjType, FALSE); |
| cqdCliInterface.resetCQS(); |
| if (objUID != -1) // object exists |
| { |
| // find owner |
| cliRC = getObjectOwner(cliInterface, catName, schName, objName, |
| (strcmp(inObjType, COM_UNKNOWN_OBJECT_LIT) == 0 ? NULL : inObjType), |
| &objectOwner); |
| if (cliRC < 0) |
| { |
| // error trying to get owner. Ignore it and return invalid owner. |
| CmpCommon::diags()->clear(); |
| objectOwner = -1; |
| } |
| |
| return objUID; |
| } |
| |
| // didnt find it in OBJECTS table. Look for it in OBJECTS_UNIQ_IDX table |
| CmpCommon::diags()->clear(); |
| objectOwner = -1; // index does not contain owner info. |
| objUID = getObjectUID(cliInterface, catName, schName, objName, |
| (strcmp(inObjType, COM_UNKNOWN_OBJECT_LIT) == 0 ? NULL : inObjType), |
| NULL, outObjType, TRUE); |
| if (objUID != -1) |
| return objUID; |
| |
| // find object_uid of missing table by doing a select on COLUMNS with |
| // the specified column name and check that the corresponding object_uid |
| // doesn't exist in OBJECTS table |
| // *** TBD *** |
| |
| return -1; |
| } |
| |
| short CmpSeabaseMDcleanup::getCleanupObjectNameAndType( |
| ExeCliInterface *cliInterface, |
| Int64 objUID, |
| NAString &catName, |
| NAString &schName, |
| NAString &objName, |
| NAString &objType, |
| Int32 &objectOwner) |
| { |
| Lng32 cliRC = 0; |
| char objTypeBuf[10]; |
| |
| objectOwner = -1; |
| |
| // look in objects idx |
| cliRC = getObjectName(cliInterface, objUID, catName, schName, objName, objTypeBuf, |
| FALSE, TRUE); |
| if ((cliRC < 0) && |
| (cliRC != -1389)) |
| return -1; |
| |
| if (cliRC == -1389) // not found |
| { |
| CmpCommon::diags()->clear(); |
| |
| // look in objects table |
| cliRC = getObjectName(cliInterface, objUID, catName, schName, objName, objTypeBuf, |
| TRUE, FALSE); |
| if ((cliRC < 0) && |
| (cliRC != -1389)) |
| return -1; |
| |
| if (cliRC == -1389) // not found |
| { |
| CmpCommon::diags()->clear(); |
| objName = ""; |
| } |
| } |
| |
| if (cliRC == -1389) // not found |
| { |
| // assume object is base table type. |
| objType = COM_BASE_TABLE_OBJECT_LIT; |
| } |
| else |
| { |
| // found this object id |
| objType = objTypeBuf; |
| |
| // find the owner |
| cliRC = getObjectOwner(cliInterface, catName, schName, objName, |
| objType, |
| &objectOwner); |
| if (cliRC < 0) |
| { |
| // error trying to get owner or not found. Ignore it and return invalid owner. |
| CmpCommon::diags()->clear(); |
| objectOwner = -1; |
| } |
| |
| } |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::validateInputValues( |
| StmtDDLCleanupObjects * stmtCleanupNode, |
| ExeCliInterface *cliInterface) |
| { |
| Lng32 cliRC; |
| |
| objUID_ = -1; |
| objectOwner_ = -1; |
| objType_ = ""; |
| |
| NAString inObjType; |
| if (stmtCleanupNode->getType() == StmtDDLCleanupObjects::TABLE_) |
| inObjType = COM_BASE_TABLE_OBJECT_LIT; |
| else if (stmtCleanupNode->getType() == StmtDDLCleanupObjects::INDEX_) |
| inObjType = COM_INDEX_OBJECT_LIT; |
| else if (stmtCleanupNode->getType() == StmtDDLCleanupObjects::SEQUENCE_) |
| inObjType = COM_SEQUENCE_GENERATOR_OBJECT_LIT; |
| else if (stmtCleanupNode->getType() == StmtDDLCleanupObjects::VIEW_) |
| inObjType = COM_VIEW_OBJECT_LIT; |
| else if (stmtCleanupNode->getType() == StmtDDLCleanupObjects::SCHEMA_PRIVATE_) |
| inObjType = COM_PRIVATE_SCHEMA_OBJECT_LIT; |
| else if (stmtCleanupNode->getType() == StmtDDLCleanupObjects::SCHEMA_SHARED_) |
| inObjType = COM_SHARED_SCHEMA_OBJECT_LIT; |
| else if (stmtCleanupNode->getType() == StmtDDLCleanupObjects::UNKNOWN_) |
| inObjType = COM_UNKNOWN_OBJECT_LIT; |
| |
| if (NOT inObjType.isNull()) |
| { |
| QualifiedName *qn = stmtCleanupNode->getTableNameAsQualifiedName(); |
| catName_ = qn->getCatalogName(); |
| schName_ = qn->getSchemaName(); |
| objName_ = qn->getObjectName(); |
| |
| char outObjType[10]; |
| objUID_ = getCleanupObjectUID(cliInterface, |
| catName_.data(), schName_.data(), objName_.data(), |
| inObjType.data(), |
| outObjType, objectOwner_); |
| if ((objUID_ == -1) && // not found |
| (inObjType != COM_UNKNOWN_OBJECT_LIT && |
| inObjType != COM_PRIVATE_SCHEMA_OBJECT_LIT && |
| inObjType != COM_SHARED_SCHEMA_OBJECT_LIT)) // type explicitly specified |
| { |
| // check if there is another object type with the same name. |
| objUID_ = getCleanupObjectUID(cliInterface, |
| catName_.data(), schName_.data(), objName_.data(), |
| COM_UNKNOWN_OBJECT_LIT, |
| outObjType, objectOwner_); |
| if ((objUID_ != -1) &&// found it |
| (inObjType != outObjType)) |
| { |
| *CmpCommon::diags() << DgSqlCode(-4256) ; |
| return -1; |
| } |
| } |
| |
| if ((objUID_ != -1) && |
| (stmtCleanupNode->getObjectUID() != -1) && |
| (objUID_ != stmtCleanupNode->getObjectUID())) |
| { |
| *CmpCommon::diags() << DgSqlCode(-4253) ; |
| return -1; |
| } |
| |
| objType_ = ""; |
| if (inObjType == COM_UNKNOWN_OBJECT_LIT) |
| { |
| if (objUID_ == -1) |
| { |
| objType_ = COM_BASE_TABLE_OBJECT_LIT; |
| objectOwner_ = -1; |
| } |
| else |
| objType_ = outObjType; |
| } |
| else |
| objType_ = inObjType; |
| |
| if ((objUID_ == -1) && |
| (stmtCleanupNode->getObjectUID() != -1)) |
| { |
| CmpCommon::diags()->clear(); |
| objUID_ = stmtCleanupNode->getObjectUID(); |
| } |
| } |
| else if (stmtCleanupNode->getType() == StmtDDLCleanupObjects::OBJECT_UID_) |
| { |
| objUID_ = stmtCleanupNode->getObjectUID(); |
| |
| cliRC = getCleanupObjectNameAndType(cliInterface, objUID_, |
| catName_, schName_, objName_, |
| objType_, objectOwner_); |
| if (cliRC < 0) |
| return -1; |
| |
| } |
| else if (stmtCleanupNode->getType() == StmtDDLCleanupObjects::OBSOLETE_) |
| { |
| cleanupMetadataEntries_ = TRUE; |
| objectOwner_ = -1; |
| } |
| |
| isHive_ = FALSE; |
| if (catName_ == HIVE_SYSTEM_CATALOG) |
| isHive_ = TRUE; |
| |
| // generate hbase name that will be used to drop underlying hbase object |
| extNameForHbase_ = ""; |
| if ((NOT isHive_) && |
| ((objType_ == COM_BASE_TABLE_OBJECT_LIT) || |
| (objType_ == COM_INDEX_OBJECT_LIT))) |
| { |
| if (NOT (catName_.isNull() || schName_.isNull() || objName_.isNull())) |
| { |
| extNameForHbase_ = catName_ + "." + schName_ + "." + objName_; |
| } |
| } |
| else if (isHive_) |
| { |
| if (NOT ((schName_.compareTo(HIVE_DEFAULT_SCHEMA_EXE, NAString::ignoreCase) == 0) || |
| (schName_.compareTo(HIVE_SYSTEM_SCHEMA, NAString::ignoreCase) == 0))) |
| extNameForHive_ = schName_ + "."; |
| |
| extNameForHive_ += objName_; |
| } |
| |
| // Make sure user has necessary privileges to perform drop |
| if (!isDDLOperationAuthorized(SQLOperation::DROP_TABLE, |
| objectOwner_, |
| -1)) |
| { |
| *CmpCommon::diags() << DgSqlCode(-CAT_NOT_AUTHORIZED); |
| |
| return -1; |
| } |
| |
| if (stmtCleanupNode->checkOnly()) |
| checkOnly_ = TRUE; |
| |
| if (stmtCleanupNode->returnDetails()) |
| returnDetails_ = TRUE; |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::processCleanupErrors(ExeCliInterface *cliInterface, |
| NABoolean &errorSeen) |
| { |
| if (cliInterface) |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| |
| if (stopOnError_) |
| return -1; |
| |
| CmpCommon::diags()->negateAllErrors(); |
| |
| errorSeen = TRUE; |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::gatherDependentObjects(ExeCliInterface *cliInterface) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| |
| NABoolean errorSeen = FALSE; |
| if (objType_ == COM_BASE_TABLE_OBJECT_LIT) |
| { |
| // generate dependent index uid list |
| str_sprintf(query, "select index_uid from %s.\"%s\".%s where base_table_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_INDEXES, |
| objUID_); |
| |
| indexesUIDlist_ = NULL; |
| cliRC = cliInterface->fetchAllRows(indexesUIDlist_, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // generate unique constr list |
| str_sprintf(query, "select constraint_uid from %s.\"%s\".%s where table_uid = %ld and constraint_type = 'U' ", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_TABLE_CONSTRAINTS, |
| objUID_); |
| |
| uniqueConstrUIDlist_ = NULL; |
| cliRC = cliInterface->fetchAllRows(uniqueConstrUIDlist_, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // generate ref constr list |
| str_sprintf(query, "select constraint_uid from %s.\"%s\".%s where table_uid = %ld and constraint_type = 'F' ", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_TABLE_CONSTRAINTS, |
| objUID_); |
| |
| refConstrUIDlist_ = NULL; |
| cliRC = cliInterface->fetchAllRows(refConstrUIDlist_, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // generate sequences list for identity columns |
| str_sprintf(query, "select seq_uid from %s.\"%s\".%s where seq_uid in (select object_uid from %s.\"%s\".%s where catalog_name = '%s' and schema_name = '%s' and object_name like '\\_%s\\_%s\\_%s\\_%%' escape '\\' and object_type = 'SG')", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_SEQ_GEN, |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS, |
| catName_.data(), schName_.data(), |
| catName_.data(), schName_.data(), objName_.data()); |
| |
| seqUIDlist_ = NULL; |
| cliRC = cliInterface->fetchAllRows(seqUIDlist_, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| if (NOT extNameForHbase_.isNull()) |
| { |
| // Base object name exists. Generate LOB info list |
| lobMDNameBuf_ = new(STMTHEAP) char[1024]; |
| Lng32 lobMDNameLen = 1024; |
| |
| char * lobDescHandleObjNamePrefix = |
| ExpLOBoper::ExpGetLOBDescHandleObjNamePrefix(objUID_, |
| lobMDNameBuf_, lobMDNameLen); |
| |
| str_sprintf(query, "select object_name from %s.\"%s\".%s where catalog_name = '%s' and schema_name = '%s' and object_name like '%s%%' and object_type = 'BT' ", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS, |
| getSystemCatalog(), schName_.data(), lobDescHandleObjNamePrefix); |
| |
| Queue *lobDescList = NULL; |
| cliRC = cliInterface->fetchAllRows(lobDescList, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| if (lobDescList->numEntries() > 0) |
| { |
| numLOBs_ = lobDescList->numEntries(); |
| lobNumList_ = new (STMTHEAP) short[numLOBs_]; |
| lobTypList_ = new (STMTHEAP) short[numLOBs_]; |
| lobLocList_ = new (STMTHEAP) char*[numLOBs_]; |
| |
| lobDescList->position(); |
| for (size_t i = 0; i < lobDescList->numEntries(); i++) |
| { |
| OutputInfo * oi = (OutputInfo*)lobDescList->getCurr(); |
| char * name = (char*)oi->get(0); |
| |
| Lng32 lobNum = |
| ExpLOBoper::ExpGetLOBnumFromDescName(name, strlen(name)); |
| lobNumList_[i] = lobNum; |
| |
| lobTypList_[i] = Lob_HDFS_File; |
| |
| char * loc = new (STMTHEAP) char[1024]; |
| const char* f = ActiveSchemaDB()->getDefaults(). |
| getValue(LOB_STORAGE_FILE_DIR); |
| strcpy(loc, f); |
| lobLocList_[i] = loc; |
| |
| lobDescList->advance(); |
| } |
| |
| lobMDName_ = (char*) |
| ExpLOBoper::ExpGetLOBMDName(schName_.length(), (char*)schName_.data(), objUID_, |
| lobMDNameBuf_, lobMDNameLen); |
| } |
| } |
| } // COM_BASE_TABLE_OBJECT |
| |
| if ((objType_ == COM_BASE_TABLE_OBJECT_LIT) || |
| (objType_ == COM_VIEW_OBJECT_LIT)) |
| { |
| // get views that use this object. |
| cliRC = getUsingViews(cliInterface, objUID_, usingViewsList_); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(NULL, errorSeen)) |
| return -1; |
| } |
| } |
| |
| if (isHive_) |
| { |
| // if this hive table has an external table, get its uid |
| NAString extTableName; |
| extTableName = ComConvertNativeNameToTrafName(catName_, schName_, objName_); |
| if (NOT extTableName.isNull()) |
| { |
| QualifiedName qn(extTableName, 3); |
| Int64 extObjUID = |
| getObjectUID(cliInterface, |
| qn.getCatalogName(), qn.getSchemaName(), qn.getObjectName(), |
| COM_BASE_TABLE_OBJECT_LIT, |
| NULL, NULL, FALSE, |
| FALSE); |
| if (extObjUID > 0) |
| { |
| char query[1000]; |
| str_sprintf(query, "cleanup uid %ld", extObjUID); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| } |
| } |
| } |
| |
| if (errorSeen) |
| return -1; |
| else |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::deleteMDentries(ExeCliInterface *cliInterface) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| |
| NABoolean errorSeen = FALSE; |
| |
| // OBJECTS table |
| |
| // Must first hide the index to OBJECTS, because the delete plan would otherwise |
| // likely access OBJECTS_UNIQ_IDX first then join that to OBJECTS (as OBJECT_UID |
| // is the leading part of the index key). If the index row were missing, we'd |
| // fail to delete the base table row. Right now OBJECTS is the only metadata |
| // table with an index, so this is the only place we need to take this precaution. |
| |
| cliRC = cliInterface->holdAndSetCQD("HIDE_INDEXES","ALL", NULL); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // Now delete from OBJECTS (but not its index) |
| |
| str_sprintf(query, "delete from %s.\"%s\".%s where object_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS, |
| objUID_); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // Restore previous setting of CQD HIDE_INDEXES |
| |
| cliRC = cliInterface->restoreCQD("HIDE_INDEXES", NULL); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // OBJECTS index |
| str_sprintf(query, "delete from table(index_table %s.\"%s\".%s) where \"OBJECT_UID@\" = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS_UNIQ_IDX, |
| objUID_); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // COLUMNS table |
| str_sprintf(query, "delete from %s.\"%s\".%s where object_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_COLUMNS, |
| objUID_); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // KEYS table |
| str_sprintf(query, "delete from %s.\"%s\".%s where object_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_KEYS, |
| objUID_); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // TABLES table |
| str_sprintf(query, "delete from %s.\"%s\".%s where table_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_TABLES, |
| objUID_); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // delete index entries |
| str_sprintf(query, "delete from %s.\"%s\".%s where base_table_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_INDEXES, |
| objUID_); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // TEXT entries |
| str_sprintf(query, "delete from %s.\"%s\".%s where text_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_TEXT, |
| objUID_); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| if (errorSeen) |
| return -1; |
| else |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::deleteMDConstrEntries(ExeCliInterface *cliInterface) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| |
| if (uniqueConstrUIDlist_) |
| { |
| uniqueConstrUIDlist_->position(); |
| for (size_t i = 0; i < uniqueConstrUIDlist_->numEntries(); i++) |
| { |
| Int64 ucUID; |
| |
| OutputInfo * oi = (OutputInfo*)uniqueConstrUIDlist_->getCurr(); |
| ucUID = *(Int64*)oi->get(0); |
| |
| str_sprintf(query, "delete from %s.\"%s\".%s where unique_constraint_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_REF_CONSTRAINTS, |
| ucUID); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| str_sprintf(query, "delete from %s.\"%s\".%s where unique_constraint_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_UNIQUE_REF_CONSTR_USAGE, |
| ucUID); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| uniqueConstrUIDlist_->advance(); |
| } // for |
| } |
| |
| if (refConstrUIDlist_) |
| { |
| refConstrUIDlist_->position(); |
| for (size_t i = 0; i < refConstrUIDlist_->numEntries(); i++) |
| { |
| Int64 rcUID; |
| |
| OutputInfo * oi = (OutputInfo*)refConstrUIDlist_->getCurr(); |
| rcUID = *(Int64*)oi->get(0); |
| str_sprintf(query, "delete from %s.\"%s\".%s where ref_constraint_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_REF_CONSTRAINTS, |
| rcUID); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| str_sprintf(query, "delete from %s.\"%s\".%s where foreign_constraint_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_UNIQUE_REF_CONSTR_USAGE, |
| rcUID); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| refConstrUIDlist_->advance(); |
| } // for |
| } |
| |
| str_sprintf(query, "delete from %s.\"%s\".%s where object_uid in (select constraint_uid from %s.\"%s\".%s where table_uid = %ld)", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS, |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_TABLE_CONSTRAINTS, |
| objUID_); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| str_sprintf(query, "delete from %s.\"%s\".%s where table_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_TABLE_CONSTRAINTS, |
| objUID_); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::deleteMDViewEntries(ExeCliInterface *cliInterface) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| |
| str_sprintf(query, "delete from %s.\"%s\".%s where view_uid = %ld", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_VIEWS, |
| objUID_); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| str_sprintf(query, "delete from %s.\"%s\".%s where used_object_uid = %ld and used_object_type = '%s' ", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_VIEWS_USAGE, |
| objUID_, |
| objType_.data()); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::deleteHistogramEntries(ExeCliInterface *cliInterface) |
| { |
| if (isHistogramTable(objName_)) |
| return 0; |
| |
| Lng32 cliRC = 0; |
| char query[1000]; |
| |
| if ((objType_ == COM_BASE_TABLE_OBJECT_LIT) && |
| (objUID_ > 0) && |
| (NOT catName_.isNull()) && |
| (NOT schName_.isNull())) |
| { |
| if (NOT isHive_) |
| { |
| if (dropSeabaseStats(cliInterface, catName_.data(), schName_.data(), objUID_)) |
| return -1; |
| } |
| else |
| { |
| if (dropSeabaseStats(cliInterface, HIVE_STATS_CATALOG, |
| HIVE_STATS_SCHEMA_NO_QUOTES, objUID_)) |
| return -1; |
| } |
| } |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::dropIndexes(ExeCliInterface *cliInterface) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| |
| if ((! indexesUIDlist_) || |
| (indexesUIDlist_->numEntries() == 0)) |
| return 0; |
| |
| indexesUIDlist_->position(); |
| for (size_t i = 0; i < indexesUIDlist_->numEntries(); i++) |
| { |
| Int64 iUID; |
| |
| OutputInfo * oi = (OutputInfo*)indexesUIDlist_->getCurr(); |
| iUID = *(Int64*)oi->get(0); |
| |
| str_sprintf(query, "cleanup uid %ld", |
| iUID); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| indexesUIDlist_->advance(); |
| } |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::dropSequences(ExeCliInterface *cliInterface) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| |
| if ((! seqUIDlist_) || |
| (seqUIDlist_->numEntries() == 0)) |
| return 0; |
| |
| seqUIDlist_->position(); |
| for (size_t i = 0; i < seqUIDlist_->numEntries(); i++) |
| { |
| Int64 iUID; |
| |
| OutputInfo * oi = (OutputInfo*)seqUIDlist_->getCurr(); |
| iUID = *(Int64*)oi->get(0); |
| |
| str_sprintf(query, "cleanup uid %ld", |
| iUID); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| seqUIDlist_->advance(); |
| } |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::dropLOBs(ExeCliInterface *cliInterface) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| |
| if (objUID_ == -1) |
| return 0; |
| |
| if (catName_.isNull() || schName_.isNull()) |
| return 0; |
| |
| if (! lobMDName_) |
| return 0; |
| NABoolean lobTrace=FALSE; |
| if (getenv("TRACE_LOB_ACTIONS")) |
| lobTrace=TRUE; |
| NAString newSchName = "\"" + catName_ + "\"" + "." + "\"" + schName_ + "\""; |
| const char *lobHdfsServer = CmpCommon::getDefaultString(LOB_HDFS_SERVER); |
| Int32 lobHdfsPort = (Lng32)CmpCommon::getDefaultNumeric(LOB_HDFS_PORT); |
| cliRC = SQL_EXEC_LOBddlInterface((char*)newSchName.data(), |
| newSchName.length(), |
| objUID_, |
| numLOBs_, |
| LOB_CLI_CLEANUP, |
| lobNumList_, |
| lobTypList_, |
| lobLocList_, |
| NULL, |
| (char *)lobHdfsServer, |
| lobHdfsPort,0,lobTrace); |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::dropUsingViews(ExeCliInterface *cliInterface) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| |
| if ((! usingViewsList_) || |
| (usingViewsList_->numEntries() == 0)) |
| return 0; |
| |
| usingViewsList_->position(); |
| for (size_t i = 0; i < usingViewsList_->numEntries(); i++) |
| { |
| OutputInfo * oi = (OutputInfo*)usingViewsList_->getCurr(); |
| char * viewName = (char*)oi->get(0); |
| |
| str_sprintf(query, "cleanup view %s ", |
| viewName); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| usingViewsList_->advance(); |
| } |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::deletePrivs(ExeCliInterface *cliInterface) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| |
| if (NOT isAuthorizationEnabled()) |
| return 0; |
| |
| str_sprintf(query, "delete from %s.\"%s\".%s where object_uid = %ld", |
| getSystemCatalog(), SEABASE_PRIVMGR_SCHEMA, "OBJECT_PRIVILEGES", |
| objUID_); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| void CmpSeabaseMDcleanup::cleanupSchemaObjects(ExeCliInterface *cliInterface) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| |
| NABoolean errorSeen = FALSE; |
| |
| if (objUID_ == -1) |
| { |
| CmpCommon::diags()->clear(); |
| |
| ComSchemaName sn(catName_, schName_); |
| *CmpCommon::diags() << DgSqlCode(4255) |
| << DgSchemaName(sn.getExternalName().data()); |
| } |
| |
| Queue *schObjList = NULL; |
| str_sprintf(query, "select object_uid, object_type, object_name from %s.\"%s\".%s where catalog_name = '%s' and schema_name = '%s' ", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS, |
| catName_.data(), schName_.data()); |
| |
| schObjList = NULL; |
| cliRC = cliInterface->fetchAllRows(schObjList, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return; |
| } |
| |
| stopOnError_ = FALSE; |
| NABoolean cannotDropSchema = FALSE; |
| |
| // Drop histogram tables first |
| schObjList->position(); |
| for (size_t i = 0; i < schObjList->numEntries(); i++) |
| { |
| OutputInfo * oi = (OutputInfo*)schObjList->getCurr(); |
| Int64 uid = *(Int64*)oi->get(0); |
| NAString obj_name((char*)oi->get(2)); |
| if (isHistogramTable(obj_name)) |
| { |
| str_sprintf(query, "cleanup uid %ld", uid); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(NULL, errorSeen)) |
| return; |
| } |
| CorrName cn(objName_, STMTHEAP, schName_, catName_); |
| ActiveSchemaDB()->getNATableDB()->removeNATable |
| ( |
| cn, |
| ComQiScope::REMOVE_FROM_ALL_USERS, |
| COM_BASE_TABLE_OBJECT, |
| FALSE, FALSE |
| ); |
| } |
| schObjList->advance(); |
| } |
| |
| // Now drop remaining objects |
| schObjList->position(); |
| for (size_t i = 0; i < schObjList->numEntries(); i++) |
| { |
| OutputInfo * oi = (OutputInfo*)schObjList->getCurr(); |
| Int64 uid = *(Int64*)oi->get(0); |
| |
| NAString obj_type((char*)oi->get(1)); |
| |
| if ((obj_type == COM_LIBRARY_OBJECT_LIT) || |
| (obj_type == COM_STORED_PROCEDURE_OBJECT_LIT) || |
| (obj_type == COM_USER_DEFINED_ROUTINE_OBJECT)) |
| { |
| schObjList->advance(); |
| cannotDropSchema = TRUE; |
| continue; |
| } |
| |
| if (NOT ((obj_type == COM_BASE_TABLE_OBJECT_LIT) || |
| (obj_type == COM_INDEX_OBJECT_LIT) || |
| (obj_type == COM_VIEW_OBJECT_LIT) || |
| (obj_type == COM_SEQUENCE_GENERATOR_OBJECT_LIT))) |
| { |
| schObjList->advance(); |
| continue; |
| } |
| |
| str_sprintf(query, "cleanup uid %ld", uid); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(NULL, errorSeen)) |
| return; |
| } |
| |
| schObjList->advance(); |
| } // for |
| |
| if (NOT cannotDropSchema) |
| { |
| // delete schema object row from objects table |
| str_sprintf(query, "delete from %s.\"%s\".%s where catalog_name = '%s' and schema_name = '%s' and object_name = '%s' ", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS, |
| (char*)catName_.data(),(char*)schName_.data(), |
| SEABASE_SCHEMA_OBJECTNAME); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(NULL, errorSeen)) |
| return; |
| } |
| } |
| |
| return; |
| } |
| |
| short CmpSeabaseMDcleanup::cleanupUIDs(ExeCliInterface *cliInterface, |
| Queue *entriesList, |
| CmpDDLwithStatusInfo *dws) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| NABoolean errorSeen = FALSE; |
| |
| if (checkOnly_) |
| return 0; |
| |
| entriesList->position(); |
| for (size_t i = 0; i < entriesList->numEntries(); i++) |
| { |
| OutputInfo * oi = (OutputInfo*)entriesList->getCurr(); |
| Int64 objUID = *(Int64*)oi->get(0); |
| |
| str_sprintf(query, "cleanup uid %ld", objUID); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(NULL, errorSeen)) |
| return -1; |
| } |
| |
| entriesList->advance(); |
| } |
| |
| return 0; |
| } |
| |
| void CmpSeabaseMDcleanup::cleanupHBaseObject(const StmtDDLCleanupObjects * stmtCleanupNode, |
| ExeCliInterface *cliInterface) |
| { |
| |
| Lng32 cliRC = 0; |
| char query[1000]; |
| NABoolean errorSeen = FALSE; |
| |
| NAString objName(stmtCleanupNode->getTableNameAsQualifiedName()->getObjectName()); |
| |
| // drop external table |
| str_sprintf(query, "drop external table if exists %s;", |
| objName.data()); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(NULL, errorSeen)) |
| return; |
| } |
| |
| // unregister registered table |
| str_sprintf(query, "unregister hbase table if exists %s cleanup;", |
| objName.data()); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(NULL, errorSeen)) |
| return; |
| } |
| |
| return; |
| } |
| |
| short CmpSeabaseMDcleanup::addReturnDetailsEntry( |
| ExeCliInterface * cliInterface, |
| Queue* &list, const char *value, |
| NABoolean init, |
| NABoolean isUID) |
| { |
| if (NOT returnDetails_) |
| return 0; |
| |
| if (init) |
| { |
| cliInterface->initializeInfoList(list, TRUE); |
| currReturnEntry_ = 0; |
| |
| return 0; |
| } |
| |
| currReturnEntry_++; |
| |
| OutputInfo * oi = new(STMTHEAP) OutputInfo(1); |
| |
| char * r = new(STMTHEAP) char[100+strlen(value) + 1]; |
| str_sprintf(r, " Entry #%d%s %s", currReturnEntry_, |
| (isUID ? "(UID): " : "(OBJECT):"), |
| value); |
| oi->insert(0, r, strlen(r)+1); |
| list->insert(oi); |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::addReturnDetailsEntryFromList( |
| ExeCliInterface * cliInterface, |
| Queue* fromList, Lng32 fromIndex, |
| Queue* toList, |
| NABoolean isUID) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| NABoolean errorSeen = FALSE; |
| |
| if (NOT returnDetails_) |
| return 0; |
| |
| fromList->position(); |
| for (size_t i = 0; i < fromList->numEntries(); i++) |
| { |
| OutputInfo * oi = (OutputInfo*)fromList->getCurr(); |
| char * val = (char*)oi->get(fromIndex); |
| |
| if (addReturnDetailsEntry(cliInterface, toList, val, FALSE, isUID)) |
| return -1; |
| |
| fromList->advance(); |
| } |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::cleanupOrphanObjectsEntries(ExeCliInterface *cliInterface, |
| ExpHbaseInterface *ehi, |
| CmpDDLwithStatusInfo *dws) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| NABoolean errorSeen = FALSE; |
| |
| // find out all entries which do not have corresponding hbase objects. |
| // Do not include metadata, repository and external tables. |
| str_sprintf(query, "select object_uid, trim(catalog_name) || '.' || trim(schema_name) || '.' || trim(object_name) from %s.\"%s\".%s where catalog_name = '%s' and schema_name not in ( '_MD_', '_REPOS_', '_PRIVMGR_MD_') and schema_name not like '|_HV|_%%|_' escape '|' and schema_name not like '|_HB|_%%|_' escape '|' and (object_type = 'BT' or object_type = 'IX') ", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS, |
| getSystemCatalog()); |
| cliRC = cliInterface->fetchRowsPrologue(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| obsoleteEntriesList_ = new(STMTHEAP) Queue(STMTHEAP); |
| returnDetailsList_ = NULL; |
| addReturnDetailsEntry(cliInterface, returnDetailsList_, NULL, TRUE); |
| |
| while (cliRC != 100) |
| { |
| cliRC = cliInterface->fetch(); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| if (cliRC != 100) |
| { |
| char * ptr; |
| Lng32 len; |
| |
| cliInterface->getPtrAndLen(1, ptr, len); |
| Int64 objUID = *(Int64*)ptr; |
| |
| cliInterface->getPtrAndLen(2, ptr, len); |
| NAString extNameForHbase(ptr, len); |
| |
| // check to see if this object exists in hbase |
| short rc = existsInHbase(extNameForHbase, ehi); // exists |
| if (rc == 0) // does not exist |
| { |
| OutputInfo * oi = new(STMTHEAP) OutputInfo(1); |
| char * r = new(STMTHEAP) char[sizeof(Int64)]; |
| str_cpy_all(r, (char*)&objUID, sizeof(Int64)); |
| oi->insert(0, r, sizeof(Int64)); |
| |
| obsoleteEntriesList_->insert(oi); |
| |
| if (addReturnDetailsEntry(cliInterface, returnDetailsList_, |
| extNameForHbase.data(), FALSE)) |
| return -1; |
| } |
| } |
| } |
| |
| cliRC = cliInterface->fetchRowsEpilogue(0); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| if (cleanupUIDs(cliInterface, obsoleteEntriesList_, dws)) |
| return -1; |
| |
| numOrphanMetadataEntries_ = obsoleteEntriesList_->numEntries(); |
| |
| return 0; |
| } |
| |
| // cleanup user objects that exist in hbase but not in metadata. |
| short CmpSeabaseMDcleanup::cleanupOrphanHbaseEntries(ExeCliInterface *cliInterface, |
| ExpHbaseInterface *ehi, |
| CmpDDLwithStatusInfo *dws) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| NABoolean errorSeen = FALSE; |
| |
| // list all hbase objects that start with TRAFODION.* |
| NAArray<HbaseStr>* listArray = ehi->listAll("TRAFODION\\..*"); |
| if (! listArray) |
| return -1; |
| |
| returnDetailsList_ = NULL; |
| addReturnDetailsEntry(cliInterface, returnDetailsList_, NULL, TRUE); |
| |
| numOrphanHbaseEntries_ = 0; |
| for (Int32 i = 0; i < listArray->entries(); i++) |
| { |
| char cBuf[1000]; |
| |
| HbaseStr *hbaseStr = &listArray->at(i); |
| if (hbaseStr->len >= sizeof(cBuf)) |
| hbaseStr->len = sizeof(cBuf)-1; |
| strncpy(cBuf, hbaseStr->val, hbaseStr->len); |
| cBuf[hbaseStr->len] = '\0'; |
| char *c = cBuf; |
| Lng32 numParts = 0; |
| char *parts[4]; |
| LateNameInfo::extractParts(c, cBuf, numParts, parts, FALSE); |
| |
| NAString catalogNamePart(parts[0]); |
| NAString schemaNamePart(parts[1]); |
| NAString objectNamePart(parts[2]); |
| const NAString extTableName = |
| catalogNamePart + "." + "\"" + schemaNamePart + "\"" + "." + "\"" + objectNamePart + "\""; |
| const NAString extHbaseName = |
| catalogNamePart + "." + schemaNamePart + "." + objectNamePart; |
| |
| if ((schemaNamePart == SEABASE_MD_SCHEMA) || |
| (schemaNamePart == SEABASE_REPOS_SCHEMA) || |
| (schemaNamePart == SEABASE_DTM_SCHEMA) || |
| (schemaNamePart == SEABASE_PRIVMGR_SCHEMA)) |
| continue; |
| |
| // check if this object exists in metadata. |
| Int64 objUID = getObjectUID(cliInterface, |
| catalogNamePart.data(), |
| schemaNamePart.data(), |
| objectNamePart.data(), |
| NULL); |
| if (objUID != -1) // found in metadata |
| continue; |
| |
| // not found or error. Clear diags and continue. |
| CmpCommon::diags()->clear(); |
| |
| numOrphanHbaseEntries_++; |
| |
| if (addReturnDetailsEntry(cliInterface, returnDetailsList_, |
| extHbaseName.data(), FALSE)) |
| return -1; |
| |
| if (checkOnly_) |
| continue; |
| |
| // this object could be a table or an index. Try to cleanup both. |
| str_sprintf(query, "cleanup table %s", extTableName.data()); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(NULL, errorSeen)) |
| return -1; |
| } |
| |
| str_sprintf(query, "cleanup index %s", extTableName.data()); |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(NULL, errorSeen)) |
| return -1; |
| } |
| |
| } // for |
| deleteNAArray(ehi->getHeap(),listArray); |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::cleanupInconsistentObjectsEntries(ExeCliInterface *cliInterface, |
| ExpHbaseInterface *ehi, |
| CmpDDLwithStatusInfo *dws) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| NABoolean errorSeen = FALSE; |
| |
| numOrphanObjectsEntries_ = 0; |
| |
| obsoleteEntriesList_ = NULL; |
| returnDetailsList_ = NULL; |
| |
| addReturnDetailsEntry(cliInterface, returnDetailsList_, NULL, TRUE); |
| |
| str_sprintf(query, "control query shape join(scan(path '%s'), scan(path '%s'))", |
| SEABASE_OBJECTS, SEABASE_OBJECTS_UNIQ_IDX); |
| |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| // find out all entries that exist in OBJECTS but not in OBJECTS_UNIQ_IDX |
| str_sprintf(query, "select object_uid, trim(catalog_name) || '.' || trim(schema_name) || '.' || trim(object_name) from %s.\"%s\".%s where catalog_name = '%s' and schema_name not in ( '_MD_', '_REPOS_', '_PRIVMGR_MD_') and object_uid not in (select \"OBJECT_UID@\" from table(index_table %s.\"%s\".%s))", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS, |
| getSystemCatalog(), |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS_UNIQ_IDX); |
| |
| cliRC = cliInterface->fetchAllRows(obsoleteEntriesList_, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| if (cleanupUIDs(cliInterface, obsoleteEntriesList_, dws)) |
| return -1; |
| |
| addReturnDetailsEntryFromList(cliInterface, obsoleteEntriesList_, 1/*0 based*/, |
| returnDetailsList_); |
| |
| numOrphanObjectsEntries_ += obsoleteEntriesList_->numEntries(); |
| |
| // find out all entries that exist in OBJECTS_UNIQ_IDX but not in OBJECTS |
| str_sprintf(query, "control query shape join(scan(path '%s'), scan(path '%s'))", |
| SEABASE_OBJECTS_UNIQ_IDX, SEABASE_OBJECTS); |
| |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| str_sprintf(query, "select \"OBJECT_UID@\", trim(catalog_name) || '.' || trim(schema_name) || '.' || trim(object_name) from table(index_table %s.\"%s\".%s) where catalog_name = '%s' and schema_name not in ( '_MD_', '_REPOS_', '_PRIVMGR_MD_') and \"OBJECT_UID@\" not in (select object_uid from %s.\"%s\".%s)", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS_UNIQ_IDX, |
| getSystemCatalog(), |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS); |
| |
| cliRC = cliInterface->fetchAllRows(obsoleteEntriesList_, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| cliRC = cliInterface->executeImmediate("control query shape cut;"); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| if (cleanupUIDs(cliInterface, obsoleteEntriesList_, dws)) |
| return -1; |
| |
| addReturnDetailsEntryFromList(cliInterface, obsoleteEntriesList_, 1/*0 based*/, |
| returnDetailsList_); |
| |
| numOrphanObjectsEntries_ += obsoleteEntriesList_->numEntries(); |
| |
| // cleanup entries in columns table which are not in objects table |
| str_sprintf(query, "control query shape groupby(join(scan(path '%s'), scan(path '%s')))", |
| SEABASE_COLUMNS, SEABASE_OBJECTS); |
| |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| str_sprintf(query, "select distinct object_uid, cast(object_uid as varchar(30) not null) from %s.\"%s\".%s where object_uid not in (select object_uid from %s.\"%s\".%s) ", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_COLUMNS, |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS); |
| |
| cliRC = cliInterface->fetchAllRows(obsoleteEntriesList_, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| cliRC = cliInterface->executeImmediate("control query shape cut;"); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| if (cleanupUIDs(cliInterface, obsoleteEntriesList_, dws)) |
| return -1; |
| |
| addReturnDetailsEntryFromList(cliInterface, obsoleteEntriesList_, 1/*0 based*/, |
| returnDetailsList_, TRUE/*UID*/); |
| |
| numOrphanObjectsEntries_ += obsoleteEntriesList_->numEntries(); |
| |
| return 0; |
| } |
| |
| short CmpSeabaseMDcleanup::cleanupOrphanViewsEntries(ExeCliInterface *cliInterface, |
| ExpHbaseInterface *ehi, |
| CmpDDLwithStatusInfo *dws) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| NABoolean errorSeen = FALSE; |
| |
| numOrphanViewsEntries_ = 0; |
| obsoleteEntriesList_ = NULL; |
| |
| returnDetailsList_ = NULL; |
| addReturnDetailsEntry(cliInterface, returnDetailsList_, NULL, TRUE); |
| |
| // find out all entries in views_usage that dont have corresponding used object |
| str_sprintf(query, "control query shape groupby(join(scan(path '%s'), scan(path '%s')))", |
| SEABASE_VIEWS_USAGE, SEABASE_OBJECTS); |
| |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| str_sprintf(query, "select distinct used_object_uid, cast(used_object_uid as varchar(30) not null) from %s.\"%s\".%s where used_object_uid not in (select object_uid from %s.\"%s\".%s)", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_VIEWS_USAGE, |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS); |
| |
| cliRC = cliInterface->fetchAllRows(obsoleteEntriesList_, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| cliRC = cliInterface->executeImmediate("control query shape cut;"); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| if (cleanupUIDs(cliInterface, obsoleteEntriesList_, dws)) |
| return -1; |
| |
| addReturnDetailsEntryFromList(cliInterface, obsoleteEntriesList_, 1/*0 based*/, |
| returnDetailsList_, TRUE/*UID*/); |
| |
| numOrphanObjectsEntries_ += obsoleteEntriesList_->numEntries(); |
| |
| // find out all entries in VIEWS that do not exist in OBJECTS |
| str_sprintf(query, "control query shape join(scan(path '%s'), scan(path '%s'))", |
| SEABASE_VIEWS, SEABASE_OBJECTS); |
| |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| str_sprintf(query, "select view_uid, cast(view_uid as varchar(30) not null) from %s.\"%s\".%s where view_uid not in (select object_uid from %s.\"%s\".%s)", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_VIEWS, |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS); |
| |
| cliRC = cliInterface->fetchAllRows(obsoleteEntriesList_, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| cliRC = cliInterface->executeImmediate("control query shape cut;"); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| if (cleanupUIDs(cliInterface, obsoleteEntriesList_, dws)) |
| return -1; |
| |
| addReturnDetailsEntryFromList(cliInterface, obsoleteEntriesList_, 1/*0 based*/, |
| returnDetailsList_, TRUE/*UID*/); |
| |
| numOrphanObjectsEntries_ += obsoleteEntriesList_->numEntries(); |
| |
| return 0; |
| } |
| |
| // remove hive objects that are registered in traf metadata but the |
| // corresponding object is missing in hive database. |
| short CmpSeabaseMDcleanup::cleanupInconsistentHiveEntries( |
| ExeCliInterface *cliInterface, |
| ExpHbaseInterface *ehi) |
| { |
| Lng32 cliRC = 0; |
| char query[4000]; |
| NABoolean errorSeen = FALSE; |
| |
| // get all registered tables that do not have corresponding hive objects. |
| str_sprintf(query, "select trim(O.a), 'table' from " |
| "(select lower(trim(catalog_name) || '.' || trim(schema_name)" |
| " || '.' || trim(object_name)) from %s.\"%s\".%s " |
| "where object_type = '%s' and catalog_name = 'HIVE') O(a) left join " |
| "(select '%s' || '.' || trim(y) from " |
| "(get tables in catalog %s, no header) x(y)) G(b) " |
| "on O.a = G.b where G.b is null " |
| " union all " |
| "select trim(O.a), 'view' from " |
| "(select lower(trim(catalog_name) || '.' || trim(schema_name)" |
| " || '.' || trim(object_name)) from %s.\"%s\".%s " |
| "where object_type = '%s' and catalog_name = 'HIVE') O(a) left join " |
| "(select '%s' || '.' || trim(y) from " |
| "(get views in catalog %s, no header) x(y)) G(b) " |
| "on O.a = G.b where G.b is null ;", |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS, |
| COM_BASE_TABLE_OBJECT_LIT, |
| HIVE_SYSTEM_CATALOG_LC, |
| HIVE_SYSTEM_CATALOG_LC, |
| getSystemCatalog(), SEABASE_MD_SCHEMA, SEABASE_OBJECTS, |
| COM_VIEW_OBJECT_LIT, |
| HIVE_SYSTEM_CATALOG_LC, |
| HIVE_SYSTEM_CATALOG_LC); |
| Queue * orphanHiveObjs = NULL; |
| cliRC = cliInterface->fetchAllRows |
| (orphanHiveObjs, query, 0, FALSE, FALSE, TRUE); |
| if (cliRC < 0) |
| { |
| if (processCleanupErrors(cliInterface, errorSeen)) |
| return -1; |
| } |
| |
| numInconsistentHiveEntries_ = 0; |
| returnDetailsList_ = NULL; |
| addReturnDetailsEntry(cliInterface, returnDetailsList_, NULL, TRUE); |
| |
| numInconsistentHiveEntries_ += orphanHiveObjs->numEntries(); |
| |
| orphanHiveObjs->position(); |
| for (size_t i = 0; i < orphanHiveObjs->numEntries(); i++) |
| { |
| |
| OutputInfo * oi = (OutputInfo*)orphanHiveObjs->getCurr(); |
| |
| if (addReturnDetailsEntry(cliInterface, returnDetailsList_, |
| oi->get(0), FALSE)) |
| return -1; |
| |
| if (NOT checkOnly_) |
| { |
| if (strcmp(oi->get(1), "table") == 0) |
| str_sprintf(query, "unregister hive table if exists %s cleanup;", |
| oi->get(0)); |
| else |
| str_sprintf(query, "unregister hive view if exists %s cleanup;", |
| oi->get(0)); |
| |
| cliRC = cliInterface->executeImmediate(query); |
| if (cliRC < 0) |
| { |
| cliInterface->retrieveSQLDiagnostics(CmpCommon::diags()); |
| return -1; |
| } |
| } |
| |
| orphanHiveObjs->advance(); |
| } |
| |
| numOrphanMetadataEntries_ = orphanHiveObjs->numEntries(); |
| |
| return 0; |
| } |
| |
| void CmpSeabaseMDcleanup::populateBlackBox(ExeCliInterface *cliInterface, |
| Queue *returnDetailsList, |
| Int32 &blackBoxLen, |
| char* &blackBox) |
| { |
| blackBoxLen = 0; |
| blackBox = NULL; |
| if (returnDetailsList && returnDetailsList->numEntries() > 0) |
| { |
| Lng32 numEntries = returnDetailsList->numEntries(); |
| |
| blackBoxLen += sizeof(Int32); |
| returnDetailsList->position(); |
| for (Int32 i = 0; i < numEntries; i++) |
| { |
| OutputInfo * oi = (OutputInfo*)returnDetailsList->getCurr(); |
| char * val = (char*)oi->get(0); |
| |
| blackBoxLen += sizeof(Int32); |
| blackBoxLen += ROUND4(strlen(val)+1); |
| |
| returnDetailsList->advance(); |
| } |
| |
| blackBoxLen = ROUND8(blackBoxLen); |
| |
| blackBox = new(STMTHEAP) char[blackBoxLen]; |
| |
| char * currPtr = blackBox; |
| *(Int32*)currPtr = numEntries; |
| currPtr += sizeof(Int32); |
| |
| returnDetailsList->position(); |
| for (Int32 i = 0; i < numEntries; i++) |
| { |
| OutputInfo * oi = (OutputInfo*)returnDetailsList->getCurr(); |
| char * val = (char*)oi->get(0); |
| |
| *(Int32*)currPtr = strlen(val); |
| currPtr += sizeof(Int32); |
| |
| strcpy(currPtr, val); |
| currPtr += ROUND4(strlen(val)+1); |
| |
| returnDetailsList->advance(); |
| } |
| |
| } |
| } |
| |
| void CmpSeabaseMDcleanup::cleanupMetadataEntries(ExeCliInterface *cliInterface, |
| ExpHbaseInterface *ehi, |
| CmpDDLwithStatusInfo *dws) |
| { |
| Lng32 cliRC = 0; |
| char query[1000]; |
| NABoolean errorSeen = FALSE; |
| |
| char buf[500]; |
| |
| dws->setBlackBoxLen(0); |
| dws->setBlackBox(NULL); |
| |
| while (1) // exit via return stmt in switch |
| { |
| switch (dws->step()) |
| { |
| case START_CLEANUP: |
| { |
| if (checkOnly_) |
| dws->setMsg("Metadata Cleanup: started, check only"); |
| else |
| dws->setMsg("Metadata Cleanup: started"); |
| dws->setStep(ORPHAN_OBJECTS_ENTRIES); |
| dws->setSubstep(0); |
| dws->setEndStep(TRUE); |
| |
| return; |
| } |
| break; |
| |
| case ORPHAN_OBJECTS_ENTRIES: |
| { |
| switch (dws->subStep()) |
| { |
| case 0: |
| { |
| dws->setMsg(" Start: Cleanup Orphan Objects Entries"); |
| dws->subStep()++; |
| dws->setEndStep(FALSE); |
| |
| return; |
| } |
| break; |
| |
| case 1: |
| { |
| if (cleanupOrphanObjectsEntries(cliInterface, ehi, dws)) |
| return; |
| |
| str_sprintf(buf, " End: Cleanup Orphan Objects Entries (%d %s %s)", |
| numOrphanMetadataEntries_, |
| (numOrphanMetadataEntries_ == 1 ? "entry" : "entries"), |
| (checkOnly_ ? "found" : "cleaned up")); |
| dws->setMsg(buf); |
| |
| Int32 blackBoxLen = 0; |
| char * blackBox = NULL; |
| populateBlackBox(cliInterface, returnDetailsList_, blackBoxLen, blackBox); |
| |
| dws->setBlackBoxLen(blackBoxLen); |
| dws->setBlackBox(blackBox); |
| |
| dws->setStep(HBASE_ENTRIES); |
| dws->setSubstep(0); |
| dws->setEndStep(TRUE); |
| |
| return; |
| } |
| break; |
| } // switch |
| } // MD_ENTRIES |
| break; |
| |
| case HBASE_ENTRIES: |
| { |
| switch (dws->subStep()) |
| { |
| case 0: |
| { |
| dws->setMsg(" Start: Cleanup Orphan Hbase Entries"); |
| dws->subStep()++; |
| dws->setEndStep(FALSE); |
| |
| return; |
| } |
| break; |
| |
| case 1: |
| { |
| if (cleanupOrphanHbaseEntries(cliInterface, ehi, dws)) |
| return; |
| |
| str_sprintf(buf, " End: Cleanup Orphan Hbase Entries (%d %s %s)", |
| numOrphanHbaseEntries_, |
| (numOrphanHbaseEntries_ == 1 ? "entry" : "entries"), |
| (checkOnly_ ? "found" : "cleaned up")); |
| |
| Int32 blackBoxLen = 0; |
| char * blackBox = NULL; |
| populateBlackBox(cliInterface, returnDetailsList_, blackBoxLen, blackBox); |
| |
| dws->setBlackBoxLen(blackBoxLen); |
| dws->setBlackBox(blackBox); |
| |
| dws->setMsg(buf); |
| dws->setStep(INCONSISTENT_OBJECTS_ENTRIES); |
| dws->setSubstep(0); |
| dws->setEndStep(TRUE); |
| |
| return; |
| } |
| break; |
| } // switch |
| } // HBASE_ENTRIES |
| break; |
| |
| case INCONSISTENT_OBJECTS_ENTRIES: |
| { |
| switch (dws->subStep()) |
| { |
| case 0: |
| { |
| dws->setMsg(" Start: Cleanup Inconsistent Objects Entries"); |
| dws->subStep()++; |
| dws->setEndStep(FALSE); |
| |
| return; |
| } |
| break; |
| |
| case 1: |
| { |
| if (cleanupInconsistentObjectsEntries(cliInterface, ehi, dws)) |
| return; |
| |
| str_sprintf(buf, " End: Cleanup Inconsistent Objects Entries (%d %s %s)", |
| numOrphanObjectsEntries_, |
| (numOrphanObjectsEntries_ == 1 ? "entry" : "entries"), |
| (checkOnly_ ? "found" : "cleaned up")); |
| |
| Int32 blackBoxLen = 0; |
| char * blackBox = NULL; |
| populateBlackBox(cliInterface, returnDetailsList_, blackBoxLen, blackBox); |
| |
| dws->setBlackBoxLen(blackBoxLen); |
| dws->setBlackBox(blackBox); |
| |
| dws->setMsg(buf); |
| dws->setStep(VIEWS_ENTRIES); |
| dws->setSubstep(0); |
| dws->setEndStep(TRUE); |
| |
| return; |
| } |
| break; |
| } // switch |
| } // OBJECTS_ENTRIES |
| break; |
| |
| case VIEWS_ENTRIES: |
| { |
| switch (dws->subStep()) |
| { |
| case 0: |
| { |
| dws->setMsg(" Start: Cleanup Inconsistent Views Entries"); |
| dws->subStep()++; |
| dws->setEndStep(FALSE); |
| |
| return; |
| } |
| break; |
| |
| case 1: |
| { |
| if (cleanupOrphanViewsEntries(cliInterface, ehi, dws)) |
| return; |
| |
| str_sprintf(buf, " End: Cleanup Inconsistent Views Entries (%d %s %s)", |
| numOrphanViewsEntries_, |
| (numOrphanViewsEntries_ == 1 ? "entry" : "entries"), |
| (checkOnly_ ? "found" : "cleaned up")); |
| |
| Int32 blackBoxLen = 0; |
| char * blackBox = NULL; |
| populateBlackBox(cliInterface, returnDetailsList_, blackBoxLen, blackBox); |
| |
| dws->setBlackBoxLen(blackBoxLen); |
| dws->setBlackBox(blackBox); |
| |
| if ((numOrphanViewsEntries_ == 0) && |
| (blackBoxLen > 0)) |
| { |
| str_sprintf(buf, " End: Cleanup Inconsistent Views Entries (%d %s %s) [internal error: blackBoxLen = %d] ", |
| numOrphanViewsEntries_, |
| (numOrphanViewsEntries_ == 1 ? "entry" : "entries"), |
| (checkOnly_ ? "found" : "cleaned up"), |
| blackBoxLen); |
| } |
| |
| dws->setMsg(buf); |
| dws->setStep(HIVE_ENTRIES); |
| dws->setSubstep(0); |
| dws->setEndStep(TRUE); |
| |
| return; |
| } |
| break; |
| } // switch |
| } // VIEWS_ENTRIES |
| |
| case HIVE_ENTRIES: |
| { |
| switch (dws->subStep()) |
| { |
| case 0: |
| { |
| dws->setMsg(" Start: Cleanup Inconsistent Hive Entries"); |
| dws->subStep()++; |
| dws->setEndStep(FALSE); |
| |
| return; |
| } |
| break; |
| |
| case 1: |
| { |
| |
| if (cleanupInconsistentHiveEntries(cliInterface, ehi)) |
| return; |
| |
| str_sprintf(buf, " End: Cleanup Inconsistent Hive Entries (%d %s %s)", |
| numInconsistentHiveEntries_, |
| (numInconsistentHiveEntries_ == 1 ? "entry" : "entries"), |
| (checkOnly_ ? "found" : "cleaned up")); |
| |
| Int32 blackBoxLen = 0; |
| char * blackBox = NULL; |
| populateBlackBox(cliInterface, returnDetailsList_, blackBoxLen, blackBox); |
| |
| dws->setBlackBoxLen(blackBoxLen); |
| dws->setBlackBox(blackBox); |
| |
| dws->setMsg(buf); |
| dws->setStep(DONE_CLEANUP); |
| dws->setSubstep(0); |
| dws->setEndStep(TRUE); |
| |
| return; |
| } |
| break; |
| } // switch |
| } // HIVE_ENTRIES |
| |
| case DONE_CLEANUP: |
| { |
| dws->setMsg("Metadata Cleanup: done"); |
| dws->setEndStep(TRUE); |
| dws->setSubstep(0); |
| dws->setDone(TRUE); |
| |
| return; |
| } |
| break; |
| |
| default: |
| return; |
| |
| } // switch |
| |
| } // while |
| |
| return; |
| } |
| |
| void CmpSeabaseMDcleanup::cleanupObjects(StmtDDLCleanupObjects * stmtCleanupNode, |
| NAString &currCatName, NAString &currSchName, |
| CmpDDLwithStatusInfo *dws) |
| { |
| Lng32 cliRC = 0; |
| ExeCliInterface cliInterface(STMTHEAP); |
| |
| if ((xnInProgress(&cliInterface)) && |
| (!Get_SqlParser_Flags(INTERNAL_QUERY_FROM_EXEUTIL))) |
| { |
| *CmpCommon::diags() << DgSqlCode(-20125) |
| << DgString0("This CLEANUP"); |
| return; |
| } |
| |
| // run each MD update in its own transaction. That way we can remove |
| // as much as we can. |
| cliInterface.autoCommit(TRUE); |
| |
| if (stmtCleanupNode) |
| { |
| if (validateInputValues(stmtCleanupNode, &cliInterface)) |
| return; |
| } |
| |
| ExpHbaseInterface * ehi = allocEHI(); |
| if (ehi == NULL) |
| { |
| return; |
| } |
| |
| checkOnly_ = FALSE; |
| if (dws && dws->getMDcleanup()) |
| { |
| if (dws->getCheckOnly()) |
| checkOnly_ = TRUE; |
| if (dws->getReturnDetails()) |
| returnDetails_ = TRUE; |
| cleanupMetadataEntries(&cliInterface, ehi, dws); |
| return; |
| } |
| |
| if (cleanupMetadataEntries_) |
| { |
| return cleanupMetadataEntries(&cliInterface, ehi, NULL); |
| } |
| |
| if ((objType_ == COM_PRIVATE_SCHEMA_OBJECT_LIT) || |
| (objType_ == COM_SHARED_SCHEMA_OBJECT_LIT)) |
| { |
| return cleanupSchemaObjects(&cliInterface); |
| } |
| |
| if (stmtCleanupNode && |
| (stmtCleanupNode->getType() == StmtDDLCleanupObjects::HBASE_TABLE_)) |
| { |
| return cleanupHBaseObject(stmtCleanupNode, &cliInterface); |
| } |
| |
| if (gatherDependentObjects(&cliInterface)) |
| { |
| if (stopOnError_) |
| goto label_return; |
| } |
| |
| if (((objType_ == COM_BASE_TABLE_OBJECT_LIT) || |
| (objType_ == COM_INDEX_OBJECT_LIT)) && |
| (NOT isHive_) && |
| (extNameForHbase_.isNull())) |
| { |
| // add warning that name couldnt be found. Hbase object cannot be removed. |
| CmpCommon::diags()->clear(); |
| *CmpCommon::diags() << DgSqlCode(4250); |
| } |
| else if (((objType_ != COM_PRIVATE_SCHEMA_OBJECT_LIT) && |
| (objType_ != COM_SHARED_SCHEMA_OBJECT_LIT) && |
| (objType_ != COM_VIEW_OBJECT_LIT)) && |
| (objUID_ == -1)) |
| { |
| CmpCommon::diags()->clear(); |
| *CmpCommon::diags() << DgSqlCode(4251) ; |
| } |
| |
| cliRC = deleteMDentries(&cliInterface); |
| if (cliRC < 0) |
| if (stopOnError_) |
| goto label_error; |
| |
| cliRC = deleteMDConstrEntries(&cliInterface); |
| if (cliRC < 0) |
| if (stopOnError_) |
| goto label_error; |
| |
| cliRC = deleteMDViewEntries(&cliInterface); |
| if (cliRC < 0) |
| if (stopOnError_) |
| goto label_error; |
| |
| cliRC = deleteHistogramEntries(&cliInterface); |
| if (cliRC < 0) |
| if (stopOnError_) |
| goto label_error; |
| |
| if ((NOT isHive_) && |
| (NOT extNameForHbase_.isNull())) |
| { |
| HbaseStr hbaseObject; |
| hbaseObject.val = (char*)extNameForHbase_.data(); |
| hbaseObject.len = extNameForHbase_.length(); |
| |
| // drop this object from hbase |
| cliRC = dropHbaseTable(ehi, &hbaseObject, FALSE, FALSE); |
| if (cliRC) |
| if (stopOnError_) |
| goto label_return; |
| } |
| |
| // drop underlying Hive object |
| if (isHive_) |
| { |
| NAString hiveQuery; |
| if (objType_ == COM_BASE_TABLE_OBJECT_LIT) |
| { |
| hiveQuery = "drop table if exists " + extNameForHive_; |
| } |
| else if (objType_ == COM_VIEW_OBJECT_LIT) |
| { |
| hiveQuery = "drop view if exists " + extNameForHive_; |
| } |
| |
| if (NOT hiveQuery.isNull()) |
| { |
| if (HiveClient_JNI::executeHiveSQL(hiveQuery.data()) != HVC_OK) |
| { |
| if (stopOnError_) |
| goto label_return; |
| } |
| } |
| } |
| |
| cliRC = dropIndexes(&cliInterface); |
| if (cliRC) |
| if (stopOnError_) |
| goto label_return; |
| |
| cliRC = dropSequences(&cliInterface); |
| if (cliRC) |
| if (stopOnError_) |
| goto label_return; |
| |
| cliRC = dropUsingViews(&cliInterface); |
| if (cliRC) |
| if (stopOnError_) |
| goto label_return; |
| |
| cliRC = dropLOBs(&cliInterface); |
| if (cliRC) |
| if (stopOnError_) |
| goto label_return; |
| |
| cliRC = deletePrivs(&cliInterface); |
| if (cliRC) |
| if (stopOnError_) |
| goto label_return; |
| |
| deallocEHI(ehi); |
| |
| if (NOT (catName_.isNull() || schName_.isNull() || objName_.isNull())) |
| { |
| CorrName cn(objName_, STMTHEAP, schName_, catName_); |
| ActiveSchemaDB()->getNATableDB()->removeNATable |
| ( |
| cn, |
| ComQiScope::REMOVE_FROM_ALL_USERS, |
| (objType_ == COM_VIEW_OBJECT_LIT ? COM_VIEW_OBJECT : |
| COM_BASE_TABLE_OBJECT), |
| FALSE, FALSE); |
| } |
| |
| return; |
| |
| label_error: |
| if ((objType_ == COM_BASE_TABLE_OBJECT_LIT) && |
| (NOT extNameForHbase_.isNull())) |
| { |
| CorrName cn(objName_, STMTHEAP, schName_, catName_); |
| ActiveSchemaDB()->getNATableDB()->removeNATable |
| (cn, |
| ComQiScope::REMOVE_FROM_ALL_USERS, |
| COM_BASE_TABLE_OBJECT, |
| FALSE, FALSE); |
| } |
| |
| label_return: |
| deallocEHI(ehi); |
| |
| return; |
| } |
| |
| |
