//*****************************************************************************
// @@@ 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 "PrivMgrComponents.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"

namespace Components 
{
// *****************************************************************************
// * Class:         MyRow
// * Description:  This class represents a row in the COMPONENTS 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
// *                
// *    A component can be uniquely identified by its ANSI name or its UID.
// *****************************************************************************
class MyRow : public PrivMgrMDRow
{
public:

// -------------------------------------------------------------------
// Constructors and destructors:
// -------------------------------------------------------------------
   MyRow(std::string tableName)
   : PrivMgrMDRow(tableName, COMPONENTS_ENUM),
     componentUID_(0)
   { };
   
   MyRow(const MyRow &other)
   : PrivMgrMDRow(other)
   {
      componentUID_ = other.componentUID_;
      componentName_ = other.componentName_;
      isSystem_ = other.isSystem_;
      componentDescription_ = other.componentDescription_;
   };
   virtual ~MyRow(){};
   inline void clear() {componentUID_ = 0;};
   bool lookupByName(
      const std::string & componentName,
      int64_t & componentUID,
      bool & isSystem,
      std::string & componentDescription);
   
   
// -------------------------------------------------------------------
// Data Members:
// -------------------------------------------------------------------
     
   int64_t            componentUID_;
   std::string        componentName_;
   std::string        componentDescription_;
   bool               isSystem_;
   
private:
   MyRow();
   
};


// *****************************************************************************
// * Class:         MyTable
// * Description:  This class represents the COMPONENTS table containing:
// *                - the fully qualified name of the table 
// *                
// *    A component can be uniquely identified by its ANSI name or its UID.
// *****************************************************************************
class MyTable : public PrivMgrMDTable
{
public:
   MyTable(
      const std::string & tableName,
      ComDiagsArea * pDiags) 
   : PrivMgrMDTable(tableName,COMPONENTS_ENUM, pDiags),
     lastRowRead_(tableName)
     {};

   virtual PrivStatus insert(const PrivMgrMDRow &row);
   virtual PrivStatus selectWhereUnique(
      const std::string & whereClause,
      PrivMgrMDRow & row);
      
   inline void clear() { lastRowRead_.clear(); };
   
   PrivStatus fetchByName(
      const std::string & componentName,
      MyRow &myRow);
   
private:   
   MyTable();
   MyRow lastRowRead_;

};
}//End namespace Components
using namespace Components;

// *****************************************************************************
//    PrivMgrComponents methods
// *****************************************************************************
// -----------------------------------------------------------------------
// Construct a PrivMgrComponents object for a new component.
// -----------------------------------------------------------------------
PrivMgrComponents::PrivMgrComponents (
   const std::string & metadataLocation,
   ComDiagsArea * pDiags)
: PrivMgr(metadataLocation,pDiags),
  fullTableName_(metadataLocation + ".COMPONENTS"),
  myTable_(*(new MyTable(fullTableName_,pDiags))) 
{ } 

// -----------------------------------------------------------------------
// Copy constructor
// -----------------------------------------------------------------------
PrivMgrComponents::PrivMgrComponents(const PrivMgrComponents &other)
: PrivMgr(other),
  myTable_(*new MyTable(fullTableName_,pDiags_))
{

   fullTableName_ = other.fullTableName_;
  
}

// -----------------------------------------------------------------------
// Destructor.
// -----------------------------------------------------------------------
PrivMgrComponents::~PrivMgrComponents() 
{ 

   delete &myTable_;

}

// *****************************************************************************
// *                                                                           *
// * Function: PrivMgrComponents::clear                                        *
// *                                                                           *
// *    This function clears any cache associated with this object.            *
// *                                                                           *
// *****************************************************************************
void PrivMgrComponents::clear()

{

MyTable &myTable = static_cast<MyTable &>(myTable_);

   myTable.clear();
   
}
//*********************** End of PrivMgrComponents::clear **********************

// *****************************************************************************
// *                                                                           *
// * Function: PrivMgrComponents::describeComponents                           *
// *                                                                           *
// * lookup "PRIVMGR_MD".COMPONENTS                                            *
// * using the specified component name(unique),                               *
// * and generate a REGISTER COMPONENT statement,                              *
// * return component UID.                                                     *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// *  Parameters:                                                              *
// *                                                                           *
// *  <componentName>                 const std::string &              In      *
// *  Unique component name.                                                   *
// *                                                                           *
// *  <componentUIDString>            std::string &                    Out     *
// *  Component UID in string of the specified component name.                 *
// *                                                                           *
// *  <componentUID>                  int64_t                          Out     *
// *  Component UID of the specified component name.                           *
// *                                                                           *
// *  <outlines>                      std::vector<std::string>         Out     *
// *  Output lines in a string array.                                          *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// * Returns: PrivStatus                                                       *
// *                                                                           *
// *                                                                           *
// *****************************************************************************
PrivStatus PrivMgrComponents::describeComponents(
   const  std::string & componentName, 
   std::string & componentUIDString, 
   int64_t & componentUID, 
   std::vector<std::string> & outlines)
   
{

    bool isSystem;
    std::string detailStr;
    std::string componentText;
    PrivStatus privStatus = fetchByName(componentName, componentUIDString, componentUID, isSystem, detailStr);
    if(privStatus == STATUS_GOOD)
    {
        componentText += "REGISTER COMPONENT "; 
        componentText += componentName; 
        componentText += isSystem?" SYSTEM":"";
        componentText += (!detailStr.empty())?" DETAIL '"+detailStr + "';":";";
        outlines.push_back(componentText);
        outlines.push_back("");
    }
    return privStatus;
    
}
//**************** End of PrivMgrComponents::describeComponents ****************


// *****************************************************************************
// *                                                                           *
// * Function: PrivMgrComponents::dropAll                                      *
// *                                                                           *
// *    This function removes all components from the system.                  *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// * Returns: PrivStatus                                                       *
// *                                                                           *
// *  STATUS_GOOD: All components were deleted.                                *
// * STATUS_ERROR: Execution failed. A CLI error is put into the diags area.   *
// *                                                                           *
// *****************************************************************************
PrivStatus PrivMgrComponents::dropAll()

{

PrivMgrComponentOperations componentOperations(metadataLocation_,pDiags_);
PrivStatus privStatus = STATUS_GOOD;

// Function dropAll() also drops any privileges granted on
// those operations.  
   privStatus = componentOperations.dropAll();
      
   if (privStatus != STATUS_GOOD)
   {
      if (pDiags_->getNumber(DgSqlCode::ERROR_) == 0)
         PRIVMGR_INTERNAL_ERROR("Unable to drop operations for component");
      return STATUS_ERROR;
   }

// If there were any operations or granted privileges on any component, they
// are now gone.  Delete all components from the COMPONENTS table.

   std::string whereClause(" ");
    
MyTable &myTable = static_cast<MyTable &>(myTable_);

   return myTable_.deleteWhere(whereClause);

}
//********************* End of PrivMgrComponents::dropAll **********************


// *****************************************************************************
// *                                                                           *
// * Function: PrivMgrComponents::exists                                       *
// *                                                                           *
// *    This function determines if a specific component has been defined in   *
// * Privilege Manager metadata.                                               *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// *  Parameters:                                                              *
// *                                                                           *
// *  <componentName>                 const std::string &             In       *
// *    is the name of the component.  Name is assumed to be upper case.       *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// * Returns: bool                                                             *
// *                                                                           *
// *  true: Component is registered.                                           *
// * false: Component is not registered or error encountered.                  *
// *                                                                           *
// *****************************************************************************
bool PrivMgrComponents::exists(const std::string & componentName)

{

MyRow row(fullTableName_);
MyTable &myTable = static_cast<MyTable &>(myTable_);

PrivStatus privStatus = myTable.fetchByName(componentName,row);

   if (privStatus == STATUS_GOOD || privStatus == STATUS_WARNING)
      return true;
      
   return false;
      
}
//*********************** End of PrivMgrComponents::exists *********************


// *****************************************************************************
// *                                                                           *
// * Function: PrivMgrComponents::fetchByName                                  *
// *                                                                           *
// *    Reads and returns data in row associated with a specified              *
// * component name.                                                           *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// *  Parameters:                                                              *
// *                                                                           *
// *  <componentName>                 const std::string &             In       *
// *    is the name of the component.  Name is assumed to be upper case.       *
// *                                                                           *
// *  <componentUIDString>            std::string &                   Out      *
// *    passes back the unique ID associated with the component as a string.   *
// *                                                                           *
// *  <componentUID>                  int64_t &                       Out      *
// *    passes back the unique ID associated with the component as a number.   *
// *                                                                           *
// *  <isSystem>                      bool &                          Out      *
// *    passes back true if the component is a system component, otherwise     *
// *    false is passed back.                                                  *
// *                                                                           *
// *  <componentDescription>          std::string &                   Out      *
// *    passes back the description of the component.  Note, providing a       *
// *  description is optional when the component is registered, so the         *
// *  value may be empty.                                                      *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// * Returns: PrivStatus                                                       *
// *                                                                           *
// *     STATUS_GOOD: Found name, UID returned.                                *
// * STATUS_NOTFOUND: Name not found or error encountered.                     *
// *                                                                           *
// *****************************************************************************
PrivStatus PrivMgrComponents::fetchByName(
   const std::string & componentName,
   std::string & componentUIDString,
   int64_t & componentUID,
   bool & isSystem,
   std::string & componentDescription)
   
{

MyRow row(fullTableName_);
MyTable &myTable = static_cast<MyTable &>(myTable_);

PrivStatus privStatus = myTable.fetchByName(componentName,row);

   if (privStatus == STATUS_NOTFOUND || privStatus == STATUS_ERROR)
      return STATUS_NOTFOUND;

   componentUIDString = UIDToString(row.componentUID_);
   componentUID = row.componentUID_;
   isSystem = row.isSystem_;
   componentDescription = row.componentDescription_;
   return STATUS_GOOD;

}
//******************** End of PrivMgrComponents::fetchByName *******************


// *****************************************************************************
// *                                                                           *
// * Function: PrivMgrComponents::getCount                                     *
// *                                                                           *
// *    Returns the number of registered components.                           *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// * Returns: int64_t                                                          *
// *                                                                           *
// *    Returns the number of registered components.                           *
// *                                                                           *
// *****************************************************************************
int64_t PrivMgrComponents::getCount()
   
{
                                   
std::string whereClause(" ");   

int64_t rowCount = 0;   
MyTable &myTable = static_cast<MyTable &>(myTable_);

// set pointer in diags area
int32_t diagsMark = pDiags_->mark();

PrivStatus privStatus = myTable.selectCountWhere(whereClause,rowCount);

   if (privStatus != STATUS_GOOD)
      pDiags_->rewind(diagsMark);
      
   return rowCount;

}
//********************* End of PrivMgrComponents::getCount *********************


// *****************************************************************************
// *                                                                           *
// * Function: PrivMgrComponents::getUniqueID                                  *
// *                                                                           *
// *    Finds the highest current unique ID and return the next value.         *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// * Returns: int64_t                                                          *
// *                                                                           *
// *    0: Error, could not get highest current UID, cannot determine a        *
// *       unique value to use.                                                *
// *   >0: A value guaranteed to be unique in the COMPONENTS table.            *
// *                                                                           *
// *                                                                           *
// *****************************************************************************
int64_t PrivMgrComponents::getUniqueID()
{

Lng32 len = 0;
char stmtBuf[1000];

   strcpy(stmtBuf,"SELECT NVL(MAX(component_uid),0) FROM ");
   strcat(stmtBuf,fullTableName_.c_str());

int64_t maxValue = 0;

ExeCliInterface cliInterface(STMTHEAP);
Lng32 cliRC = cliInterface.executeImmediate(stmtBuf,(char *)&maxValue,&len,false);

   if (cliRC != 0)
   {
      return 0;
   }
 
   return ++maxValue;
   
}
//******************** End of PrivMgrComponents::getUniqueID *******************


// *****************************************************************************
// *                                                                           *
// * Function: PrivMgrComponents::registerComponent                            *
// *                                                                           *
// *    Adds a row to the COMPONENTS table.                                    *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// *  Parameters:                                                              *
// *                                                                           *
// *  <componentName>                 const std::string &             In       *
// *    is the name of the component.  Name is assumed to be upper case.       *
// *                                                                           *
// *  <isSystem>                      const bool                      In       *
// *    is true if this is a system level component, false otherwise.  If a    *
// *  component is system level, Trafodion software assumes is it defined.     *
// *  System components may only be unregistered by DB__ROOT.  Only DB__ROOT   *
// *  may register a system component (unless a component privilege is added   *
// *  to authorize the operation).                                             *
// *                                                                           *
// *  <componentDescription>          const std::string &             In       *
// *    is a description of the component.                                     *
// *                                                                           *
// *  <existsErrorOK>                 const bool                      [In]     *
// *    if true, exists errors are silently ignored.                           *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// * Returns: PrivStatus                                                       *
// *                                                                           *
// * STATUS_GOOD: Component name was registered.                               *
// *           *: Unable to register component name, see diags.                *
// *                                                                           *
// *****************************************************************************
PrivStatus PrivMgrComponents::registerComponent(
   const std::string & componentName,
   const bool isSystem,
   const std::string & componentDescription,
   const bool existsErrorOK)

{

//TODO: Could check for setting isSystem, could be separate
// privilege, or restricted to DB__ROOT.
PrivMgrComponentPrivileges componentPrivileges(metadataLocation_, pDiags_);

   if (!ComUser::isRootUserID()&&
       !componentPrivileges.hasSQLPriv(ComUser::getCurrentUser(), SQLOperation::MANAGE_COMPONENTS, true))
   {   
      *pDiags_ << DgSqlCode(-CAT_NOT_AUTHORIZED);
      return STATUS_ERROR;
   }

// Is component already registered?

   if (exists(componentName))
   {
      if (existsErrorOK)
         return STATUS_GOOD;
   
      *pDiags_ << DgSqlCode(-CAT_TABLE_ALREADY_EXISTS)
               << DgTableName(componentName.c_str());
      return STATUS_ERROR;
   }

// Set up new component entry
int64_t uid = getUniqueID();

   if (uid == 0)
     return STATUS_ERROR;
      
MyRow row(fullTableName_);

   row.componentUID_ = uid;
   row.componentName_ = componentName;
   row.isSystem_ = isSystem;
   row.componentDescription_ = componentDescription;
   
// write the row to the components table
   return myTable_.insert(row);

}
//***************** End of PrivMgrComponents::registerComponent ****************


// *****************************************************************************
// *                                                                           *
// * Function: PrivMgrComponents::registerComponentInternal                    *
// *                                                                           *
// *    Internal function to register a component.  No checks are made prior   *
// * to inserting row into the COMPONENTS table.                               *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// *  Parameters:                                                              *
// *                                                                           *
// *  <componentName>                 const std::string &             In       *
// *    is the name of the component.  Name is assumed to be upper case.       *
// *                                                                           *
// *  <componentUID>                  const int64_t                   In       *
// *    is a unique ID for the component.                                      *
// *                                                                           *
// *  <isSystem>                      const bool                      In       *
// *    is true if this is a system level component, false otherwise.          *
// *                                                                           *
// *  <componentDescription>          const std::string &             In       *
// *    is a description of the component.                                     *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// * Returns: PrivStatus                                                       *
// *                                                                           *
// * STATUS_GOOD: Component name was registered.                               *
// *           *: Unable to register component name, see diags.                *
// *                                                                           *
// *****************************************************************************
PrivStatus PrivMgrComponents::registerComponentInternal(
   const std::string & componentName,
   const int64_t componentUID,
   const bool isSystem,
   const std::string & componentDescription)

{
      
MyRow row(fullTableName_);

   row.componentUID_ = componentUID;
   row.componentName_ = componentName;
   row.isSystem_ = isSystem;
   row.componentDescription_ = componentDescription;
   
// write the row to the components table
   return myTable_.insert(row);

}
//************* End of PrivMgrComponents::registerComponentInternal ************


// *****************************************************************************
// *                                                                           *
// * Function: PrivMgrComponents::unregisterComponent                          *
// *                                                                           *
// *    Removes component from the COMPONENTS table and removes all operations *
// * associated with the component and any granted privileges related to the   *
// * component.                                                                *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// *  Parameters:                                                              *
// *                                                                           *
// *  <componentName>                 const std::string &             In       *
// *    is the name of the component.  Name is assumed to be upper case.       *
// *                                                                           *
// *  <dropBehavior>                  PrivDropBehavior                In       *
// *    indicates whether restrict or cascade behavior is requested.           *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// * Returns: PrivStatus                                                       *
// *                                                                           *
// * STATUS_GOOD: Component was unregistered.                                  *
// *           *: Unable to unregister component, see diags.                   *
// *                                                                           *
// *****************************************************************************
PrivStatus PrivMgrComponents::unregisterComponent(
   const std::string & componentName,
   PrivDropBehavior dropBehavior)
   
{

//TODO: Related, could check below for unregistering system level components.
PrivMgrComponentPrivileges componentPrivileges(metadataLocation_, pDiags_);

   if (!ComUser::isRootUserID()&&
       !componentPrivileges.hasSQLPriv(ComUser::getCurrentUser(), SQLOperation::MANAGE_COMPONENTS, true))
   {   
      *pDiags_ << DgSqlCode(-CAT_NOT_AUTHORIZED);
      return STATUS_ERROR;
   }
   
   if (!exists(componentName))
   {
      *pDiags_ << DgSqlCode(-CAT_TABLE_DOES_NOT_EXIST_ERROR)
               << DgTableName(componentName.c_str());
      return STATUS_ERROR;
   }

std::string componentUIDString;
int64_t componentUID;
bool isSystem;
std::string tempStr;

   fetchByName(componentName,componentUIDString,componentUID,isSystem,tempStr);

//TODO: check authority if it is a system component

PrivMgrComponentOperations componentOperations(metadataLocation_,pDiags_);
PrivStatus privStatus = STATUS_GOOD;

   if (dropBehavior == PrivDropBehavior::RESTRICT)
   {
      if (componentOperations.isComponentUsed(componentUIDString))
      {
         *pDiags_ << DgSqlCode(-CAT_DEPENDENT_OBJECTS_EXIST);
         return STATUS_ERROR; 
      }
   }
   else  //CASCADE
   {  
      // Function dropAll() also drops any privileges granted on
      // those operations.  
      privStatus = componentOperations.dropAll(componentUIDString);
      
      if (privStatus != STATUS_GOOD)
      {
         if (pDiags_->getNumber(DgSqlCode::ERROR_) == 0)
            PRIVMGR_INTERNAL_ERROR("Unable to drop operations for component");
         return STATUS_ERROR;
      }
   }

// If there were any operations or granted privileges on this component, they
// are now gone.  Delete the component from the COMPONENTS table.

   std::string whereClause("WHERE COMPONENT_NAME = '");
   whereClause += componentName;
   whereClause += "'";
   
   return myTable_.deleteWhere(whereClause);

}
//*************** End of PrivMgrComponents::unregisterComponent ****************

// *****************************************************************************
//    MyRow methods
// *****************************************************************************

// *****************************************************************************
// *                                                                           *
// * Function: MyRow::lookupByName                                             *
// *                                                                           *
// *    Looks for a specified component name in cache, and if found, returns   *
// *  associated data.                                                         *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// *  Parameters:                                                              *
// *                                                                           *
// *  <componentName>                 const std::string &             In       *
// *    is the name of the component.  Name is assumed to be upper case.       *
// *                                                                           *
// *  <componentUID>                  int64_t &                       Out      *
// *    passes back the unique ID associated with the component.               *
// *                                                                           *
// *  <isSystem>                      bool &                          Out      *
// *    passes back true if the component is a system component, otherwise     *
// *    false is passed back.                                                  *
// *                                                                           *
// *  <componentDescription>          std::string &                   Out      *
// *    passes back the description of the component.  Note, providing a       *
// *  description is optional when the component is registered, so the         *
// *  value may be empty.                                                      *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// * Returns: bool                                                             *
// *                                                                           *
// *  true: Component name found in cache.                                     *
// * false: Component name not found in cache.                                 *
// *                                                                           *
// *****************************************************************************
bool MyRow::lookupByName(
   const std::string & componentName,
   int64_t & componentUID,
   bool & isSystem,
   std::string & componentDescription) 
   
{

// If componentUID_ is zero, that means data is uninitialized.  

   if (componentUID_ == 0 || componentName != componentName_)
      return false;
      
   componentUID = componentUID_;
   isSystem = isSystem_;
   componentDescription = componentDescription_;
   return true;
   
}  
//*********************** End of MyRow::lookupByName ***************************


// *****************************************************************************
//    MyTable methods
// *****************************************************************************


// *****************************************************************************
// *                                                                           *
// * Function: MyTable::fetchByName                                            *
// *                                                                           *
// *    Reads from the COMPONENTS table and returns the row associated with    *
// *    a specified component name.                                            *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// *  Parameters:                                                              *
// *                                                                           *
// *  <componentName>                 const std::string &             In       *
// *    is the name of the component.  Name is assumed to be upper case.       *
// *                                                                           *
// *  <row>                           MyRow &                         Out      *
// *    passes back a reference to MyRow, containing the data read.            *
// *                                                                           *
// *****************************************************************************
// *                                                                           *
// * Returns: PrivStatus                                                       *
// *                                                                           *
// * STATUS_GOOD: Found name, row returned.                                    *
// *           *: Name not found or error encountered.                         *
// *                                                                           *
// *****************************************************************************
PrivStatus MyTable::fetchByName(
   const std::string & componentName,
   MyRow & row)
   
{

// Check the last row read before reading metadata.
   if (lastRowRead_.lookupByName(componentName,row.componentUID_,
                                 row.isSystem_,row.componentDescription_))
      return STATUS_GOOD;
      
// Not found in cache, look for the component name in metadata.
std::string whereClause ("WHERE COMPONENT_NAME = '");

   whereClause += componentName;  //TODO: is character set OK?  Do we need to do anything to make sure?
   whereClause += "'";            // For instance, prefix with _UTF8?
   
PrivStatus privStatus = selectWhereUnique(whereClause,row);

   switch (privStatus)
   {
      // Return status to caller to handle
      case STATUS_NOTFOUND:
      case STATUS_ERROR:
         return privStatus;
         break;

      // Object exists - break out and continue
      case STATUS_GOOD:
      case STATUS_WARNING:
         return STATUS_GOOD;
         break;

      // Should not occur, internal error
      default:
         PRIVMGR_INTERNAL_ERROR("Switch statement in PrivMgrComponents::MyTable::fetchByName()");
         return STATUS_ERROR;
         break;
   }
   
   return STATUS_GOOD;

}   
//********************** End of MyTable::fetchByName ***************************
  

// *****************************************************************************
// *                                                                           *
// * Function: MyTable::insert                                                 *
// *                                                                           *
// *    Inserts a row into the COMPONENTS 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)
{

char insertStatement[1000];
const MyRow & row = static_cast<const MyRow &>(rowIn);
char isSystem[3] = {0};

   if (row.isSystem_)
      isSystem[0] = 'Y';
   else
      isSystem[0] = 'N';

   sprintf(insertStatement, "insert into %s values (%ld, '%s', '%s', '%s')",
           tableName_.c_str(),
           row.componentUID_,
           row.componentName_.c_str(),
           isSystem,
           row.componentDescription_.c_str());
           
   return CLIImmediate(insertStatement);

}
//************************** End of MyTable::insert ****************************


// *****************************************************************************
// *                                                                           *
// * 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 COMPONENT_UID, COMPONENT_NAME, IS_SYSTEM, COMPONENT_DESCRIPTION FROM ");

   selectStmt += tableName_;
   selectStmt += " ";
   selectStmt += whereClause;

ExeCliInterface cliInterface(STMTHEAP);

PrivStatus privStatus = CLIFetch(cliInterface,selectStmt);   
   
   if (privStatus != STATUS_GOOD && privStatus != STATUS_WARNING)
      return privStatus;   
  
// Row read successfully.  Extract the columns.

char * ptr = NULL;
Lng32 len = 0;
char value[500];
MyRow & row = static_cast<MyRow &>(rowOut);

   // column 1:  component_uid
   cliInterface.getPtrAndLen(1,ptr,len);
   row.componentUID_ = *(reinterpret_cast<int64_t*>(ptr));

   // column 2:  component_name
   cliInterface.getPtrAndLen(2,ptr,len);
   strncpy(value,ptr,len);
   value[len] = 0;
   row.componentName_ = value;

   // column 3:  is_system
   cliInterface.getPtrAndLen(3,ptr,len);
   strncpy(value,ptr,len);
   value[len] = 0;
   if (value[0] == 'Y')
      row.isSystem_ = true;
   else
      row.isSystem_ = false;
   
   // column 4: component_description
   cliInterface.getPtrAndLen(4,ptr,len);
   strncpy(value, ptr,len);
   value[len] = 0;
   row.componentDescription_ = value;
   
   lastRowRead_ = row;

   return STATUS_GOOD;
   
}
//******************* End of MyTable::selectWhereUnique ************************