| //***************************************************************************** |
| // @@@ 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 @@@ |
| //***************************************************************************** |
| |
| #include "PrivMgrObjects.h" |
| |
| #include "PrivMgrMD.h" |
| #include "PrivMgrMDTable.h" |
| #include "PrivMgrComponentOperations.h" |
| #include "PrivMgrComponentPrivileges.h" |
| |
| #include <string> |
| #include <cstdio> |
| #include "ComSmallDefs.h" |
| // sqlcli.h included because ExExeUtilCli.h needs it (and does not include it!) |
| #include "sqlcli.h" |
| #include "ExExeUtilCli.h" |
| #include "ComDiags.h" |
| #include "ComQueue.h" |
| // CmpCommon.h contains STMTHEAP declaration |
| #include "CmpCommon.h" |
| #include "CmpDDLCatErrorCodes.h" |
| #include "ComUser.h" |
| #include "CmpContext.h" |
| |
| namespace Objects |
| { |
| // ***************************************************************************** |
| // * Class: MyRow |
| // * Description: This class represents a row in the OBJECTS table containing: |
| // * - UID of the component |
| // * - ANSI name of the component |
| // * - if the component is a system component (intrinsic to Trafodion) |
| // * - Description of the component |
| // * |
| // * An object can be uniquely identified by its ANSI name and object type |
| // * or by its UID. |
| // ***************************************************************************** |
| class MyRow : public PrivMgrMDRow |
| { |
| public: |
| |
| // ------------------------------------------------------------------- |
| // Constructors and destructors: |
| // ------------------------------------------------------------------- |
| MyRow(std::string tableName) |
| : PrivMgrMDRow(tableName, OBJECTS_ENUM), |
| objectUID_(0) |
| { }; |
| |
| MyRow(const MyRow &other) |
| : PrivMgrMDRow(other) |
| { |
| objectUID_ = other.objectUID_; |
| catalogName_ = other.catalogName_; |
| schemaName_ = other.schemaName_; |
| objectName_ = other.objectName_; |
| objectType_ = other.objectType_; |
| createTime_ = other.createTime_; |
| redefTime_ = other.redefTime_; |
| isValid_ = other.isValid_; |
| objectOwner_ = other.objectOwner_; |
| schemaOwner_ = other.schemaOwner_; |
| }; |
| virtual ~MyRow(){}; |
| inline void clear() {objectUID_ = 0;}; |
| |
| |
| // ------------------------------------------------------------------- |
| // Data Members: |
| // ------------------------------------------------------------------- |
| |
| int64_t objectUID_; |
| std::string catalogName_; |
| std::string schemaName_; |
| std::string objectName_; |
| ComObjectType objectType_; |
| int64_t createTime_; |
| int64_t redefTime_; |
| int32_t objectOwner_; |
| int32_t schemaOwner_; |
| bool isValid_; |
| |
| private: |
| MyRow(); |
| |
| }; |
| |
| // ***************************************************************************** |
| // * Class: MyTable |
| // * Description: This class represents the COMPONENTS table containing: |
| // * - the fully qualified name of the table |
| // * - the last row read |
| // * |
| // * An object can be uniquely identified by its fully-qualified ANSI name |
| // * or its UID. |
| // ***************************************************************************** |
| class MyTable : public PrivMgrMDTable |
| { |
| public: |
| MyTable( |
| const std::string & tableName, |
| PrivMgrTableEnum myTableEnum, |
| ComDiagsArea * pDiags) |
| : PrivMgrMDTable(tableName,OBJECTS_ENUM,pDiags), |
| lastRowRead_(tableName) |
| {}; |
| |
| inline void clear() { lastRowRead_.clear(); }; |
| |
| virtual PrivStatus insert(const PrivMgrMDRow &row); |
| |
| PrivStatus selectAllWhere( |
| const std::string & whereClause, |
| const std::string & orderByClause, |
| std::vector<MyRow> & rows); |
| |
| virtual PrivStatus selectWhereUnique( |
| const std::string & whereClause, |
| PrivMgrMDRow & row); |
| |
| void setRow( |
| OutputInfo & cliInterface, |
| PrivMgrMDRow & rowOut); |
| |
| private: |
| MyTable(); |
| MyRow lastRowRead_; |
| |
| }; |
| }//End namespace Objects |
| using namespace Objects; |
| |
| // ***************************************************************************** |
| // PrivMgrObjects methods |
| // ***************************************************************************** |
| // ----------------------------------------------------------------------- |
| // Construct a PrivMgrObjects object for a new component. |
| // ----------------------------------------------------------------------- |
| PrivMgrObjects::PrivMgrObjects ( |
| const std::string & metadataLocation, |
| ComDiagsArea * pDiags) |
| : PrivMgr(metadataLocation,pDiags), |
| fullTableName_(metadataLocation + ".OBJECTS"), |
| myTable_(*(new MyTable(fullTableName_,OBJECTS_ENUM, pDiags))) |
| { } |
| |
| // ----------------------------------------------------------------------- |
| // Copy constructor |
| // ----------------------------------------------------------------------- |
| PrivMgrObjects::PrivMgrObjects(const PrivMgrObjects &other) |
| : PrivMgr(other), |
| myTable_(*new MyTable(fullTableName_,OBJECTS_ENUM, pDiags_)) |
| { |
| |
| fullTableName_ = other.fullTableName_; |
| |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Destructor. |
| // ----------------------------------------------------------------------- |
| PrivMgrObjects::~PrivMgrObjects() |
| { |
| |
| delete &myTable_; |
| |
| } |
| |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: PrivMgrObjects::addEntry * |
| // * * |
| // * Adds an entry to the OBJECTS table. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Parameters: * |
| // * * |
| // * <objectUID> const int64_t In * |
| // * is the unique ID representing the object. * |
| // * * |
| // * <catalogName> const std::string & In * |
| // * is the name of the catalog. * |
| // * * |
| // * <schemaName> const std::string & In * |
| // * is the name of the schema. * |
| // * * |
| // * <objectName> const std::string & In * |
| // * is the name of the object. * |
| // * * |
| // * <objectType> const ComObjectType In * |
| // * is the type of the object (table, view, sequence, etc.) * |
| // * * |
| // * <createTime> const int64_t In * |
| // * is the Julian timestamp of the object creation. * |
| // * * |
| // * <redefTime> const int64_t In * |
| // * is the Julian timestamp of the last time the object's definition was * |
| // * changed in any way. At object creation, this should have the same * |
| // * value as <createTime>. * |
| // * * |
| // * <isValid> const bool In * |
| // * is true if the object is valid, false otherwise. State is recorded. * |
| // * * |
| // * <objectOwner> const int32_t In * |
| // * is the authorization ID of the owner of the object. * |
| // * * |
| // * <schemaOwner> const int32_t In * |
| // * is the authorization ID of the owner of the schema containing the * |
| // * object. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Returns: PrivStatus * |
| // * * |
| // * STATUS_GOOD: New entry was successfully written to OBJECTS table. * |
| // * STATUS_ERROR: Entry could not be added. A CLI error is put into * |
| // * the diags area. * |
| // * * |
| // ***************************************************************************** |
| PrivStatus PrivMgrObjects::addEntry( |
| const int64_t objectUID, |
| const std::string & catalogName, |
| const std::string & schemaName, |
| const std::string & objectName, |
| const ComObjectType objectType, |
| const int64_t createTime, |
| const int64_t redefTime, |
| const bool isValid, |
| const int32_t objectOwner, |
| const int32_t schemaOwner) |
| |
| { |
| |
| MyTable &myTable = static_cast<MyTable &>(myTable_); |
| MyRow row(fullTableName_); |
| |
| row.objectUID_ = objectUID; |
| row.catalogName_ = catalogName; |
| row.schemaName_ = schemaName; |
| row.objectName_ = objectName; |
| row.objectType_ = objectType; |
| row.createTime_ = createTime; |
| row.redefTime_ = redefTime; |
| row.isValid_ = isValid; |
| row.objectOwner_ = objectOwner; |
| row.schemaOwner_ = schemaOwner; |
| |
| return myTable.insert(row); |
| |
| } |
| //*********************** End of PrivMgrObjects::addEntry ********************** |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: PrivMgrObjects::clear * |
| // * * |
| // * This function clears any cache associated with this object. * |
| // * * |
| // ***************************************************************************** |
| void PrivMgrObjects::clear() |
| |
| { |
| |
| MyTable &myTable = static_cast<MyTable &>(myTable_); |
| |
| myTable.clear(); |
| |
| } |
| //************************* End of PrivMgrObjects::clear *********************** |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: PrivMgrObjects::deleteEntryByName * |
| // * * |
| // * Removes an object definition from the OBJECTS table. Object is * |
| // * uniquely identified by qualified name. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Parameters: * |
| // * * |
| // * <catalogName> const std::string & In * |
| // * is the name of the catalog. * |
| // * * |
| // * <schemaName> const std::string & In * |
| // * is the name of the schema. * |
| // * * |
| // * <objectName> const std::string & In * |
| // * is the name of the object. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Returns: PrivStatus * |
| // * * |
| // * STATUS_GOOD: Name of object was returned. * |
| // * STATUS_ERROR: Name of object was not returned. A CLI error is put into * |
| // * the diags area. * |
| // * * |
| // ***************************************************************************** |
| PrivStatus PrivMgrObjects::deleteEntryByName( |
| const std::string & catalogName, |
| const std::string & schemaName, |
| const std::string & objectName) |
| |
| { |
| |
| MyTable &myTable = static_cast<MyTable &>(myTable_); |
| |
| std::string whereClause(" WHERE CATALOG_NAME = '"); |
| |
| whereClause += catalogName + "' AND SCHEMA_NAME = '"; |
| whereClause += schemaName + "' AND OBJECT_NAME = '"; |
| whereClause += objectName + "'"; |
| |
| return myTable.deleteWhere(whereClause); |
| |
| } |
| //****************** End of PrivMgrObjects::deleteEntryByName ***************** |
| |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: PrivMgrObjects::fetchObjectOwner * |
| // * * |
| // * Returns the object owner ID for the object that matches the unique ID * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Parameters: * |
| // * * |
| // * * |
| // * <objectUID> const int64_t In * |
| // * is the unique ID representing the object. * |
| // * * |
| // * <objectOwner> int32_t & Out * |
| // * passes back the object owner ID. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Returns: PrivStatus * |
| // * * |
| // * STATUS_GOOD: The object owner was returned. * |
| // * STATUS_ERROR: Theo object owner was not returned. CLI error is put into * |
| // * the diags area. * |
| // * * |
| // ***************************************************************************** |
| |
| PrivStatus PrivMgrObjects::fetchObjectOwner( |
| const int64_t objectUID, |
| int32_t & objectOwner) |
| |
| { |
| |
| MyTable &myTable = static_cast<MyTable &>(myTable_); |
| MyRow row(fullTableName_); |
| |
| std::string whereClause(" WHERE OBJECT_UID = "); |
| |
| whereClause += UIDToString(objectUID); |
| |
| PrivStatus privStatus = myTable.selectWhereUnique(whereClause,row); |
| |
| if (privStatus != STATUS_GOOD) |
| return STATUS_ERROR; |
| |
| objectOwner = row.objectOwner_; |
| |
| return STATUS_GOOD; |
| |
| } |
| //****************** End of PrivMgrObjects::fetchObjectOwner ***************** |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: PrivMgrObjects::fetchQualifiedName * |
| // * * |
| // * Returns the fully qualified (cat.sch.obj) name for the object that * |
| // * matches the unique ID. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Parameters: * |
| // * * |
| // * * |
| // * <objectUID> const int64_t In * |
| // * is the unique ID representing the object. * |
| // * * |
| // * <qualifiedObjectName> std::string & Out * |
| // * passes back the name of the object, fully qualified. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Returns: PrivStatus * |
| // * * |
| // * STATUS_GOOD: Name of object was returned. * |
| // * STATUS_ERROR: Name of object was not returned. A CLI error is put into * |
| // * the diags area. * |
| // * * |
| // ***************************************************************************** |
| PrivStatus PrivMgrObjects::fetchQualifiedName( |
| const int64_t objectUID, |
| std::string & qualifiedObjectName) |
| |
| { |
| |
| MyTable &myTable = static_cast<MyTable &>(myTable_); |
| MyRow row(fullTableName_); |
| |
| std::string whereClause(" WHERE OBJECT_UID = "); |
| |
| whereClause += UIDToString(objectUID); |
| |
| PrivStatus privStatus = myTable.selectWhereUnique(whereClause,row); |
| |
| if (privStatus != STATUS_GOOD) |
| return STATUS_ERROR; |
| |
| qualifiedObjectName = row.catalogName_ + "."; |
| qualifiedObjectName += row.schemaName_ + "."; |
| qualifiedObjectName += row.objectName_; |
| |
| return STATUS_GOOD; |
| |
| } |
| //****************** End of PrivMgrObjects::fetchQualifiedName ***************** |
| |
| |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: PrivMgrObjects::fetchQualifiedName * |
| // * * |
| // * * |
| // * Returns the fully qualified (cat.sch.obj) name for the object that * |
| // * matches the specifications of the WHERE clause. * |
| // * * |
| // * NOTE: WHERE clause must specify a unique object or behavior is * |
| // * unsupported. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Parameters: * |
| // * * |
| // * <whereClause> const std::string & In * |
| // * is the WHERE clause specifying a unique object. * |
| // * * |
| // * <qualifiedObjectName> std::string & Out * |
| // * passes back the name of the object, fully qualified. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Returns: PrivStatus * |
| // * * |
| // * STATUS_GOOD: Name of object was returned. * |
| // * STATUS_ERROR: Name of object was not returned. A CLI error is put into * |
| // * the diags area. * |
| // * * |
| // ***************************************************************************** |
| PrivStatus PrivMgrObjects::fetchQualifiedName( |
| const std::string & whereClause, |
| std::string & qualifiedObjectName) |
| |
| { |
| |
| MyTable &myTable = static_cast<MyTable &>(myTable_); |
| MyRow row(fullTableName_); |
| |
| PrivStatus privStatus = myTable.selectWhereUnique(whereClause,row); |
| |
| if (privStatus != STATUS_GOOD) |
| return STATUS_ERROR; |
| |
| qualifiedObjectName = row.catalogName_ + "."; |
| qualifiedObjectName += row.schemaName_ + "."; |
| qualifiedObjectName += row.objectName_; |
| |
| return STATUS_GOOD; |
| |
| } |
| //****************** End of PrivMgrObjects::fetchQualifiedName ***************** |
| |
| |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: PrivMgrObjects::fetchUIDandOwner * |
| // * * |
| // * Returns a vector of object UIDs and their object owner for all rows * |
| // * in the OBJECTS table specified by a WHERE clause. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Parameters: * |
| // * * |
| // * <whereClause> const std::string & In * |
| // * is the WHERE clause specifying the rows to fetch. * |
| // * * |
| // * <orderByClause> const std::string & In * |
| // * is the ORDER BY clause specifying the order to return the rows. * |
| // * * |
| // * <objectRows> vector<UIDAndOwner> & Out * |
| // * passes back a vector of object UIDs and their object. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Returns: PrivStatus * |
| // * * |
| // * STATUS_GOOD: A vector of object UIDs and object owners was returned. * |
| // * STATUS_ERROR: Error reading OBJECTS table or no matches found. A CLI * |
| // * error is put into the diags area. * |
| // * * |
| // ***************************************************************************** |
| PrivStatus PrivMgrObjects::fetchUIDandOwner( |
| const std::string whereClause, |
| const std::string orderByClause, |
| vector<UIDAndOwner> & objectRows) |
| |
| { |
| |
| std::vector<MyRow> rows; |
| MyTable &myTable = static_cast<MyTable &>(myTable_); |
| |
| PrivStatus privStatus = myTable.selectAllWhere(whereClause,orderByClause,rows); |
| |
| if (privStatus != STATUS_GOOD) |
| return STATUS_ERROR; |
| |
| for (size_t r = 0; r < rows.size(); r++) |
| { |
| UIDAndOwner element; |
| |
| element.UID = rows[r].objectUID_; |
| element.ownerID = rows[r].objectOwner_; |
| |
| objectRows.push_back(element); |
| } |
| |
| return STATUS_GOOD; |
| |
| } |
| //******************* End of PrivMgrObjects::fetchUIDandOwner ****************** |
| |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: PrivMgrObjects::fetchUIDandTypes * |
| // * * |
| // * Returns a vector of object UIDs and their object type for all rows * |
| // * in the OBJECTS table specified by a WHERE clause. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Parameters: * |
| // * * |
| // * <whereClause> const std::string & In * |
| // * is the WHERE clause specifying a unique object. * |
| // * * |
| // * <UIDandTypes> vector<UIDAndType> & Out * |
| // * passes back a vector of object UIDs and their object type. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Returns: PrivStatus * |
| // * * |
| // * STATUS_GOOD: A vector of object UIDs and object types was returned. * |
| // * STATUS_ERROR: Error reading OBJECTS table or no matches found. A CLI * |
| // * error is put into the diags area. * |
| // * * |
| // ***************************************************************************** |
| PrivStatus PrivMgrObjects::fetchUIDandTypes( |
| const std::string whereClause, |
| vector<UIDAndType> & UIDandTypes) |
| |
| { |
| |
| std::string orderByClause; |
| |
| std::vector<MyRow> rows; |
| MyTable &myTable = static_cast<MyTable &>(myTable_); |
| |
| PrivStatus privStatus = myTable.selectAllWhere(whereClause,orderByClause,rows); |
| |
| if (privStatus != STATUS_GOOD) |
| return STATUS_ERROR; |
| |
| for (size_t r = 0; r < rows.size(); r++) |
| { |
| UIDAndType element; |
| |
| element.UID = rows[r].objectUID_; |
| element.objectType = rows[r].objectType_; |
| |
| UIDandTypes.push_back(element); |
| } |
| |
| return STATUS_GOOD; |
| |
| } |
| //******************* End of PrivMgrObjects::fetchUIDandTypes ****************** |
| |
| |
| |
| |
| |
| // ***************************************************************************** |
| // MyTable methods |
| // ***************************************************************************** |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: MyTable::insert * |
| // * * |
| // * Function defined because base class requires it. This is not the * |
| // * way to insert into the OBJECTS table. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Parameters: * |
| // * * |
| // * <rowIn> const PrivMgrMDRow & In * |
| // * is a MyRow to be inserted. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Returns: PrivStatus * |
| // * * |
| // * STATUS_GOOD: Row inserted. * |
| // * *: Insert failed. A CLI error is put into the diags area. * |
| // * * |
| // ***************************************************************************** |
| PrivStatus MyTable::insert(const PrivMgrMDRow & rowIn) |
| { |
| |
| const MyRow & row = static_cast<const MyRow &>(rowIn); |
| char insertStatement[1000]; |
| char objectTypeLit[3] = {0}; |
| |
| strncpy(objectTypeLit,PrivMgr::ObjectEnumToLit(row.objectType_),2); |
| |
| char validDef[2] = {0}; |
| |
| if (row.isValid_) |
| validDef[0] = 'Y'; |
| else |
| validDef[0] = 'N'; |
| |
| sprintf(insertStatement,"insert into %s values ('%s', '%s', '%s', '%s', %ld, %ld, %ld, '%s', %d, %d)", |
| tableName_.c_str(), |
| row.catalogName_.c_str(), |
| row.schemaName_.c_str(), |
| row.objectName_.c_str(), |
| objectTypeLit, |
| row.objectUID_, |
| row.createTime_, |
| row.redefTime_, |
| validDef, |
| row.objectOwner_, |
| row.schemaOwner_); |
| |
| return CLIImmediate(insertStatement); |
| |
| } |
| //************************** End of MyTable::insert **************************** |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: MyTable::selectAllWhere * |
| // * * |
| // * Selects rows from the OBJECTS table based on the specified WHERE * |
| // * clause and sorted per an optional ORDER BY clause. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Parameters: * |
| // * * |
| // * <whereClause> const std::string & In * |
| // * is the WHERE clause specifying a unique row. * |
| // * * |
| // * <orderByClause> const std::string & In * |
| // * is an optional ORDER BY clause. * |
| // * * |
| // * <rowOut> PrivMgrMDRow & Out * |
| // * passes back a MyRow. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Returns: PrivStatus * |
| // * * |
| // * STATUS_GOOD: Row returned. * |
| // * *: Select failed. A CLI error is put into the diags area. * |
| // * * |
| // ***************************************************************************** |
| PrivStatus MyTable::selectAllWhere( |
| const std::string & whereClause, |
| const std::string & orderByClause, |
| std::vector<MyRow> & rows) |
| |
| { |
| |
| std::string selectStmt("SELECT CATALOG_NAME, SCHEMA_NAME, OBJECT_NAME," |
| "OBJECT_TYPE, OBJECT_UID, CREATE_TIME, REDEF_TIME," |
| "VALID_DEF, OBJECT_OWNER FROM "); |
| selectStmt += tableName_; |
| selectStmt += " "; |
| selectStmt += whereClause; |
| selectStmt += " "; |
| selectStmt += orderByClause; |
| |
| Queue * tableQueue = NULL; |
| |
| PrivStatus privStatus = executeFetchAll(selectStmt,tableQueue); |
| |
| if (privStatus == STATUS_ERROR) |
| return STATUS_ERROR; |
| |
| tableQueue->position(); |
| for (int idx = 0; idx < tableQueue->numEntries(); idx++) |
| { |
| OutputInfo * pCliRow = (OutputInfo*)tableQueue->getNext(); |
| MyRow row(tableName_); |
| setRow(*pCliRow,row); |
| rows.push_back(row); |
| } |
| |
| return STATUS_GOOD; |
| |
| } |
| //********************** End of MyTable::selectAllWhere ************************ |
| |
| |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: MyTable::selectWhereUnique * |
| // * * |
| // * Selects a row from the COMPONENTS table based on the specified * |
| // * WHERE clause. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Parameters: * |
| // * * |
| // * <whereClause> const std::string & In * |
| // * is the WHERE clause specifying a unique row. * |
| // * * |
| // * <rowOut> PrivMgrMDRow & Out * |
| // * passes back a MyRow. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Returns: PrivStatus * |
| // * * |
| // * STATUS_GOOD: Row returned. * |
| // * *: Select failed. A CLI error is put into the diags area. * |
| // * * |
| // ***************************************************************************** |
| PrivStatus MyTable::selectWhereUnique( |
| const std::string & whereClause, |
| PrivMgrMDRow & rowOut) |
| |
| { |
| |
| // Generate the select statement |
| std::string selectStmt("SELECT CATALOG_NAME, SCHEMA_NAME, OBJECT_NAME," |
| "OBJECT_TYPE, OBJECT_UID, CREATE_TIME, REDEF_TIME," |
| "VALID_DEF, OBJECT_OWNER FROM "); |
| |
| selectStmt += tableName_; |
| selectStmt += " "; |
| selectStmt += whereClause; |
| |
| ExeCliInterface cliInterface(STMTHEAP, 0, NULL, |
| CmpCommon::context()->sqlSession()->getParentQid()); |
| |
| PrivStatus privStatus = CLIFetch(cliInterface,selectStmt); |
| |
| if (privStatus != STATUS_GOOD && privStatus != STATUS_WARNING) |
| return privStatus; |
| |
| // Row read successfully. Extract the columns. |
| |
| char * ptr = NULL; |
| Lng32 length = 0; |
| char value[500]; |
| MyRow & row = static_cast<MyRow &>(rowOut); |
| |
| // column 1: CATALOG_NAME |
| cliInterface.getPtrAndLen(1,ptr,length); |
| strncpy(value,ptr,length); |
| value[length] = 0; |
| row.catalogName_ = value; |
| |
| // column 2: SCHEMA_NAME |
| cliInterface.getPtrAndLen(2,ptr,length); |
| strncpy(value,ptr,length); |
| value[length] = 0; |
| row.schemaName_ = value; |
| |
| // column 3: OBJECT_NAME |
| cliInterface.getPtrAndLen(3,ptr,length); |
| strncpy(value,ptr,length); |
| value[length] = 0; |
| row.objectName_ = value; |
| |
| // column 4: OBJECT_TYPE |
| cliInterface.getPtrAndLen(4,ptr,length); |
| strncpy(value,ptr,length); |
| value[length] = 0; |
| row.objectType_ = PrivMgr::ObjectLitToEnum(value); |
| |
| // column 5: OBJECT_UID |
| cliInterface.getPtrAndLen(5,ptr,length); |
| row.objectUID_ = *(reinterpret_cast<int64_t*>(ptr)); |
| |
| // column 6: CREATE_TIME |
| cliInterface.getPtrAndLen(6,ptr,length); |
| row.createTime_ = *(reinterpret_cast<int64_t*>(ptr)); |
| |
| // column 7: REDEF_TIME |
| cliInterface.getPtrAndLen(7,ptr,length); |
| row.redefTime_ = *(reinterpret_cast<int64_t*>(ptr)); |
| |
| // column 8: VALID_DEF |
| cliInterface.getPtrAndLen(8,ptr,length); |
| strncpy(value,ptr,length); |
| value[length] = 0; |
| row.isValid_ = (value[0] == 'Y' ? true : false); |
| |
| // column 9: OBJECT_OWNER |
| cliInterface.getPtrAndLen(9,ptr,length); |
| row.objectOwner_ = *(reinterpret_cast<int32_t*>(ptr)); |
| |
| lastRowRead_ = row; |
| |
| return STATUS_GOOD; |
| |
| } |
| //******************* End of MyTable::selectWhereUnique ************************ |
| |
| |
| |
| // ***************************************************************************** |
| // * * |
| // * Function: MyTable::setRow * |
| // * * |
| // * Sets the fields of a row. * |
| // * * |
| // ***************************************************************************** |
| // * * |
| // * Parameters: * |
| // * * |
| // * <cliInterface> OutputInfo & In * |
| // * is a reference to CLI interface to the row data that was read. * |
| // * * |
| // * <rowOut> PrivMgrMDRow & Out * |
| // * passes back a MyRow. * |
| // * * |
| // ***************************************************************************** |
| void MyTable::setRow( |
| OutputInfo & cliInterface, |
| PrivMgrMDRow & rowOut) |
| |
| { |
| |
| MyRow & row = static_cast<MyRow &>(rowOut); |
| char * ptr = NULL; |
| int32_t length = 0; |
| char value[500]; |
| |
| // column 1: CATALOG_NAME |
| cliInterface.get(0,ptr,length); |
| strncpy(value,ptr,length); |
| value[length] = 0; |
| row.catalogName_ = value; |
| |
| // column 2: SCHEMA_NAME |
| cliInterface.get(1,ptr,length); |
| strncpy(value,ptr,length); |
| value[length] = 0; |
| row.schemaName_ = value; |
| |
| // column 3: OBJECT_NAME |
| cliInterface.get(2,ptr,length); |
| strncpy(value,ptr,length); |
| value[length] = 0; |
| row.objectName_ = value; |
| |
| // column 4: OBJECT_TYPE |
| cliInterface.get(3,ptr,length); |
| strncpy(value,ptr,length); |
| value[length] = 0; |
| row.objectType_ = PrivMgr::ObjectLitToEnum(value); |
| |
| // column 5: OBJECT_UID |
| cliInterface.get(4,ptr,length); |
| row.objectUID_ = *(reinterpret_cast<int64_t*>(ptr)); |
| |
| // column 6: CREATE_TIME |
| cliInterface.get(5,ptr,length); |
| row.createTime_ = *(reinterpret_cast<int64_t*>(ptr)); |
| |
| // column 7: REDEF_TIME |
| cliInterface.get(6,ptr,length); |
| row.redefTime_ = *(reinterpret_cast<int64_t*>(ptr)); |
| |
| // column 8: VALID_DEF |
| cliInterface.get(7,ptr,length); |
| strncpy(value,ptr,length); |
| value[length] = 0; |
| row.isValid_ = (value[0] == 'Y' ? true : false); |
| |
| // column 9: OBJECT_OWNER |
| cliInterface.get(8,ptr,length); |
| row.objectOwner_ = *(reinterpret_cast<int32_t*>(ptr)); |
| |
| lastRowRead_ = row; |
| |
| } |
| //************************** End of MyTable::setRow **************************** |
| |
| |
| |
| |
| |
