/**********************************************************************
// @@@ 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 @@@
 **********************************************************************/
#ifndef EX_EXE_UTIL_H
#define EX_EXE_UTIL_H


/* -*-C++-*-
*****************************************************************************
*
* File:         ExExeUtil.h
* Description:
*
*
* Created:      9/12/2005
* Language:     C++
*
*
*
*
*****************************************************************************
*/

// forward
class ex_expr;
class Queue;
class ExTransaction;
class ContextCli;
class IpcServer;
class IpcServerClass;
class ExStatisticsArea;
class CmpDDLwithStatusInfo;
class ExSqlComp;

class ExProcessStats;

class ExpHbaseInterface;
class HdfsClient;

//class FILE_STREAM;
#include "ComAnsiNamePart.h"
#include "ComTdbExeUtil.h"
#include "ComTdbRoot.h"
#include "ComRtUtils.h"
#include "ExExeUtilCli.h"
#include "ExpLOBstats.h"
#include "hiveHook.h"
#include "ExpHbaseDefs.h"

#include "SequenceFileReader.h"

#define TO_FMT3u(u) MINOF(((u)+500)/1000, 999)
#define MAX_ACCUMULATED_STATS_DESC 2
#define MAX_PERTABLE_STATS_DESC    256
#define MAX_PROGRESS_STATS_DESC    256 
#define MAX_OPERATOR_STATS_DESC    512
#define MAX_RMS_STATS_DESC         512
#define BUFFER_SIZE 4000
#define MAX_AUTHIDTYPE_CHAR        11
#define MAX_USERINFO_CHAR          257
// max number of attempts to create ORSERV upon failure
#define MAX_CREATE_ORSERV_COUNT 5

// -----------------------------------------------------------------------
// Classes defined in this file
// -----------------------------------------------------------------------
class ExExeUtilTdb;
class ExExeUtilDisplayExplainTdb;
class ExExeUtilDisplayExplainComplexTdb;
class ExExeUtilHiveTruncateTdb;
class ExExeUtilHiveQueryTdb;
class ExExeUtilSuspendTdb;
class ExExeUtilSuspendTcb;
class ExpHbaseInterface;

// -----------------------------------------------------------------------
// Classes referenced in this file
// -----------------------------------------------------------------------
class ex_tcb;

// -----------------------------------------------------------------------
// ExExeUtilTdb
// -----------------------------------------------------------------------
class ExExeUtilTdb : public ComTdbExeUtil
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilTdb()
    {}

  virtual ~ExExeUtilTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};


struct QueryString {
  public:
const char * str;
};

//
// Task control block
//
class ExExeUtilTcb : public ex_tcb
{
  friend class ExExeUtilTdb;
  friend class ExExeUtilPrivateState;

 public:
  enum Step
    {
      EMPTY_,
      PROCESSING_,
      DONE_,
      HANDLE_ERROR_,
      CANCELLED_
    };

  enum ProcessQueryStep
  {
    PROLOGUE_,
    EXECUTE_,
    FETCH_ROW_,
    RETURN_ROW_,
    ERROR_RETURN_,
    CLOSE_,
    EPILOGUE_,
    ALL_DONE_
  };


  // Constructor
  ExExeUtilTcb(const ComTdbExeUtil & exe_util_tdb,
               const ex_tcb * child_tcb, // for child queue
               ex_globals * glob = 0);

  ~ExExeUtilTcb();

  virtual short work();

  ex_queue_pair getParentQueue() const;
  Int32 orderedQueueProtocol() const;

  virtual void freeResources();

  virtual Int32 numChildren() const;
  virtual const ex_tcb* getChild(Int32 pos) const;

  void glueQueryFragments(Lng32 queryArraySize,
                          const QueryString * queryArray,
                          char * &gluedQuery,
                          Lng32 &gluedQuerySize);

  // extract parts from 'objectName' and fixes up delimited names.
  Lng32 extractParts
  (char * objectName,
   char ** parts0,
   char ** parts1,
   char ** parts2
  );

   Lng32 changeAuditAttribute(char * tableName,
                             NABoolean makeAudited,
                             NABoolean isVolatile = FALSE,
                             NABoolean isIndex = FALSE,
                             NABoolean parallelAlter = FALSE
                             );

  virtual short moveRowToUpQueue(const char * row, Lng32 len = -1,
                                 short * rc = NULL, NABoolean isVarchar = TRUE);

  NABoolean isUpQueueFull(short size);

  static char * getTimeAsString(Int64 t, char * timeBuf,
                                NABoolean noUsec = FALSE);
  char * getTimestampAsString(Int64 t, char * timeBuf);

  short initializeInfoList(Queue* &infoList);
  short fetchAllRows(Queue * &infoList,
                     char * query,
                     Lng32 numOutputEntries,
                     NABoolean varcharFormat,
                     short &rc,
		     NABoolean monitorThis=FALSE);
    
  ex_expr::exp_return_type evalScanExpr(char * ptr, Lng32 len, 
                                        NABoolean copyToVCbuf);

  char * getStatusString(const char * operation,
                         const char * status,
                         const char * object,
                         char * outBuf,
                         NABoolean isET = FALSE,
                         char * timeBuf = NULL,
                         char * queryBuf = NULL,
                         char * sqlcodeBuf = NULL);

  short executeQuery(char * step, char * object,
                     char * query,
                     NABoolean displayStartTime, NABoolean displayEndTime,
                     short &rc, short * warning, Lng32 * errorCode = NULL,
                     NABoolean moveErrorRow = TRUE,
                     NABoolean continueOnError = FALSE,
		     NABoolean monitorThis=FALSE);

  ExeCliInterface * cliInterface() { return cliInterface_; };
  ExeCliInterface * cliInterface2() { return cliInterface2_; };

  ComDiagsArea *&getDiagsArea() { return diagsArea_; }

  void setDiagsArea(ComDiagsArea * d) { diagsArea_ = d; }

  short setSchemaVersion(char * param1);

  short setSystemVersion();

  short holdAndSetCQD(const char * defaultName, const char * defaultValue,
                      ComDiagsArea * globalDiags = NULL);

  short restoreCQD(const char * defaultName, ComDiagsArea * globalDiags = NULL);

  short setCS(const char * csName, char * csValue,
              ComDiagsArea * globalDiags = NULL);
  short resetCS(const char * csName, ComDiagsArea * globalDiags = NULL);

  void setMaintainControlTableTimeout(char * catalog);
  void restoreMaintainControlTableTimeout(char * catalog);

  static Lng32 holdAndSetCQD(const char * defaultName, const char * defaultValue,
                         ExeCliInterface * cliInterface,
                         ComDiagsArea * globalDiags = NULL);

  static Lng32 restoreCQD(const char * defaultName,
                         ExeCliInterface * cliInterface,
                         ComDiagsArea * globalDiags = NULL);

  static Lng32 setCS(const char * csName, char * csValue,
                    ExeCliInterface * cliInterface,
                    ComDiagsArea * globalDiags = NULL);
  static Lng32 resetCS(const char * csName,
                      ExeCliInterface * cliInterface,
                      ComDiagsArea * globalDiags = NULL);

  short disableCQS();
  short restoreCQS();

  short doubleQuoteStr(char * str, char * newStr,
                       NABoolean singleQuote);

  char * getSchemaVersion()
  { return (strlen(versionStr_) == 0 ? (char *)"" : versionStr_); }

  char * getSystemVersion()
  { return (strlen(sysVersionStr_) == 0 ? NULL : sysVersionStr_); }

  Lng32 getSchemaVersionLen() { return versionStrLen_; }

  short getObjectUid(char * catName, char * schName,
                     char * objName,
                     NABoolean isIndex, NABoolean isMv,
                     char * uid);

  short lockUnlockObject(char * tableName,
                         NABoolean lock,
                         NABoolean parallel,
                         char * failReason);

  short alterObjectState(NABoolean online, char * tableName,
                         char * failReason, NABoolean forPurgedata);
  short alterDDLLock(NABoolean add, char * tableName,
                     char * failReason, NABoolean isMV,
                     Int32 lockType,
                     const char * lockPrefix = NULL,
                     NABoolean skipDDLLockCheck = FALSE);
  short alterCorruptBit(short val, char * tableName,
                        char * failReason, Queue* indexList);

  short alterAuditFlag(NABoolean audited, char * tableName,
                       NABoolean isIndex);

  short handleError();

  short handleDone();

  NABoolean &infoListIsOutputInfo() { return infoListIsOutputInfo_; }

  // Error: -1, creation of IpcServerClass failed.
  //        -2, PROCESSNAME_CREATE_ failed.
  //        -3, allocateServerProcess failed.
  short createServer(char *serverName,
                     const char *inPName,
                     IpcServerTypeEnum serverType,
                     IpcServerAllocationMethod servAllocMethod,
                     char *nodeName,
                     short cpu,
                     const char *partnName,
                     IpcServer* &ipcServer,
                     NABoolean logError,
                     const char * operation);

  void deleteServer(IpcServer *ipcServer);

  NABoolean isProcessObsolete(short cpu, pid_t pin, short segmentNum,
                              Int64 procCreateTime);

protected:

  const ex_tcb * childTcb_;

  ex_queue_pair         qparent_;
  ex_queue_pair  qchild_;

  atp_struct * workAtp_;

  ComDiagsArea * diagsArea_;

  char * query_;

  unsigned short tcbFlags_;

  char * explQuery_;

  ExExeUtilTdb & exeUtilTdb() const{return (ExExeUtilTdb &) tdb;};
  void handleErrors(Lng32 error);

  CollHeap * getMyHeap()
    {
      return (getGlobals()->getDefaultHeap());
    };

  void  AddCommas (char *outStr, Lng32 &intSize) const;
  void FormatFloat (char *outStr, Lng32 &intSize,
                    Lng32 &fullSize, double floatVal,
                    NABoolean normalMode, NABoolean expertMode)const;

  Queue * infoList_;
  NABoolean infoListIsOutputInfo_;
  char *childQueryId_;
  Lng32 childQueryIdLen_;
  SQL_QUERY_COST_INFO childQueryCostInfo_;
  SQL_QUERY_COMPILER_STATS_INFO childQueryCompStatsInfo_;
  char *outputBuf_;

  char failReason_[2000];

private:
  ExeCliInterface * cliInterface_;
  ExeCliInterface * cliInterface2_;

  ProcessQueryStep pqStep_;

  char   versionStr_[10];
  Lng32   versionStrLen_;

  char   sysVersionStr_[10];
  Lng32   sysVersionStrLen_;

  NABoolean restoreTimeout_;

  AnsiName *extractedPartsObj_;

  Int64 startTime_;
  Int64 endTime_;
  Int64 elapsedTime_;

  short warning_;
};

class ExExeUtilPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilTcb;
  friend class ExExeUtilCleanupVolatileTablesTcb;
  friend class ExExeUtilCreateTableAsTcb;
  friend class ExExeUtilHiveTruncateTcb;
  friend class ExExeUtilHiveQueryTcb;
  friend class ExExeUtilAQRTcb;
  friend class ExExeUtilHBaseBulkLoadTcb;
  friend class ExExeUtilHBaseBulkUnLoadTcb;


 public:
  ExExeUtilPrivateState(const ExExeUtilTcb * tcb); //constructor
  ~ExExeUtilPrivateState();        // destructor
  ex_tcb_private_state * allocate_new(const ex_tcb * tcb);
 protected:
  ExExeUtilTcb::Step step_;
  Int64 matches_;
};

// -----------------------------------------------------------------------
// ExExeUtilDisplayExplainTdb
// -----------------------------------------------------------------------
class ExExeUtilDisplayExplainTdb : public ComTdbExeUtilDisplayExplain
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilDisplayExplainTdb()
    {}

  virtual ~ExExeUtilDisplayExplainTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};


//
// Task control block
//
class ExExeUtilDisplayExplainTcb : public ExExeUtilTcb
{
  friend class ExExeUtilDisplayExplainTdb;
  friend class ExExeUtilPrivateState;

 public:

  // Constructor
  ExExeUtilDisplayExplainTcb(const ComTdbExeUtilDisplayExplain & exe_util_tdb,
                             ex_globals * glob = 0);

  ~ExExeUtilDisplayExplainTcb();

  virtual short work();

  virtual ex_tcb_private_state * allocatePstates(
                                                            Lng32 &numElems,      // inout, desired/actual elements
                                                            Lng32 &pstateLength); // out, length of one element

  short processExplainRows();

  //state machine states for work() method
  enum Step
    {
      EMPTY_,
      PREPARE_,
      SETUP_EXPLAIN_,
      FETCH_PROLOGUE_,
      FETCH_EXPLAIN_ROW_,
      FETCH_FIRST_EXPLAIN_ROW_,
      GET_COLUMNS_,
      DO_HEADER_,
      DO_OPERATOR_,
      RETURN_FMT_ROWS_,
      RETURN_EXPLAIN_ROW_,
      FETCH_EPILOGUE_,
      FETCH_EPILOGUE_AND_RETURN_ERROR_,
      DONE_,
      HANDLE_ERROR_,
      RETURN_ERROR_,
      CANCELLED_
    };

 protected:

 private:
  // Enums
  //  enum { MLINE = 74    };          // max number of lines in the array, 3000/50 + 14
  //  enum { MLEN  = 80    };          // max length of each line
  enum { MNAME = 60    };          // width of the returned SQL name columns
  enum { MOPER = 30    };          // width of the returned SQL operator column
  enum { MCOST = 200   };          // width of the returned SQL detailed_cost column
  enum { MDESC = 30000  };          // width of the returned SQL description column
  enum { MUSERSP = 20  };          // max output number space for user
  //  enum { MWIDE = MLEN-1};          // max line width in char for output
  enum { COL2  = 28    };          // position of column 2 (value) on the line
  enum Option                      //which output format we are using
    {
      N_,
      E_,
      F_,
      M_
    };

  // Variables
  SQLMODULE_ID * module_;
  SQLSTMT_ID   * stmt_;
  SQLDESC_ID   * sql_src_;
  SQLDESC_ID   * input_desc_;
  SQLDESC_ID   * output_desc_;
  char         * outputBuf_;
  char * explainQuery_;

  Option optFlag_;              // option flag
  char ** lines_;
  //  char  lines_[MLINE][MLEN];    // array of MLINE lines MLEN char wide
  Lng32  cntLines_;              // count of lines in lines_ array
  Lng32  nextLine_;              // number of next line to output from array
  char* parsePtr_;              // location in input string being parsed
  Lng32  header_;                // flag saying current node is root if 1
  Lng32  lastFrag_;              // previous row fragment number
  char  lastOp_[MOPER+1];       // previous row operator name

  char * optFOutput;
  //  char  optFOutput[MLEN];        // formatted line for optionsF

  // Next 13 are the local column data, storage for one node's info
  char  moduleName_[MNAME+1];   // module name column, sometimes null, MNAME=60
  char  statementName_[MNAME+1];// stmt name column, sometimes null, MNAME=60
  Int64 planId_;                // large number, unique per plan
  Lng32  seqNum_;                // number of this node
  char  operName_[MOPER+1];     // operator name, MOPER=30
  Lng32  leftChild_;             // number of left child
  Lng32  rightChild_;            // number of right child
  char  tName_[MNAME+1];        // table name, often null, MNAME=60
  float cardinality_;           // number of rows returned by this node
  float operatorCost_;          // cost of this node alone, in seconds
  float totalCost_;             // cost of this node and all children, in seconds
  char  detailCost_[MCOST+1];   // node cost in 5 parts in key-value format, MCOST=200
  char  description_[MDESC+1];  // other attributs in key-value format, MDESC=3000

  Lng32 MLINE;
  Lng32 MLEN;
  Lng32 MWIDE;

  // Methods
  short GetColumns();
  void  FormatForF();                // formats the line for optionsF and places into optFOutput
  void  DoHeader();
  void  DoOperator();
  short OutputLines();
  void  truncate_whitespace(char * str) const;
  void  DoSeparator();
  //void  AddCommas (char *outStr, long &intSize) const;
  //void  FormatFloat (char *outStr, long &intSize, long &fullSize, float floatVal) const;
  void  FormatNumber (char *outStr, Lng32 &intSize, Lng32 &fullSize, char *strVal) const;
  Lng32  GetField (char *col, const char *key, char *&fieldptr, Lng32 &fullSize) const;
  Lng32  ParseField (char *&keyptr, char *&fieldptr, Lng32 &keySize, Lng32 &fullSize,
                    Lng32 &done);
  Lng32  IsNumberFmt(char *fieldptr) const;
  void  FormatFirstLine (void);
  NABoolean filterKey(
       const char *key, Lng32 keySize, char * value, char * retVal,
       Lng32 &decLoc);
  void  FormatLine (const char *key, const char *val, Lng32 keySize, Lng32 valSize,
                    Lng32 indent = 0, Lng32 decLoc = 0);
  void  FormatLongLine (const char *key, char *val, Lng32 keySize, Lng32 valSize,
                        Lng32 indent = 0);
  void  FormatSQL (const char *key, char *val, Lng32 keySize, Lng32 valSize, Lng32 indent = 0);
  Lng32  FindParens(char *inStr, Lng32 par[]) const;

  ExExeUtilDisplayExplainTdb & exeUtilTdb() const
    {return (ExExeUtilDisplayExplainTdb &) tdb;};
};


class ExExeUtilDisplayExplainPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilDisplayExplainTcb;

 public:
  ExExeUtilDisplayExplainPrivateState();
  ~ExExeUtilDisplayExplainPrivateState();        // destructor
 protected:
  ExExeUtilDisplayExplainTcb::Step step_;
  Int64 matches_;
};

//////////////////////////////////////////////////////////////////////////


// -----------------------------------------------------------------------
// ExExeUtilDisplayExplainComplexTdb
// -----------------------------------------------------------------------
class ExExeUtilDisplayExplainComplexTdb : public ComTdbExeUtilDisplayExplainComplex
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilDisplayExplainComplexTdb()
    {}

  virtual ~ExExeUtilDisplayExplainComplexTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};


//
// Task control block
//
class ExExeUtilDisplayExplainComplexTcb : public ExExeUtilTcb
{
  friend class ExExeUtilDisplayExplainComplexTdb;
  friend class ExExeUtilPrivateState;

 public:

  // Constructor
  ExExeUtilDisplayExplainComplexTcb(const ComTdbExeUtilDisplayExplainComplex & exe_util_tdb,
                                    ex_globals * glob = 0);

  ~ExExeUtilDisplayExplainComplexTcb();

  virtual short work();

  virtual ex_tcb_private_state *
  allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

private:
  //state machine states for work() method
  enum Step
    {
      EMPTY_,
      TURN_ON_IMOD_,
      IN_MEMORY_BASE_TABLE_CREATE_,
      IN_MEMORY_CREATE_,
      REGULAR_CREATE_,
      ALTER_TO_NOAUDIT_,
      ALTER_TO_AUDIT_,
      EXPLAIN_CREATE_,
      EXPLAIN_INSERT_SELECT_,
      DROP_AND_ERROR_,
      DROP_AND_DONE_,
      DONE_,
      ERROR_,
      CANCELLED_
    };

  ExExeUtilDisplayExplainComplexTdb & exeUtilTdb() const
    {return (ExExeUtilDisplayExplainComplexTdb &) tdb;};

  Step step_;
};

class ExExeUtilDisplayExplainComplexPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilDisplayExplainComplexTcb;

public:
  ExExeUtilDisplayExplainComplexPrivateState();
  ~ExExeUtilDisplayExplainComplexPrivateState();        // destructor
protected:
  Int64 matches_;
};

class ExExeUtilDisplayExplainShowddlTcb : public ExExeUtilTcb
{
  friend class ExExeUtilDisplayExplainComplexTdb;
  friend class ExExeUtilPrivateState;

 public:

  // Constructor
  ExExeUtilDisplayExplainShowddlTcb(const ComTdbExeUtilDisplayExplainComplex & exe_util_tdb,
                                    ex_globals * glob = 0);

  ~ExExeUtilDisplayExplainShowddlTcb();

  virtual short work();

  virtual ex_tcb_private_state *
  allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

private:
  //state machine states for work() method
  enum Step
    {
      EMPTY_,
      GET_LABEL_STATS_,
      EXPLAIN_CREATE_,
      DONE_,
      ERROR_,
      CANCELLED_
    };

  ExExeUtilDisplayExplainComplexTdb & exeUtilTdb() const
    {return (ExExeUtilDisplayExplainComplexTdb &) tdb;};

  Step step_;

  char * newQry_;
};

class ExExeUtilDisplayExplainShowddlPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilDisplayExplainShowddlTcb;

public:
  ExExeUtilDisplayExplainShowddlPrivateState();
  ~ExExeUtilDisplayExplainShowddlPrivateState();        // destructor
protected:
  Int64 matches_;
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilCreateTableAsTdb
// -----------------------------------------------------------------------
class ExExeUtilCreateTableAsTdb : public ComTdbExeUtilCreateTableAs
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilCreateTableAsTdb()
    {}

  virtual ~ExExeUtilCreateTableAsTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

class ExExeUtilCreateTableAsTcb : public ExExeUtilTcb
{
  friend class ExExeUtilCreateTableAsTdb;
  friend class ExExeUtilPrivateState;

 public:
  // Constructor
  ExExeUtilCreateTableAsTcb(const ComTdbExeUtil & exe_util_tdb,
                            ex_globals * glob = 0);

  virtual short work();

  ExExeUtilCreateTableAsTdb & ctaTdb() const
    {
      return (ExExeUtilCreateTableAsTdb &) tdb;
    };

  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

 private:
  enum Step
    {
      INITIAL_,
      CREATE_,
      TRUNCATE_TABLE_,
      INSERT_SIDETREE_,
      INSERT_VSBB_,
      ALTER_TO_NOAUDIT_,
      ALTER_TO_AUDIT_,
      ALTER_TO_AUDIT_AND_INSERT_VSBB_,
      UPD_STATS_,
      DONE_,
      HANDLE_ERROR_, TRUNCATE_TABLE_AND_ERROR_, ERROR_,
      DROP_AND_ERROR_,
      DROP_AND_DONE_,
      INSERT_SIDETREE_EXECUTE_,
      INSERT_VSBB_EXECUTE_
    };


  Step step_;

  NABoolean doSidetreeInsert_;

  NABoolean tableExists_;
};

class ExExeUtilCreateTableAsPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilCreateTableAsTcb;

 public:
  ExExeUtilCreateTableAsPrivateState();
  ~ExExeUtilCreateTableAsPrivateState();        // destructor
 protected:
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilCleanupVolatileTablesTdb
// -----------------------------------------------------------------------
class ExExeUtilCleanupVolatileTablesTdb : public ComTdbExeUtilCleanupVolatileTables
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilCleanupVolatileTablesTdb()
    {}

  virtual ~ExExeUtilCleanupVolatileTablesTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

class ExExeUtilVolatileTablesTcb : public ExExeUtilTcb
{
 public:
  // Constructor
  ExExeUtilVolatileTablesTcb(const ComTdbExeUtil & exe_util_tdb,
                             ex_globals * glob = 0);

  virtual ex_tcb_private_state * allocatePstates(
                                                 Lng32 &numElems,      // inout, desired/actual elements
                                                 Lng32 &pstateLength); // out, length of one element

 protected:
  short isCreatorProcessObsolete(const char * name,
                                 NABoolean includesCat,
                                 NABoolean isCSETableName);
};

class ExExeUtilCleanupVolatileTablesTcb : public ExExeUtilVolatileTablesTcb
{
  friend class ExExeUtilCleanupVolatileTablesTdb;
  friend class ExExeUtilPrivateState;

 public:
  // Constructor
  ExExeUtilCleanupVolatileTablesTcb(const ComTdbExeUtil & exe_util_tdb,
                                    ex_globals * glob = 0);

  virtual short work();

  ExExeUtilCleanupVolatileTablesTdb & cvtTdb() const
    {
      return (ExExeUtilCleanupVolatileTablesTdb &) tdb;
    };

  static short dropVolatileSchema(ContextCli * currContext,
                                  char * schemaName,
                                  CollHeap * heap,
                                  ComDiagsArea *&diagsArea,
                                  ex_globals *globals = NULL);
  static short dropVolatileTables(ContextCli * currContext, CollHeap * heap);
  short dropHiveTempTablesForCSEs();

 private:
  enum Step
    {
      INITIAL_,
      FETCH_SCHEMA_NAMES_,
      START_CLEANUP_,
      CHECK_FOR_OBSOLETE_CREATOR_PROCESS_,
      BEGIN_WORK_,
      DO_CLEANUP_,
      COMMIT_WORK_,
      END_CLEANUP_,
      CLEANUP_HIVE_TABLES_,
      DONE_,
      ERROR_
    };

  Step step_;

  Queue * schemaNamesList_;

  NABoolean someSchemasCouldNotBeDropped_;
  char errorSchemas_[1010];

  char * schemaQuery_;
};

class ExExeUtilVolatileTablesPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilVolatileTablesTcb;

 public:
  ExExeUtilVolatileTablesPrivateState();
  ~ExExeUtilVolatileTablesPrivateState();        // destructor
 protected:
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetVolatileInfoTdb
// -----------------------------------------------------------------------
class ExExeUtilGetVolatileInfoTdb : public ComTdbExeUtilGetVolatileInfo
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilGetVolatileInfoTdb()
    {}

  virtual ~ExExeUtilGetVolatileInfoTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetVolatileInfoTcb
// -----------------------------------------------------------------------
class ExExeUtilGetVolatileInfoTcb : public ExExeUtilVolatileTablesTcb
{
  friend class ExExeUtilGetVolatileInfoTdb;
  friend class ExExeUtilPrivateState;

 public:
  // Constructor
  ExExeUtilGetVolatileInfoTcb(const ComTdbExeUtil & exe_util_tdb,
                              ex_globals * glob = 0);

  virtual short work();

  ExExeUtilGetVolatileInfoTdb & gviTdb() const
    {
      return (ExExeUtilGetVolatileInfoTdb &) tdb;
    };

 private:
  enum Step
    {
      INITIAL_,
      GET_SCHEMA_VERSION_,
      GET_ALL_NODE_NAMES_,
      APPEND_NEXT_QUERY_FRAGMENT_,
      FETCH_ALL_ROWS_,
      RETURN_ALL_SCHEMAS_,
      RETURN_ALL_TABLES_,
      RETURN_TABLES_IN_A_SESSION_,
      DONE_,
      ERROR_
    };

  Step step_;

  OutputInfo * prevInfo_;

  char * infoQuery_;
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetErrorInfoTdb
// -----------------------------------------------------------------------
class ExExeUtilGetErrorInfoTdb : public ComTdbExeUtilGetErrorInfo
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilGetErrorInfoTdb()
    {}

  virtual ~ExExeUtilGetErrorInfoTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetErrorInfoTcb
// -----------------------------------------------------------------------
class ExExeUtilGetErrorInfoTcb : public ExExeUtilTcb
{
  friend class ExExeUtilGetErrorInfoTdb;
  friend class ExExeUtilPrivateState;

 public:
  // Constructor
  ExExeUtilGetErrorInfoTcb(const ComTdbExeUtilGetErrorInfo & exe_util_tdb,
			   ex_globals * glob = 0);

  virtual short work();

  ExExeUtilGetErrorInfoTdb & geiTdb() const
    {
      return (ExExeUtilGetErrorInfoTdb &) tdb;
    };

  ex_tcb_private_state * 
    allocatePstates(
		    Lng32 &numElems,      // inout, desired/actual elements
		    Lng32 &pstateLength)  // out, length of one element
    ;

 private:
  enum Step
    {
      INITIAL_,
      RETURN_TEXT_,
      DONE_,
      ERROR_
    };

  Step step_;

  char * outputBuf_;
};

class ExExeUtilGetErrorInfoPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilGetErrorInfoTcb;

 public:
  ExExeUtilGetErrorInfoPrivateState();
  ~ExExeUtilGetErrorInfoPrivateState();        // destructor
 protected:
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilLoadVolatileTableTdb
// -----------------------------------------------------------------------
class ExExeUtilLoadVolatileTableTdb : public ComTdbExeUtilLoadVolatileTable
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilLoadVolatileTableTdb()
    {}

  virtual ~ExExeUtilLoadVolatileTableTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

class ExExeUtilLoadVolatileTableTcb : public ExExeUtilTcb
{
  friend class ExExeUtilLoadVolatileTableTdb;
  friend class ExExeUtilPrivateState;

 public:
  // Constructor
  ExExeUtilLoadVolatileTableTcb(const ComTdbExeUtil & exe_util_tdb,
                                ex_globals * glob = 0);

  virtual short work();

  ExExeUtilLoadVolatileTableTdb & lvtTdb() const
    {
      return (ExExeUtilLoadVolatileTableTdb &) tdb;
    };

  ex_tcb_private_state * allocatePstates(
                                         Lng32 &numElems,      // inout, desired/actual elements
                                         Lng32 &pstateLength)  // out, length of one element
    ;

 private:
  enum Step
    {
      INITIAL_,
      INSERT_,
      UPD_STATS_,
      DONE_,
      ERROR_
    };

  Step step_;

};

class ExExeUtilLoadVolatileTablePrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilLoadVolatileTableTcb;

 public:
  ExExeUtilLoadVolatileTablePrivateState();
  ~ExExeUtilLoadVolatileTablePrivateState();        // destructor
 protected:
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetStatisticsTdb
// -----------------------------------------------------------------------
class ExExeUtilGetStatisticsTdb : public ComTdbExeUtilGetStatistics
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilGetStatisticsTdb()
  {}

  virtual ~ExExeUtilGetStatisticsTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetStatisticsTcb
// -----------------------------------------------------------------------
class ExExeUtilGetStatisticsTcb : public ExExeUtilTcb
{
  friend class ExExeUtilGetStatisticsTdb;
  friend class ExExeUtilPrivateState;
  friend class ExExeUtilGetRTSStatisticsTcb;

public:
  // Constructor
  ExExeUtilGetStatisticsTcb(const ComTdbExeUtilGetStatistics & exe_util_tdb,
                            ex_globals * glob = 0);

  ~ExExeUtilGetStatisticsTcb();

  virtual short work();

  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

  ExExeUtilGetStatisticsTdb & getStatsTdb() const
  {
    return (ExExeUtilGetStatisticsTdb &) tdb;
  };
 protected:
  void moveCompilationStatsToUpQueue(CompilationStatsData *cmpStats);

  enum Step
  {
    INITIAL_,
    RETURN_COMPILER_STATS_,
    RETURN_EXECUTOR_STATS_,
    RETURN_OTHER_STATS_,
    SETUP_DETAILED_STATS_,
    FETCH_PROLOGUE_,
    FETCH_FIRST_STATS_ROW_,
    DISPLAY_HEADING_,
    FETCH_STATS_ROW_,
    RETURN_STATS_ROW_,
    FORMAT_AND_RETURN_PERTABLE_STATS_,
    FORMAT_AND_RETURN_ACCUMULATED_STATS_,
    FORMAT_AND_RETURN_ALL_STATS_,
    HANDLE_ERROR_,
    FETCH_EPILOGUE_,
    DONE_,
  };

  Step step_;

  ExStatisticsArea * stats_;

  char * statsQuery_;

  char * statsBuf_;

  char * statsRow_;
  Lng32   statsRowlen_;

  char detailedStatsCQDValue_[40];

  short statsMergeType_;

  short hdfsAccess_;
};

class ExExeUtilGetStatisticsPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilGetStatisticsTcb;

public:
  ExExeUtilGetStatisticsPrivateState();
  ~ExExeUtilGetStatisticsPrivateState();        // destructor
protected:
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetProcessStatisticsTdb
// -----------------------------------------------------------------------
class ExExeUtilGetProcessStatisticsTdb : public ComTdbExeUtilGetProcessStatistics
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilGetProcessStatisticsTdb()
  {}

  virtual ~ExExeUtilGetProcessStatisticsTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
};


//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetUIDTdb
// -----------------------------------------------------------------------
class ExExeUtilGetUIDTdb : public ComTdbExeUtilGetUID
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilGetUIDTdb()
  {}

  virtual ~ExExeUtilGetUIDTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetUIDTcb
// -----------------------------------------------------------------------
class ExExeUtilGetUIDTcb : public ExExeUtilTcb
{
  friend class ExExeUtilGetUIDTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilGetUIDTcb(const ComTdbExeUtilGetUID & exe_util_tdb,
                            ex_globals * glob = 0);

  ~ExExeUtilGetUIDTcb();

  virtual short work();

  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

  ExExeUtilGetUIDTdb & getUIDTdb() const
  {
    return (ExExeUtilGetUIDTdb &) tdb;
  };

private:
  enum Step
  {
    INITIAL_,
    RETURN_UID_,
    ERROR_,
    DONE_,
  };

  Step step_;
};

class ExExeUtilGetUIDPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilGetUIDTcb;

public:
  ExExeUtilGetUIDPrivateState();
  ~ExExeUtilGetUIDPrivateState();        // destructor
protected:
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetQIDTdb
// -----------------------------------------------------------------------
class ExExeUtilGetQIDTdb : public ComTdbExeUtilGetQID
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilGetQIDTdb()
  {}

  virtual ~ExExeUtilGetQIDTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetQIDTcb
// -----------------------------------------------------------------------
class ExExeUtilGetQIDTcb : public ExExeUtilTcb
{
  friend class ExExeUtilGetQIDTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilGetQIDTcb(const ComTdbExeUtilGetQID & exe_util_tdb,
                            ex_globals * glob = 0);

  ~ExExeUtilGetQIDTcb();

  virtual short work();

  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

  ExExeUtilGetQIDTdb & getQIDTdb() const
  {
    return (ExExeUtilGetQIDTdb &) tdb;
  };

private:
  enum Step
  {
    INITIAL_,
    RETURN_QID_,
    ERROR_,
    DONE_,
  };

  Step step_;
};

class ExExeUtilGetQIDPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilGetQIDTcb;

public:
  ExExeUtilGetQIDPrivateState();
  ~ExExeUtilGetQIDPrivateState();        // destructor
protected:
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilPopulateInMemStatsTdb
// -----------------------------------------------------------------------
class ExExeUtilPopulateInMemStatsTdb : public ComTdbExeUtilPopulateInMemStats
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilPopulateInMemStatsTdb()
  {}

  virtual ~ExExeUtilPopulateInMemStatsTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilPopulateInMemStatsTcb
// -----------------------------------------------------------------------
class ExExeUtilPopulateInMemStatsTcb : public ExExeUtilTcb
{
  friend class ExExeUtilPopulateInMemStatsTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilPopulateInMemStatsTcb(const ComTdbExeUtilPopulateInMemStats & exe_util_tdb,
                                 ex_globals * glob = 0);

  ~ExExeUtilPopulateInMemStatsTcb();

  virtual short work();

  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

  ExExeUtilPopulateInMemStatsTdb & pimsTdb() const
  {
    return (ExExeUtilPopulateInMemStatsTdb &) tdb;
  };

private:
  enum Step
  {
    INITIAL_,
    PROLOGUE_,
    DELETE_STATS_,
    POPULATE_HISTOGRAMS_STATS_,
    POPULATE_HISTINTS_STATS_,
    EPILOGUE_,
    EPILOGUE_AND_ERROR_RETURN_,
    ERROR_,
    ERROR_RETURN_,
    DONE_,
  };

  Step step_;
};

class ExExeUtilPopulateInMemStatsPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilPopulateInMemStatsTcb;

public:
  ExExeUtilPopulateInMemStatsPrivateState();
  ~ExExeUtilPopulateInMemStatsPrivateState();        // destructor
protected:
};

///////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilAqrWnrInsertTdb
// -----------------------------------------------------------------------
class ExExeUtilAqrWnrInsertTdb : public ComTdbExeUtilAqrWnrInsert
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilAqrWnrInsertTdb()
  {}

  virtual ~ExExeUtilAqrWnrInsertTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

///////////////////////////////////////////////////////////////
// ExExeUtilAqrWnrInsertTcb
///////////////////////////////////////////////////////////////
class ExExeUtilAqrWnrInsertTcb : public ExExeUtilTcb
{
public:
  // Constructor
  ExExeUtilAqrWnrInsertTcb(const ComTdbExeUtilAqrWnrInsert & exe_util_tdb,
							const ex_tcb * child_tcb,
							ex_globals * glob = 0);

  ~ExExeUtilAqrWnrInsertTcb();

  virtual Int32 fixup();

  virtual short work();

  virtual short workCancel();

protected:
  enum Step
  {
    INITIAL_,
    LOCK_TARGET_,
    IS_TARGET_EMPTY_,
    SEND_REQ_TO_CHILD_,
    GET_REPLY_FROM_CHILD_,
    CLEANUP_CHILD_,
    ERROR_,
    CLEANUP_TARGET_,
    DONE_
  };

private:
  ExExeUtilAqrWnrInsertTdb & ulTdb() const
  {return (ExExeUtilAqrWnrInsertTdb &) tdb;}

  void setStep(Step s, int lineNum);

  Step step_;
  bool targetWasEmpty_;

};

// -----------------------------------------------------------------------
// ExExeUtilLongRunningTdb
// -----------------------------------------------------------------------
class ExExeUtilLongRunningTdb : public ComTdbExeUtilLongRunning
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilLongRunningTdb()
  {}

  virtual ~ExExeUtilLongRunningTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

///////////////////////////////////////////////////////////////
// ExExeUtilLongRunningTcb
///////////////////////////////////////////////////////////////
class ExExeUtilLongRunningTcb : public ExExeUtilTcb
{
public:
  // Constructor
  ExExeUtilLongRunningTcb(const ComTdbExeUtilLongRunning & exe_util_tdb,

                       ex_globals * glob = 0);

  ~ExExeUtilLongRunningTcb();

  virtual Int32 fixup();

  virtual short work();

  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

  void registerSubtasks();

  ExExeUtilLongRunningTdb & lrTdb() const{return (ExExeUtilLongRunningTdb &) tdb;};

  short doLongRunning();

  short executeLongRunningQuery();

  short processInitial(Lng32 &rc);

  short processContinuing(Lng32 &rc);

  short finalizeDoLongRunning();

  void addTransactionCount() { transactions_++; };
  Int64 getTransactionCount() { return transactions_; };

  void addRowsDeleted(Int64 rows) { rowsDeleted_ += rows; };
  Int64 getRowsDeleted() { return rowsDeleted_; };

  void setInitial(short initial) { initial_ = initial; };
  short getInitial() { return initial_; };

  void setInitialOutputVarPtrList(Queue * outputVarPtrList)
  { initialOutputVarPtrList_ = outputVarPtrList; };
  Queue * getInitialOutputVarPtrList() { return initialOutputVarPtrList_; };

  void setContinuingOutputVarPtrList(Queue * outputVarPtrList)
  { continuingOutputVarPtrList_ = outputVarPtrList; };
  Queue * getContinuingOutputVarPtrList() { return continuingOutputVarPtrList_; };

  ComDiagsArea *getDiagAreaFromUpQueueTail();

private:
  enum Step
  {
    INITIAL_,
    BEGIN_WORK_,
    LONG_RUNNING_,
    ERROR_,
    DONE_
  };

  Step step_;
  Int64 transactions_;
  Int64 rowsDeleted_;
  short initial_;

  Queue * initialOutputVarPtrList_;
  Queue * continuingOutputVarPtrList_;
  char    * lruStmtAndPartInfo_;
  char    * lruStmtWithCKAndPartInfo_;
  ExTransaction * currTransaction_;
};

class ExExeUtilLongRunningPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilLongRunningTcb;

public:
  ExExeUtilLongRunningPrivateState();
  ~ExExeUtilLongRunningPrivateState();        // destructor

protected:
};


class ExExeUtilGetRTSStatisticsTcb : public ExExeUtilTcb
{
  friend class ExExeUtilGetStatisticsTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilGetRTSStatisticsTcb(const ComTdbExeUtilGetStatistics & exe_util_tdb,
                            ex_globals * glob = 0);

  ~ExExeUtilGetRTSStatisticsTcb();

  virtual short work();

  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

  ExExeUtilGetStatisticsTdb & getStatsTdb() const
  {
    return (ExExeUtilGetStatisticsTdb &) tdb;
  };

  void deleteSqlStatItems(SQLSTATS_ITEM *sqlStatsItem,
                              ULng32  noOfStatsItem);
  void initSqlStatsItems(SQLSTATS_ITEM *sqlStatsItem,
                                  ULng32  noOfStatsItem,
                                  NABoolean initTdbIdOnly);
  NABoolean singleLineFormat() { return singleLineFormat_; } 

private:
  enum Step
  {
    INITIAL_,
    GET_NEXT_STATS_DESC_ENTRY_,
    GET_MASTER_STATS_ENTRY_,
    FORMAT_AND_RETURN_MASTER_STATS_,
    GET_MEAS_STATS_ENTRY_,
    FORMAT_AND_RETURN_MEAS_STATS_,
    GET_ROOTOPER_STATS_ENTRY_,
    FORMAT_AND_RETURN_ROOTOPER_STATS_,
    GET_PERTABLE_STATS_ENTRY_,
    DISPLAY_PERTABLE_STATS_HEADING_,
    FORMAT_AND_RETURN_PERTABLE_STATS_,
    GET_PARTITION_ACCESS_STATS_ENTRY_,
    FORMAT_AND_RETURN_PARTITION_ACCESS_STATS_,
    GET_OPER_STATS_ENTRY_,
    FORMAT_AND_RETURN_OPER_STATS_,
    GET_DP2_OPER_STATS_ENTRY_,
    FORMAT_AND_RETURN_DP2_OPER_STATS_,
    HANDLE_ERROR_,
    DONE_,
    EXPAND_STATS_ARRAY_,
    GET_RMS_STATS_ENTRY_,
    FORMAT_AND_RETURN_RMS_STATS_,
    GET_BMO_STATS_ENTRY_,
    DISPLAY_BMO_STATS_HEADING_,
    FORMAT_AND_RETURN_BMO_STATS_,
    GET_UDR_BASE_STATS_ENTRY_,
    DISPLAY_UDR_BASE_STATS_HEADING_,
    FORMAT_AND_RETURN_UDR_BASE_STATS_,
    GET_REPLICATE_STATS_ENTRY_,
    FORMAT_AND_RETURN_REPLICATE_STATS_,
    GET_REPLICATOR_STATS_ENTRY_,
    FORMAT_AND_RETURN_REPLICATOR_STATS_,
    GET_PROCESS_STATS_ENTRY_,
    FORMAT_AND_RETURN_PROCESS_STATS_,
    GET_HBASE_STATS_ENTRY_,
    GET_SE_STATS_ENTRY_ = GET_HBASE_STATS_ENTRY_,
    DISPLAY_HBASE_STATS_HEADING_,
    FORMAT_AND_RETURN_HBASE_STATS_,
    GET_HIVE_STATS_ENTRY_,
    DISPLAY_HIVE_STATS_HEADING_,
    FORMAT_AND_RETURN_HIVE_STATS_
  };

  Step step_;
  char * statsBuf_;
  short statsCollectType_;
  SQLSTATS_DESC *sqlStatsDesc_;
  Lng32 maxStatsDescEntries_;
  Lng32 retStatsDescEntries_;
  Lng32 currStatsDescEntry_;
  Lng32 currStatsItemEntry_;

  SQLSTATS_ITEM *masterStatsItems_;
  SQLSTATS_ITEM *measStatsItems_;
  SQLSTATS_ITEM* operatorStatsItems_;
  SQLSTATS_ITEM *rootOperStatsItems_;
  SQLSTATS_ITEM* partitionAccessStatsItems_;
  SQLSTATS_ITEM *pertableStatsItems_;
  SQLSTATS_ITEM *rmsStatsItems_;
  SQLSTATS_ITEM *bmoStatsItems_;
  SQLSTATS_ITEM *udrbaseStatsItems_;
  SQLSTATS_ITEM *replicateStatsItems_;
  SQLSTATS_ITEM *replicatorStatsItems_;
  SQLSTATS_ITEM *processStatsItems_;
  SQLSTATS_ITEM *hbaseStatsItems_;
  SQLSTATS_ITEM *hiveStatsItems_;
  Lng32 maxMasterStatsItems_;
  Lng32 maxMeasStatsItems_;
  Lng32 maxOperatorStatsItems_;
  Lng32 maxRootOperStatsItems_;
  Lng32 maxPartitionAccessStatsItems_;
  Lng32 maxPertableStatsItems_;
  Lng32 maxRMSStatsItems_;
  Lng32 maxBMOStatsItems_;
  Lng32 maxUDRBaseStatsItems_;
  Lng32 maxReplicateStatsItems_;
  Lng32 maxReplicatorStatsItems_;
  Lng32 maxProcessStatsItems_;
  Lng32 maxHbaseStatsItems_;
  Lng32 maxHiveStatsItems_;

  NABoolean isHeadingDisplayed_;
  NABoolean isBMOHeadingDisplayed_;
  NABoolean isUDRBaseHeadingDisplayed_;
  NABoolean isHbaseHeadingDisplayed_;
  NABoolean isHiveHeadingDisplayed_;

  static const Int32 numOperStats = 14;
  void formatOperStatItems(SQLSTATS_ITEM operStatsItems[]);
  void formatOperStats(SQLSTATS_ITEM operStatsItems[]);
  //  void formatDouble(SQLSTATS_ITEM stat, char* targetString);
  void formatInt64(SQLSTATS_ITEM stat, char* targetString);
  // void formatWDouble(SQLSTATS_ITEM stat, char* targetString);
  void formatWInt64(SQLSTATS_ITEM stat, char* targetString);
  char *formatTimestamp(char *buf, Int64 inTime);
  char *formatElapsedTime(char *buf, Int64 inTime);
  NABoolean singleLineFormat_;
};

class ExExeUtilGetRTSStatisticsPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilGetRTSStatisticsTcb;

public:
  ExExeUtilGetRTSStatisticsPrivateState();
  ~ExExeUtilGetRTSStatisticsPrivateState();        // destructor
protected:
};
//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetMetadataInfoTdb
// -----------------------------------------------------------------------
class ExExeUtilGetMetadataInfoTdb : public ComTdbExeUtilGetMetadataInfo
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilGetMetadataInfoTdb()
  {}

  virtual ~ExExeUtilGetMetadataInfoTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetMetadataInfoTcb
// -----------------------------------------------------------------------
class ExExeUtilGetMetadataInfoTcb : public ExExeUtilTcb
{
  friend class ExExeUtilGetMetadataInfoTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilGetMetadataInfoTcb(const ComTdbExeUtilGetMetadataInfo & exe_util_tdb,
                              ex_globals * glob = 0);

  ~ExExeUtilGetMetadataInfoTcb();

  virtual short work();

  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

  ExExeUtilGetMetadataInfoTdb & getMItdb() const
  {
    return (ExExeUtilGetMetadataInfoTdb &) tdb;
  };

protected:
  enum
  {
    NUM_MAX_PARAMS_ = 25
  };

  enum Step
  {
    INITIAL_,
    DISABLE_CQS_,
    GET_SCHEMA_VERSION_,
    GET_OBJECT_UID_,
    SETUP_QUERY_,
    SETUP_HBASE_QUERY_,
    FETCH_ALL_ROWS_,
    FETCH_ALL_ROWS_FOR_OBJECTS_,
    FETCH_ALL_ROWS_IN_SCHEMA_,
    DISPLAY_HEADING_,
    PROCESS_NEXT_ROW_,
    EVAL_EXPR_,
    RETURN_ROW_,
    ENABLE_CQS_,
    GET_USING_VIEWS_,
    GET_USED_OBJECTS_,
    HANDLE_ERROR_,
    DONE_,
  };

  enum ViewsStep
  {
    VIEWS_INITIAL_,
    VIEWS_FETCH_PROLOGUE_,
    VIEWS_FETCH_ROW_,
    VIEWS_FETCH_EPILOGUE_,
    VIEWS_ERROR_,
    VIEWS_DONE_
  };

  enum AuthIdType
  {
    USERS_ROLES_ = 0,
    ROLES_,
    USERS_
  };

  Step step_;
  ViewsStep vStep_;

  char * metadataQuery_;

  char objectUid_[25];

  char * queryBuf_;
  char * outputBuf_;
  char * headingBuf_;

  char * patternStr_;

  Lng32 numOutputEntries_;

  char * param_[NUM_MAX_PARAMS_];

  NABoolean headingReturned_;

  short displayHeading();

  Lng32 getUsingView(Queue * infoList,

                    // TRUE: shorthand view, FALSE: Materialized View
                    NABoolean isShorthandView,

                    char* &viewName, Lng32 &len);

  Lng32 getUsedObjects(Queue * infoList,
                      NABoolean isShorthandView,
                      char* &viewName, Lng32 &len);
  void setReturnRowCount( Lng32 n) { returnRowCount_ = n; }

  Lng32 getReturnRowCount() {return returnRowCount_;}

  void incReturnRowCount() {returnRowCount_++; }

  Lng32 returnRowCount_;

private:

  NABoolean checkUserPrivs(ContextCli * currConnext, const ComTdbExeUtilGetMetadataInfo::QueryType queryType);
  Int32 getAuthID(
    const char *authName,
    const char *catName,
    const char *schName,
    const char *objName);

  Int32 colPrivsFrag(
    const char *authName,
    const char *catName,
    const NAString &privWhereClause,
    NAString &colPrivsStmt);

  NAString getGrantedPrivCmd(
    const NAString &roleList,
    const char * cat,
    const NAString &inColumn = NAString("object_uid"));

  char * getRoleList(
    const Int32 userID,
    const char *catName,
    const char *schName,
    const char *objName);


};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetMetadataInfoComplexTcb
// -----------------------------------------------------------------------
class ExExeUtilGetMetadataInfoComplexTcb : public ExExeUtilGetMetadataInfoTcb
{
  friend class ExExeUtilGetMetadataInfoTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilGetMetadataInfoComplexTcb(
       const ComTdbExeUtilGetMetadataInfo & exe_util_tdb,
       ex_globals * glob = 0);

  ~ExExeUtilGetMetadataInfoComplexTcb();

  virtual short work();

protected:
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetMetadataInfoVersionTcb
// -----------------------------------------------------------------------
class ExExeUtilGetMetadataInfoVersionTcb : public ExExeUtilGetMetadataInfoTcb
{
  friend class ExExeUtilGetMetadataInfoTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilGetMetadataInfoVersionTcb(
       const ComTdbExeUtilGetMetadataInfo & exe_util_tdb,
       ex_globals * glob = 0);

  virtual short work();

protected:
  UInt32 maxObjLen_;
  char formatStr_[100];
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetHbaseObjectsTcb
// -----------------------------------------------------------------------
class ExExeUtilGetHbaseObjectsTcb : public ExExeUtilGetMetadataInfoTcb
{
  friend class ExExeUtilGetMetadataInfoTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilGetHbaseObjectsTcb(
       const ComTdbExeUtilGetMetadataInfo & exe_util_tdb,
       ex_globals * glob = 0);

  ~ExExeUtilGetHbaseObjectsTcb();

  virtual short work();

 private:
  ExpHbaseInterface * ehi_;
  NAArray<HbaseStr> *hbaseTables_;
  Int32 currIndex_;

  NAString extTableName_;

  char * hbaseName_;
  char * hbaseNameBuf_;
  char * outBuf_;
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetHiveMetadataInfoTdb
// -----------------------------------------------------------------------
class ExExeUtilGetHiveMetadataInfoTdb : public ComTdbExeUtilGetHiveMetadataInfo
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilGetHiveMetadataInfoTdb()
  {}

  virtual ~ExExeUtilGetHiveMetadataInfoTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilGetHiveMetadataInfoTcb
// -----------------------------------------------------------------------
class ExExeUtilGetHiveMetadataInfoTcb : public ExExeUtilGetMetadataInfoTcb
{
  friend class ExExeUtilGetHiveMetadataInfoTdb;

public:
  // Constructor
  ExExeUtilGetHiveMetadataInfoTcb(
       const ComTdbExeUtilGetHiveMetadataInfo & exe_util_tdb,
       ex_globals * glob = 0);

  ~ExExeUtilGetHiveMetadataInfoTcb();

  virtual short work();

  ExExeUtilGetHiveMetadataInfoTdb & getMItdb() const
  {
    return (ExExeUtilGetHiveMetadataInfoTdb &) tdb;
  };

protected:
short fetchAllHiveRows(Queue * &infoList, 
		       Lng32 numOutputEntries,
		       short &rc);

  HiveMetaData* hiveMetaDB_;

  void * mdInfo_;
};

//////////////////////////////////////////////////////////////////////////
class ExExeUtilGetMetadataInfoPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilGetMetadataInfoTcb;

public:
  ExExeUtilGetMetadataInfoPrivateState();
  ~ExExeUtilGetMetadataInfoPrivateState();        // destructor
protected:
};


// See ExCancel.cpp


//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilShowSetTdb
// -----------------------------------------------------------------------
class ExExeUtilShowSetTdb : public ComTdbExeUtilShowSet
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilShowSetTdb()
    {}

  virtual ~ExExeUtilShowSetTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilShowSetTcb
// -----------------------------------------------------------------------
class ExExeUtilShowSetTcb : public ExExeUtilTcb
{
  friend class ExExeUtilShowSetTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilShowSetTcb(const ComTdbExeUtilShowSet & exe_util_tdb,
                      ex_globals * glob = 0);

  virtual short work();

  ExExeUtilShowSetTdb & ssTdb() const
  {
    return (ExExeUtilShowSetTdb &) tdb;
  };

protected:
  enum Step
  {
    EMPTY_,
    RETURN_HEADER_,
    RETURNING_DEFAULT_,
    DONE_,
    HANDLE_ERROR_,
    CANCELLED_
  };

  Step step_;
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilAQRTdb
// -----------------------------------------------------------------------
class ExExeUtilAQRTdb : public ComTdbExeUtilAQR
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilAQRTdb()
    {}

  virtual ~ExExeUtilAQRTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilAQRTcb
// -----------------------------------------------------------------------
class ExExeUtilAQRTcb : public ExExeUtilTcb
{
  friend class ExExeUtilAQRTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilAQRTcb(const ComTdbExeUtilAQR & exe_util_tdb,
                  ex_globals * glob = 0);

  virtual short work();

  ExExeUtilAQRTdb & aqrTdb() const
  {
    return (ExExeUtilAQRTdb &) tdb;
  };

protected:
  enum Step
  {
    EMPTY_,
    SET_ENTRY_,
    RETURN_HEADER_,
    RETURNING_ENTRY_,
    DONE_,
    HANDLE_ERROR_,
    CANCELLED_
  };

  Step step_;
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilLobExtractTdb
// -----------------------------------------------------------------------
class ExExeUtilLobExtractTdb : public ComTdbExeUtilLobExtract
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilLobExtractTdb()
    {}

  virtual ~ExExeUtilLobExtractTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilLobExtractTcb
// -----------------------------------------------------------------------
class ExExeUtilLobExtractTcb : public ExExeUtilTcb
{
  friend class ExExeUtilLobExtractTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilLobExtractTcb(const ComTdbExeUtilLobExtract & exe_util_tdb,
			 const ex_tcb * child_tcb, 
			 ex_globals * glob = 0);
  
  virtual short work();
  virtual ~ExExeUtilLobExtractTcb();
  virtual void freeResources();
  virtual ExOperStats *doAllocateStatsEntry(CollHeap *heap,
                                            ComTdb *tdb);
  
  ExExeUtilLobExtractTdb & lobTdb() const
  {
    return (ExExeUtilLobExtractTdb &) tdb;
  };
  ExLobGlobals *&getLobGlobals() { return exLobGlobals_;}
 protected:
  enum Step
  {
    EMPTY_,
    GET_NO_CHILD_HANDLE_,
    GET_LOB_HANDLE_,
    RETRIEVE_LOB_LENGTH_,
    EXTRACT_HDFSFILENAME_,
    RETRIEVE_OFFSET_,
    EXTRACT_LOB_DATA_,
    RETURN_STATUS_,
    SEND_REQ_TO_CHILD_,
    GET_REPLY_FROM_CHILD_,
    ERROR_FROM_CHILD_,
    OPEN_CURSOR_,
    READ_CURSOR_,
    CLOSE_CURSOR_,
    RETURN_STRING_,
    INSERT_FROM_STRING_,
    INSERT_FROM_SOURCE_FILE_,
    READ_STRING_FROM_SOURCE_FILE_,
    CREATE_TARGET_FILE_,
    OPEN_TARGET_FILE_,
    CLOSE_TARGET_FILE_,
    COLLECT_STATS_,
    DONE_,
    CANCEL_,
    HANDLE_ERROR_,
    CANCELLED_
  };

  Step step_;
  Lng32 lobHandleLen_;
  char  lobHandle_[2050];
  char lobInputHandleBuf_[4096];
  char lobNameBuf_[1024];
  Lng32 lobNameLen_;
  char * lobName_;
  Lng32 lobType_;
  char * lobData_;
  char * lobData2_;
  Int64 lobDataSpecifiedExtractLen_;
  Int64 lobDataLen_;
  Int64 remainingBytes_;
  Lng32 currPos_;
  Lng32 numChildRows_;
  Int64 requestTag_;
  char lobLoc_[1024];
  ExLobStats lobStats_;
  char statusString_[200];
  fstream indata_;
  ExLobGlobals *exLobGlobals_;
};


//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilLobUpdateTdb
// -----------------------------------------------------------------------
class ExExeUtilLobUpdateTdb : public ComTdbExeUtilLobUpdate
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilLobUpdateTdb()
    {}

  virtual ~ExExeUtilLobUpdateTdb()
    {}


  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);
private:
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilLobUpdateTcb
// -----------------------------------------------------------------------


class ExExeUtilLobUpdateTcb : public ExExeUtilTcb
{
  friend class ExExeUtilLobUpdateTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilLobUpdateTcb(const ComTdbExeUtilLobUpdate & exe_util_tdb,
			 const ex_tcb * child_tcb, 
			 ex_globals * glob = 0);
  
  virtual short work();
  virtual ~ExExeUtilLobUpdateTcb();
  virtual void freeResources();
  virtual ExOperStats *doAllocateStatsEntry(CollHeap *heap,
                                            ComTdb *tdb);
  ExExeUtilLobUpdateTdb & lobTdb() const
  {
    return (ExExeUtilLobUpdateTdb &) tdb;
  };
  ExLobGlobals *&getLobGlobals() { return exLobGlobals_;}
 protected:
  enum Step
    {
      EMPTY_,
      GET_HANDLE_,
      UPDATE_LOB_DATA_,
      EMPTY_LOB_DATA_,
      APPEND_LOB_DATA_,
      RETURN_STATUS_,
      DONE_,
      CANCEL_,
      HANDLE_ERROR_,
      CANCELLED_
    };
  Step step_;
  Lng32 lobHandleLen_;
  char  lobHandle_[2050];
  char lobInputHandleBuf_[4096];
  char lobNameBuf_[1024];
  Lng32 lobNameLen_;
  char * lobName_;
  Lng32 lobType_;
  char * lobData_;
  Int64 lobDataLen_;
  Int64 requestTag_;
  char lobLoc_[1024];
  ExLobStats lobStats_;
  char statusString_[200];
  fstream indata_;
  char lobLockId_[LOB_LOCK_ID_SIZE];
  ExLobGlobals *exLobGlobals_;
};
// -----------------------------------------------------------------------
// ExExeUtilFileUpdateTcb
// -----------------------------------------------------------------------
class ExExeUtilFileExtractTcb : public ExExeUtilLobExtractTcb
{
  friend class ExExeUtilLobExtractTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilFileExtractTcb(const ComTdbExeUtilLobExtract & exe_util_tdb,
			  const ex_tcb * child_tcb, 
			  ex_globals * glob = 0);
  
  virtual NABoolean needStatsEntry();

  virtual ExOperStats *doAllocateStatsEntry(CollHeap *heap,
                                            ComTdb *tdb);

  virtual short work();

 private:
  NABoolean  eodReturned_;
};

// -----------------------------------------------------------------------
// ExExeUtilFileLoadTcb
// -----------------------------------------------------------------------
class ExExeUtilFileLoadTcb : public ExExeUtilLobExtractTcb
{
  friend class ExExeUtilLobExtractTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilFileLoadTcb(const ComTdbExeUtilLobExtract & exe_util_tdb,
		       const ex_tcb * child_tcb, 
		       ex_globals * glob = 0);
  
  virtual ExOperStats *doAllocateStatsEntry(CollHeap *heap,
                                            ComTdb *tdb);
  virtual short work();

 private:
  Int64 srcFileRemainingBytes_;
};


//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilLobShowddlTdb
// -----------------------------------------------------------------------
class ExExeUtilLobShowddlTdb : public ComTdbExeUtilLobShowddl
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilLobShowddlTdb()
    {}

  virtual ~ExExeUtilLobShowddlTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilLobShowddlTcb
// -----------------------------------------------------------------------
class ExExeUtilLobShowddlTcb : public ExExeUtilTcb
{
  friend class ExExeUtilLobShowddlTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilLobShowddlTcb(const ComTdbExeUtilLobShowddl & exe_util_tdb,
			 ex_globals * glob = 0);

  virtual short work();

  ExExeUtilLobShowddlTdb & lobTdb() const
  {
    return (ExExeUtilLobShowddlTdb &) tdb;
  };
  
 private:
  short fetchRows(char * query, short &rc);
  short returnRows(short &rc);
 
  enum Step
  {
    INITIAL_,
    FETCH_TABLE_SHOWDDL_,
    RETURN_TABLE_SHOWDDL_,
    FETCH_METADATA_SHOWDDL_,
    RETURN_METADATA_SHOWDDL_,
    RETURN_LOB_NAME_,
    FETCH_LOB_DESC_HANDLE_SHOWDDL_,
    RETURN_LOB_DESC_HANDLE_SHOWDDL_,
    FETCH_LOB_DESC_CHUNKS_SHOWDDL_,
    RETURN_LOB_DESC_CHUNKS_SHOWDDL_,
    DONE_,
    HANDLE_ERROR_,
    CANCELLED_
  };

  Step step_;

  char lobMDNameBuf_[1024];
  Lng32 lobMDNameLen_;
  char * lobMDName_;
  
  Lng32 currLobNum_;
  
  char sdOptionStr_[100];
};

class ExExeUtilGetProcessStatisticsTcb : public ExExeUtilGetStatisticsTcb
{
  friend class ExExeUtilGetProcessStatisticsTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilGetProcessStatisticsTcb
      (const ComTdbExeUtilGetProcessStatistics & exe_util_tdb,
         ex_globals * glob = 0);
 
  //  ~ExExeUtilGetProcessStatisticsTcb();

  virtual short work();

  ExExeUtilGetProcessStatisticsTdb & getStatsTdb() const
  { 
    return (ExExeUtilGetProcessStatisticsTdb &) tdb;
  };

private:
  enum ProcessStatsStep
  {
     INITIAL_,
     GET_PROCESS_STATS_AREA_,
     GET_PROCESS_STATS_ENTRY_,
     FORMAT_AND_RETURN_PROCESS_STATS_, 
     HANDLE_ERROR_,
     DONE_
  };
   
  ProcessStatsStep step_;
  const ExStatisticsArea *statsArea_;
  ExProcessStats *processStats_;
};
  

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilHiveMDaccessTdb
// -----------------------------------------------------------------------
class ExExeUtilHiveMDaccessTdb : public ComTdbExeUtilHiveMDaccess
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilHiveMDaccessTdb()
  {}

  virtual ~ExExeUtilHiveMDaccessTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilHiveMDaccessTcb
// -----------------------------------------------------------------------
class ExExeUtilHiveMDaccessTcb : public ExExeUtilTcb
{
  friend class ExExeUtilHiveMDaccessTdb;

public:
  // Constructor
  ExExeUtilHiveMDaccessTcb(
       const ComTdbExeUtilHiveMDaccess & exe_util_tdb,
       ex_globals * glob = 0);

  ~ExExeUtilHiveMDaccessTcb();

  virtual short work();

  ExExeUtilHiveMDaccessTdb & hiveMDtdb() const
  {
    return (ExExeUtilHiveMDaccessTdb &) tdb;
  };

virtual ex_tcb_private_state *
  allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

protected:
  Lng32 getTypeAttrsFromHiveColType(const char* hiveType,
                                    NABoolean isORC,
                                    Lng32 &fstype,
                                    Lng32 &length,
                                    Lng32 &precision,
                                    Lng32 &scale,
                                    char *sqlType,
                                    char *displayType,
                                    char *charset);
  enum Step
  {
    INITIAL_,
    SETUP_SCHEMAS_,
    GET_ALL_SCHEMAS_,
    GET_ALL_TABLES_,
    GET_ALL_TABLES_IN_SCHEMA_,
    POSITION_,
    FETCH_SCHEMA_,
    FETCH_TABLE_,
    FETCH_COLUMN_,
    FETCH_PKEY_,
    APPLY_PRED_,
    RETURN_ROW_,
    ADVANCE_ROW_,
    ADVANCE_SCHEMA_,
    DONE_,
    HANDLE_ERROR_,
    CANCELLED_
  };

  Step step_;

  HiveMetaData* hiveMD_;

  hive_column_desc * currColDesc_;
  hive_pkey_desc * currPartnDesc_;
  hive_bkey_desc * currKeyDesc_;
  Int32 currSchNum_;
  Int32 currColNum_;

  char * mdRow_;
  LIST (NAText *) schNames_;
  LIST (NAText *) tblNames_;

  char hiveCat_[1024];
  char hiveSch_[1024];
  char schForHive_[1024];
};

//////////////////////////////////////////////////////////////////////////
class ExExeUtilHiveMDaccessPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilGetMetadataInfoTcb;

public:
  ExExeUtilHiveMDaccessPrivateState();
  ~ExExeUtilHiveMDaccessPrivateState();        // destructor
protected:
};

// -----------------------------------------------------------------------
// ExExeUtilHiveTruncateTdb
// -----------------------------------------------------------------------
class ExExeUtilHiveTruncateTdb : public ComTdbExeUtilHiveTruncate
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilHiveTruncateTdb()
    {}

  virtual ~ExExeUtilHiveTruncateTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

///////////////////////////////////////////////////////////////
// ExExeUtilHiveTruncateLegacyTcb
///////////////////////////////////////////////////////////////
class ExExeUtilHiveTruncateLegacyTcb : public ExExeUtilTcb
{
 public:
  // Constructor
  ExExeUtilHiveTruncateLegacyTcb(const ComTdbExeUtilHiveTruncate & exe_util_tdb,
                           ex_globals * glob = 0);

  ~ExExeUtilHiveTruncateLegacyTcb();

  virtual void freeResources();
  virtual short work();

  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element
  virtual Int32 fixup();
 private:
  enum Step
    {
      INITIAL_,
      ERROR_,
      DATA_MOD_CHECK_,
      EMPTY_DIRECTORY_,
      DONE_
    };

  ExExeUtilHiveTruncateTdb & htTdb() const
    {return (ExExeUtilHiveTruncateTdb &) tdb;};

  short injectError(const char * val);

  Step step_;

  int   numExistingFiles_;
  ExLobGlobals * lobGlob_;
};

class ExExeUtilHiveTruncateLegacyPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilHiveTruncateLegacyTcb;

 public:
  ExExeUtilHiveTruncateLegacyPrivateState();
  ~ExExeUtilHiveTruncateLegacyPrivateState();        // destructor
 protected:
};

///////////////////////////////////////////////////////////////
// ExExeUtilHiveTruncateTcb
///////////////////////////////////////////////////////////////
class ExExeUtilHiveTruncateTcb : public ExExeUtilTcb
{
 public:
  // Constructor
  ExExeUtilHiveTruncateTcb(const ComTdbExeUtilHiveTruncate & exe_util_tdb,
                                ex_globals * glob = 0);

  ~ExExeUtilHiveTruncateTcb();

  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element
  virtual void freeResources();
  virtual short work();

 private:
  enum Step
    {
      INITIAL_,
      ALTER_TO_MANAGED_,
      TRUNCATE_TABLE_,
      ALTER_TO_EXTERNAL_,
      ALTER_TO_EXTERNAL_AND_ERROR_,
      ERROR_,
      DONE_
    };

  ExExeUtilHiveTruncateTdb & htTdb() const
    {return (ExExeUtilHiveTruncateTdb &) tdb;};

  Step step_;
};

class ExExeUtilHiveTruncatePrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilHiveTruncateTcb;

 public:
  ExExeUtilHiveTruncatePrivateState();
  ~ExExeUtilHiveTruncatePrivateState();        // destructor
 protected:
};

//////////////////////////////////////////////////////////////
// ExExeUtilHiveQueryTdb
//////////////////////////////////////////////////////////////
class ExExeUtilHiveQueryTdb : public ComTdbExeUtilHiveQuery
{
 public:
  ExExeUtilHiveQueryTdb()
    {}
  virtual ~ExExeUtilHiveQueryTdb()
    {}
  virtual ex_tcb *build(ex_globals *globals);
 private:
};
class ExExeUtilHiveQueryTcb : public ExExeUtilTcb
{
 public:
  ExExeUtilHiveQueryTcb(const ComTdbExeUtilHiveQuery & exe_util_tdb,
                        ex_globals * glob = 0);
  ~ExExeUtilHiveQueryTcb();
  virtual short work();
  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element
 private:
  enum Step
    {
      INITIAL_,
      ERROR_,
      PROCESS_QUERY_,
      DONE_
    };
  ExExeUtilHiveQueryTdb & htTdb() const
    {return (ExExeUtilHiveQueryTdb &) tdb;};
  Step step_;
};
class ExExeUtilHiveQueryPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilHiveQueryTcb;
 public:
  ExExeUtilHiveQueryPrivateState();
  ~ExExeUtilHiveQueryPrivateState();        // destructor
 protected:
};
//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilHbaseLoadTdb
// -----------------------------------------------------------------------
class ExExeUtilHBaseBulkLoadTdb : public ComTdbExeUtilHBaseBulkLoad
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilHBaseBulkLoadTdb()
    {}

  virtual ~ExExeUtilHBaseBulkLoadTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};


class ExExeUtilHBaseBulkLoadTcb : public ExExeUtilTcb
{
  friend class ExExeUtilHBaseBulkLoadTdb;
  friend class ExExeUtilPrivateState;

 public:
  // Constructor
  ExExeUtilHBaseBulkLoadTcb(const ComTdbExeUtil & exe_util_tdb,
                            ex_globals * glob = 0);
  ~ExExeUtilHBaseBulkLoadTcb();
  virtual short work();

  ExExeUtilHBaseBulkLoadTdb & hblTdb() const
  {
    return (ExExeUtilHBaseBulkLoadTdb &) tdb;
  };

  virtual short moveRowToUpQueue(const char * row, Lng32 len = -1,
                                 short * rc = NULL, NABoolean isVarchar = TRUE);

  short printLoggingLocation(int bufPos);
 
  void setEndStatusMsg(const char * operation,
                                       int bufPos = 0,
                                       NABoolean   withtime= FALSE);

  short setStartStatusMsgAndMoveToUpQueue(const char * operation,
                                       short * rc,
                                       int bufPos = 0,
                                       NABoolean   withtime = FALSE);
  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element
  void setLoggingLocation();
 private:
  enum Step
    {
    //initial state
      INITIAL_,
      //cleanup leftover files
      PRE_LOAD_CLEANUP_,
      LOAD_START_,
      LOAD_END_,
      LOAD_END_ERROR_,
      PREPARATION_,
      LOADING_DATA_,
      COMPLETE_BULK_LOAD_, //load incremental
      POST_LOAD_CLEANUP_,
      TRUNCATE_TABLE_,
      DISABLE_INDEXES_,
      POPULATE_INDEXES_,
      POPULATE_INDEXES_EXECUTE_,
      UPDATE_STATS_,
      UPDATE_STATS_EXECUTE_,
      RETURN_STATUS_MSG_,
      DONE_,
      HANDLE_ERROR_, DELETE_DATA_AND_ERROR_,
      LOAD_ERROR_
    };


  Step step_;
  Step nextStep_;

  Int64 startTime_;
  Int64 endTime_;
  Int64 rowsAffected_;
  char statusMsgBuf_[BUFFER_SIZE];
  ExpHbaseInterface * ehi_;
  char *loggingLocation_;
  short setCQDs();
  short restoreCQDs();
};

class ExExeUtilHbaseLoadPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilHBaseBulkLoadTcb;

 public:
  ExExeUtilHbaseLoadPrivateState();
  ~ExExeUtilHbaseLoadPrivateState();        // destructor
 protected:
};


//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilHbaseUnLoadTdb
// -----------------------------------------------------------------------
class ExExeUtilHBaseBulkUnLoadTdb : public ComTdbExeUtilHBaseBulkUnLoad
{
 public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilHBaseBulkUnLoadTdb()
    {}

  virtual ~ExExeUtilHBaseBulkUnLoadTdb()
    {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

 private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  //
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};


class ExExeUtilHBaseBulkUnLoadTcb : public ExExeUtilTcb
{
  friend class ExExeUtilHBaseBulkUnLoadTdb;
  friend class ExExeUtilPrivateState;

 public:
  // Constructor
  ExExeUtilHBaseBulkUnLoadTcb(const ComTdbExeUtil & exe_util_tdb,
                            ex_globals * glob = 0);
  ~ExExeUtilHBaseBulkUnLoadTcb();

  void freeResources();

  virtual short work();

  ExExeUtilHBaseBulkUnLoadTdb & hblTdb() const
  {
    return (ExExeUtilHBaseBulkUnLoadTdb &) tdb;
  };

  virtual short moveRowToUpQueue(const char * row, Lng32 len = -1,
                                 short * rc = NULL, NABoolean isVarchar = TRUE);

  void setEndStatusMsg(const char * operation,
                                       int bufPos = 0,
                                       NABoolean   withtime= FALSE);

  short setStartStatusMsgAndMoveToUpQueue(const char * operation,
                                       short * rc,
                                       int bufPos = 0,
                                       NABoolean   withtime = FALSE);
  virtual ex_tcb_private_state * allocatePstates(
       Lng32 &numElems,      // inout, desired/actual elements
       Lng32 &pstateLength); // out, length of one element

  short getTrafodionScanTables();

  short resetExplainSettings();

  char * setSnapshotScanId(char * str2)
  {
    assert (str2 != NULL);
    char  str[30];
    time_t t;
    time(&t);
    struct tm * curgmtime = gmtime(&t);
    strftime(str, 30, "%Y%m%d%H%M%S", curgmtime);
    srand(getpid());
    sprintf (str2,"%s_%d", str, rand()% 1000);
    return str2;
  }
 private:
  struct snapshotStruct
  {
    NAString * fullTableName;
    NAString * snapshotName;
  };
  void createHdfsFileError(Int32 sfwRetCode);
  enum Step
    {
    //initial state
      INITIAL_,
      EMPTY_TARGET_,
      //cleanup leftover files
      UNLOAD_START_,
      UNLOAD_END_,
      UNLOAD_END_ERROR_,
      UNLOAD_,
      MERGE_FILES_,
      RETURN_STATUS_MSG_,
      DONE_,
      HANDLE_ERROR_,
      UNLOAD_ERROR_,
      CREATE_SNAPSHOTS_,
      VERIFY_SNAPSHOTS_,
      DELETE_SNAPSHOTS_
    };

  void setEmptyTarget( NABoolean v)
  {
    emptyTarget_ = v;
  }
  NABoolean getEmptyTarget() const
  {
    return emptyTarget_;
  }
  void setOneFile( NABoolean v)
  {
    oneFile_ = v;
  }
  NABoolean getOneFile() const
  {
    return oneFile_;
  }
  Step step_;
  Step nextStep_;

  Int64 startTime_;
  Int64 endTime_;
  Int64 rowsAffected_;
  char statusMsgBuf_[BUFFER_SIZE];
  NAList<struct snapshotStruct *> * snapshotsList_;
  NABoolean emptyTarget_;
  NABoolean oneFile_;
  ExpHbaseInterface * ehi_;
};

class ExExeUtilHbaseUnLoadPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilHBaseBulkLoadTcb;

 public:
  ExExeUtilHbaseUnLoadPrivateState();
  ~ExExeUtilHbaseUnLoadPrivateState();        // destructor
 protected:
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilRegionStatsTdb
// -----------------------------------------------------------------------
class ExExeUtilRegionStatsTdb : public ComTdbExeUtilRegionStats
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilRegionStatsTdb()
  {}

  virtual ~ExExeUtilRegionStatsTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  // 
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilRegionStatsTcb
// -----------------------------------------------------------------------
class ExExeUtilRegionStatsTcb : public ExExeUtilTcb
{
  friend class ExExeUtilRegionStatsTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilRegionStatsTcb(const ComTdbExeUtilRegionStats & exe_util_tdb,
				ex_globals * glob = 0);

  ~ExExeUtilRegionStatsTcb();

  virtual short work();

  ExExeUtilRegionStatsTdb & getDLStdb() const
  {
    return (ExExeUtilRegionStatsTdb &) tdb;
  };

private:
  enum Step
  {
    INITIAL_,
    EVAL_INPUT_,
    COLLECT_STATS_,
    POPULATE_STATS_BUF_,
    EVAL_EXPR_,
    RETURN_STATS_BUF_,
    HANDLE_ERROR_,
    DONE_
  };
  Step step_;

protected:
  Int64 getEmbeddedNumValue(char* &sep, char endChar, 
                            NABoolean adjustLen = TRUE);

  short collectStats(char * tableName);
  short populateStats(Int32 currIndex);

  char * hbaseRootdir_;

  char * tableName_;

  char * inputNameBuf_;

  char * statsBuf_;
  Lng32 statsBufLen_;
  ComTdbRegionStatsVirtTableColumnStruct* stats_;  

  ExpHbaseInterface * ehi_;
  NAArray<HbaseStr> *regionInfoList_;

  Int32 currIndex_;

  Int32 numRegionStatsEntries_;

  char * catName_;
  char * schName_;
  char * objName_;
  char * regionName_;

  NAString extNameForHbase_;
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilRegionStatsFormatTcb
// -----------------------------------------------------------------------
class ExExeUtilRegionStatsFormatTcb : public ExExeUtilRegionStatsTcb
{
  friend class ExExeUtilRegionStatsTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilRegionStatsFormatTcb(const ComTdbExeUtilRegionStats & exe_util_tdb,
                                      ex_globals * glob = 0);

  virtual short work();

private:
  enum Step
  {
    INITIAL_,
    COLLECT_STATS_,
    EVAL_INPUT_,
    COMPUTE_TOTALS_,
    RETURN_SUMMARY_,
    RETURN_DETAILS_,
    POPULATE_STATS_BUF_,
    RETURN_REGION_INFO_,
    HANDLE_ERROR_,
    DONE_
  };

  Step step_;

  char * statsTotalsBuf_;
  ComTdbRegionStatsVirtTableColumnStruct* statsTotals_;  

  short initTotals();
  short computeTotals();
};

////////////////////////////////////////////////////////////////////////////
class ExExeUtilRegionStatsPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilRegionStatsTcb;
  
public:	
  ExExeUtilRegionStatsPrivateState();
  ~ExExeUtilRegionStatsPrivateState();	// destructor
protected:
};


//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilClusterStatsTcb
// -----------------------------------------------------------------------
class ExExeUtilClusterStatsTcb : public ExExeUtilRegionStatsTcb
{
  friend class ExExeUtilClusterStatsTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilClusterStatsTcb(const ComTdbExeUtilRegionStats & exe_util_tdb,
                           ex_globals * glob = 0);

  ~ExExeUtilClusterStatsTcb();

  virtual short work();

private:
  enum Step
  {
    INITIAL_,
    EVAL_INPUT_,
    COLLECT_STATS_,
    POPULATE_STATS_BUF_,
    EVAL_EXPR_,
    RETURN_STATS_BUF_,
    HANDLE_ERROR_,
    DONE_
  };
  Step step_;

  short collectStats();
  short populateStats(Int32 currIndex, NABoolean nullTerminate = FALSE);

protected:
  ComTdbClusterStatsVirtTableColumnStruct* stats_;  

};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilLobInfoTdb
// -----------------------------------------------------------------------
class ExExeUtilLobInfoTdb : public ComTdbExeUtilLobInfo
{
public:

  // ---------------------------------------------------------------------
  // Constructor is only called to instantiate an object used for
  // retrieval of the virtual table function pointer of the class while
  // unpacking. An empty constructor is enough.
  // ---------------------------------------------------------------------
  ExExeUtilLobInfoTdb()
  {}

  virtual ~ExExeUtilLobInfoTdb()
  {}

  // ---------------------------------------------------------------------
  // Build a TCB for this TDB. Redefined in the Executor project.
  // ---------------------------------------------------------------------
  virtual ex_tcb *build(ex_globals *globals);

private:
  // ---------------------------------------------------------------------
  // !!!!!!! IMPORTANT -- NO DATA MEMBERS ALLOWED IN EXECUTOR TDB !!!!!!!!
  // *********************************************************************
  // The Executor TDB's are only used for the sole purpose of providing a
  // way to supplement the Compiler TDB's (in comexe) with methods whose
  // implementation depends on Executor objects. This is done so as to
  // decouple the Compiler from linking in Executor objects unnecessarily.
  //
  // When a Compiler generated TDB arrives at the Executor, the same data
  // image is "cast" as an Executor TDB after unpacking. Therefore, it is
  // a requirement that a Compiler TDB has the same object layout as its
  // corresponding Executor TDB. As a result of this, all Executor TDB's
  // must have absolutely NO data members, but only member functions. So,
  // if you reach here with an intention to add data members to a TDB, ask
  // yourself two questions:
  //
  // 1. Are those data members Compiler-generated?
  //    If yes, put them in the ComTdbDLL instead.
  //    If no, they should probably belong to someplace else (like TCB).
  // 
  // 2. Are the classes those data members belong defined in the executor
  //    project?
  //    If your answer to both questions is yes, you might need to move
  //    the classes to the comexe project.
  // ---------------------------------------------------------------------
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilLobInfoTcb
// -----------------------------------------------------------------------
class ExExeUtilLobInfoTcb : public ExExeUtilTcb
{
  friend class ExExeUtilLobInfoTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilLobInfoTcb(const ComTdbExeUtilLobInfo & exe_util_tdb,
				ex_globals * glob = 0);

  ~ExExeUtilLobInfoTcb();

  virtual short work();


private:
  enum Step
  {
    INITIAL_,
    EVAL_INPUT_,
    COLLECT_LOBINFO_,
    POPULATE_LOBINFO_BUF_,
    RETURN_LOBINFO_BUF_,
    HANDLE_ERROR_,
    DONE_
  };
  Step step_;

protected:
 
  short collectAndReturnLobInfo(char * tableName, Int32 currLobNum, ContextCli *context);

  ExExeUtilLobInfoTdb & getLItdb() const
  {
    return (ExExeUtilLobInfoTdb &) tdb;
  };
  
  char * tableName_;
  char * inputNameBuf_;
  Int32 currLobNum_;
 
};

//////////////////////////////////////////////////////////////////////////
// -----------------------------------------------------------------------
// ExExeUtilLobInfoTableTcb
// -----------------------------------------------------------------------
class ExExeUtilLobInfoTableTcb : public ExExeUtilTcb
{
  friend class ExExeUtilLobInfoTdb;
  friend class ExExeUtilPrivateState;

public:
  // Constructor
  ExExeUtilLobInfoTableTcb(const ComTdbExeUtilLobInfo & exe_util_tdb,
				ex_globals * glob = 0);

  ~ExExeUtilLobInfoTableTcb();

  virtual short work();


private:
  enum Step
  {
    INITIAL_,
    EVAL_INPUT_,
    COLLECT_LOBINFO_,
    POPULATE_LOBINFO_BUF_,
    RETURN_LOBINFO_BUF_,
    HANDLE_ERROR_,
    DONE_
  };
  Step step_;

protected:
  Int64 getEmbeddedNumValue(char* &sep, char endChar, 
                            NABoolean adjustLen = TRUE);
  short collectLobInfo(char * tableName, Int32 currLobNum, ContextCli *context);
  short populateLobInfo(Int32 currLobNum, NABoolean nullTerminate = FALSE);

  ExExeUtilLobInfoTdb & getLItdb() const
  {
    return (ExExeUtilLobInfoTdb &) tdb;
  };
 
  char * tableName_;
  char * inputNameBuf_;
  
  char * lobInfoBuf_;
  Lng32 lobInfoBufLen_;
  ComTdbLobInfoVirtTableColumnStruct* lobInfo_;  
  Int32 currLobNum_;
 
};


////////////////////////////////////////////////////////////////////////////
class ExExeUtilLobInfoPrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilLobInfoTcb;
  
public:	
  ExExeUtilLobInfoPrivateState();
  ~ExExeUtilLobInfoPrivateState();	// destructor
protected:
};

////////////////////////////////////////////////////////////////////////////
class ExExeUtilLobInfoTablePrivateState : public ex_tcb_private_state
{
  friend class ExExeUtilLobInfoTableTcb;
  
public:	
  ExExeUtilLobInfoTablePrivateState();
  ~ExExeUtilLobInfoTablePrivateState();	// destructor
protected:
};

short ExExeUtilLobExtractLibrary(ExeCliInterface *cliInterface,char *libHandle, char *cachedLibName,ComDiagsArea *toDiags);
#endif