/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/

/* -*-C++-*-
 *****************************************************************************
 *
 * File:         ExExeUtilGetStats.cpp
 * Description:  
 *               
 *               
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */

#include "ComCextdecs.h"
#include  "cli_stdh.h"
#include  "ex_stdh.h"
#include  "sql_id.h"
#include  "ex_transaction.h"
#include  "ComTdb.h"
#include  "ex_tcb.h"
#include  "ComSqlId.h"
#include  "ExExeUtil.h"
#include  "ex_exe_stmt_globals.h"
#include  "exp_expr.h"
#include  "exp_clause_derived.h"
#include  "ComRtUtils.h"
#include  "ExStats.h"
#include  "ComSizeDefs.h"

///////////////////////////////////////////////////////////////////
ex_tcb * ExExeUtilGetStatisticsTdb::build(ex_globals * glob)
{
  ex_tcb * exe_util_tcb = NULL;

  switch (getStatsReqType())
  {
  case SQLCLI_STATS_REQ_STMT:
    if (getStmtName() == NULL)
       exe_util_tcb = new(glob->getSpace()) ExExeUtilGetStatisticsTcb(*this, glob);
    else
    {
       if (compilerStats() || executorStats() || otherStats() || detailedStats() ||
               oldFormat() || shortFormat() || tokenizedFormat())
          exe_util_tcb = new(glob->getSpace()) ExExeUtilGetStatisticsTcb(*this, glob);
       else
          exe_util_tcb = new(glob->getSpace()) ExExeUtilGetRTSStatisticsTcb(*this, glob);
    }
    break;
  case SQLCLI_STATS_REQ_QID:
  case SQLCLI_STATS_REQ_QID_INTERNAL:
  case SQLCLI_STATS_REQ_CPU:
  case SQLCLI_STATS_REQ_PID:
  case SQLCLI_STATS_REQ_QID_CURRENT:
  case SQLCLI_STATS_REQ_RMS_INFO:
    exe_util_tcb = new(glob->getSpace()) ExExeUtilGetRTSStatisticsTcb(*this, glob);
    break;
  default:
    ex_assert(0, "Stats Request type not yet supported");
    break;
  }
  exe_util_tcb->registerSubtasks();

  return (exe_util_tcb);
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilGetStatisticsTcb
///////////////////////////////////////////////////////////////
ExExeUtilGetStatisticsTcb::ExExeUtilGetStatisticsTcb(
     const ComTdbExeUtilGetStatistics & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilTcb( exe_util_tdb, NULL, glob)
{
  // Allocate the private state in each entry of the down queue
  qparent_.down->allocatePstate(this);

  step_ = INITIAL_;

  // allocate space to hold the stats query that will be used to retrieve
  // statistics. 6K is big enough for it.
  statsQuery_ = new(glob->getDefaultHeap()) char[6144];

  // buffer where output will be formatted
  statsBuf_ = new(glob->getDefaultHeap()) char[4096];

  statsRow_ = NULL;
  statsMergeType_ = SQLCLI_SAME_STATS;
}

ExExeUtilGetStatisticsTcb::~ExExeUtilGetStatisticsTcb()
{
  NADELETEBASIC(statsQuery_, getGlobals()->getDefaultHeap());
  NADELETEBASIC(statsBuf_, getGlobals()->getDefaultHeap());
}

// This method searches for the token string in str.
// It returns start position and length of the next string delimited by
// spaces following the token string except spaces inside quotes.
static short getSubstrInfo(char * str,   // IN
			   short maxLen, // IN
			   const char * token, // IN
			   char * sstrbuf) // OUT
{
  Lng32 startPos, currPos, length;
  const char space = ' ';
  const char quote = '\"';
  char * ptr = str_str(str, token);
  if (! ptr)
    {
      sstrbuf[0] = '\0';
      return -1;
    }
  
  startPos = ptr - str;
  startPos += strlen(token) + 1;
  if (startPos >= maxLen)
    {
      sstrbuf[0] = '\0';
      return -1;
    }  
  
  currPos = startPos;

  // terminate at space
  while(currPos < maxLen && str[currPos] != space)
  {
    // check for quote
    if(str[currPos] == quote)
    {
      currPos++;
      // find end quote
      while(currPos < maxLen && str[currPos] != quote)
          currPos++;
      if (currPos < maxLen)
        currPos++;
    }
    else
      currPos++;
  }

  length = currPos - startPos;

  strncpy(sstrbuf, &str[startPos], length);
  sstrbuf[length] = 0;

  return 0;
}

static const QueryString getStatsAllDefaultViewQuery[] =
{
  {" select a from ( "},
{"    select  "},
{"        trim( "},
{"        case when tdb_id is null then '.  ' "},
{"             else cast(cast(tdb_id as numeric(3)) as char(3)) "},
{"        end || ' ' || "},
{"        case when lc_tdb_id is null then '.  ' "},
{"             else cast(cast(lc_tdb_id as numeric(3)) as char(3)) "},
{"        end || ' ' || "},
{"        case when rc_tdb_id is null then '.  ' "},
{"             else cast(cast(rc_tdb_id as numeric(3)) as char(3)) "},
{"        end || ' ' || "},
{"        case when seq_num is null then '.  ' "},
{"             else cast(cast(seq_num as numeric(3)) as char(3)) "},
{"        end || ' ' || "},
{"        cast(tdb_name as char(18)) || ' ' || "},
{"  "},
{"        substring(cast(cast(sum(est_rows)/count(*) as real) as char(15)), 1, 4) || 'E' ||  "},
{"        substring(cast(cast(sum(est_rows)/count(*) as real) as char(15)), 13, 4) || ' ' || "},
{"  "},
{"        substring(cast(cast(sum(act_rows) as real) as char(15)), 1, 4) || 'E' ||  "},
{"        substring(cast(cast(sum(act_rows) as real) as char(15)), 13, 4) || ' ' || "},
{"        cast(sum(work_calls) as char(8)) || ' ' || "},
{"        ltrim(cast(cast(cast(sum(val1)/1000000 as interval second(12, 6)) "},
{"           as interval hour(2) to second(6)) as char(20))) || ' ' || "},
{"        cast (	 "},
{"          case  "},
{"            when (tdb_name = 'EX_ROOT' or tdb_name = 'EX_EID_ROOT' or  "},
{"                  tdb_name = 'EX_SPLIT_BOTTOM') "},
{"              then case when sum(val2) >= 0 then "},
{"                   ltrim(cast(cast(cast(sum(val2)/1000000 as interval second(12, 6))  "},
{"                        as interval hour(2) to second(6)) as char(20))) "},
{"                 else ' ' "},
{"                 end "},
{"            when tdb_name = 'EX_PARTN_ACCESS'  "},
{"              then trim(cast(min( "},
{"                  substring(substring(text, position('.' in text)+1), "},
{"                     1+ position('.' in substring(text, position('.' in text)+1))) "},
{"                  ) as char(20))) || '|' || "},
{"                trim(cast(sum(zeroifnull(val2)) as char(20))) || '|' || "},
{"                trim(cast(sum(zeroifnull(val3)) as char(20))) || '|' || "},
{"                trim(cast(sum(zeroifnull(val4)) as char(20))) "},
{"            when tdb_name = 'EX_SEND_TOP'  or tdb_name = 'EX_SEND_BOTTOM' "},
{"                 or tdb_name = 'EX_HASHJ' or tdb_name = 'EX_HASH_GRBY'  "},
{"                 or tdb_name = 'EX_SORT'  "},
{"                 or tdb_name = 'EX_SPLIT_TOP'     "},
{"                 or tdb_name = 'EX_FAST_EXTRACT'     "},
{"            then  "},
{"                trim(cast(sum(zeroifnull(val2)) as char(20))) || '|' || "},
{"                trim(cast(sum(zeroifnull(val3)) as char(20))) || '|' || "},
{"                trim(cast(sum(zeroifnull(val4)) as char(20))) "},
{"            else ' ' "},
{"          end "},
{"        as char(45))), "},
{"        tdb_id "},
{"    from table(statistics(null,'STMT=%s,MERGE=%d')) "},
{"  group by tdb_id, lc_tdb_id, rc_tdb_id, seq_num, tdb_name ) x(a,b) order by b desc "},
{" ; "},
};

//
// Used for internal testing to put CompilationStats data into row to be returned
//
void 
ExExeUtilGetStatisticsTcb::moveCompilationStatsToUpQueue(CompilationStatsData *cmpStats)
{
  if( NULL != cmpStats )
  {

    char startTime[26], endTime[26];
    short timestamp[8];

    INTERPRETTIMESTAMP(cmpStats->compileStartTime(), timestamp);
    sprintf(startTime, "%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",                        
		                    timestamp[0], // year
                        timestamp[1], // month
                        timestamp[2], // day
			                  timestamp[3], // hour
                        timestamp[4], // minute
                        timestamp[5], // second
			                  timestamp[6], // fraction
                        timestamp[7]);// fraction

    sprintf(statsBuf_,
				  "Compile Start Time\t: %s", 
				  startTime);
	  moveRowToUpQueue(statsBuf_);

    INTERPRETTIMESTAMP(cmpStats->compileEndTime(), timestamp);
    sprintf(endTime, "%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",                        
		                    timestamp[0], // year
                        timestamp[1], // month
                        timestamp[2], // day
			                  timestamp[3], // hour
                        timestamp[4], // minute
                        timestamp[5], // second
			                  timestamp[6], // fraction
                        timestamp[7]);// fraction

	  sprintf(statsBuf_,
				  "Compile End Time\t: %s", 
				  endTime);
	  moveRowToUpQueue(statsBuf_);

	  sprintf(statsBuf_,
				  "Compiler ID\t\t: %s", 
				  cmpStats->compilerId());
	  moveRowToUpQueue(statsBuf_);

	  sprintf(statsBuf_,
				  "CPU Total\t\t: %d", 
				  cmpStats->cmpCpuTotal());
	  moveRowToUpQueue(statsBuf_);

	  sprintf(statsBuf_,
				  "CPU Binder\t\t: %d", 
				  cmpStats->cmpCpuBinder());
	  moveRowToUpQueue(statsBuf_);

	  sprintf(statsBuf_,
				  "CPU Normalizer\t\t: %d", 
				  cmpStats->cmpCpuNormalizer());
	  moveRowToUpQueue(statsBuf_);

	  sprintf(statsBuf_,
				  "CPU Analyzer\t\t: %d", 
				  cmpStats->cmpCpuAnalyzer());
	  moveRowToUpQueue(statsBuf_);

	  sprintf(statsBuf_,
				  "CPU Optimizer\t\t: %d", 
				  cmpStats->cmpCpuOptimizer());
	  moveRowToUpQueue(statsBuf_);

	  sprintf(statsBuf_,
				  "CPU Generator\t\t: %d", 
				  cmpStats->cmpCpuGenerator());
	  moveRowToUpQueue(statsBuf_);

	  sprintf(statsBuf_,
				  "Metadata Cache Hits\t: %d", 
				  cmpStats->metadataCacheHits());
	  moveRowToUpQueue(statsBuf_);

    sprintf(statsBuf_,
				  "Metadata Cache Lookups\t: %d", 
				  cmpStats->metadataCacheLookups());
	  moveRowToUpQueue(statsBuf_);

    char queryCacheStateBuf[20];

    // See CompilationStats.h for QCacheState values
    switch(cmpStats->queryCacheState())
    {
    case 0:
      sprintf(queryCacheStateBuf,"TEXT");
    break;
    case 1:
      sprintf(queryCacheStateBuf,"TEMPLATE");
    break;
    case 2:
      sprintf(queryCacheStateBuf,"MISS NON-CACHEABLE");
    break;
    case 3:
      sprintf(queryCacheStateBuf,"MISS CACHEABLE");
    break;
    default:
      sprintf(queryCacheStateBuf,"UNKNOWN");
    break;
    };

    sprintf(statsBuf_,
				  "Query Cache State\t: %s", 
				  queryCacheStateBuf);
    moveRowToUpQueue(statsBuf_);

    sprintf(statsBuf_,
				  "Histogram Cache Hits\t: %d", 
				  cmpStats->histogramCacheHits());
	  moveRowToUpQueue(statsBuf_);

    sprintf(statsBuf_,
				  "Histogram Cache Lookups\t: %d", 
				  cmpStats->histogramCacheLookups());
	  moveRowToUpQueue(statsBuf_);

    sprintf(statsBuf_,
				  "Statement Heap Size\t: %d", 
				  cmpStats->stmtHeapSize());
	  moveRowToUpQueue(statsBuf_);

    sprintf(statsBuf_,
				  "Context Heap Size\t: %d", 
				  cmpStats->contextHeapSize());
	  moveRowToUpQueue(statsBuf_);

    sprintf(statsBuf_,
				  "Optimization Tasks\t: %d", 
				  cmpStats->optTasks());
	  moveRowToUpQueue(statsBuf_);

    sprintf(statsBuf_,
				  "Optimization Contexts\t: %d", 
				  cmpStats->optContexts());
	  moveRowToUpQueue(statsBuf_);

    if( cmpStats->isRecompile() )
    {
      sprintf(statsBuf_, "Is Recompile\t\t: YES");
    }
    else
    {
      sprintf(statsBuf_, "Is Recompile\t\t: NO");
    }
	  moveRowToUpQueue(statsBuf_);

    sprintf(statsBuf_,
				  "Compile Info\t\t: %s", 
				  cmpStats->compileInfo());
	  moveRowToUpQueue(statsBuf_);

    sprintf(statsBuf_,
				  "Compile Info Length\t: %d", 
				  cmpStats->compileInfoLen());
	  moveRowToUpQueue(statsBuf_);
  }
}

//////////////////////////////////////////////////////
// work() for ExExeUtilGetStatisticsTcb
//////////////////////////////////////////////////////
short ExExeUtilGetStatisticsTcb::work()
{
  //  short rc = 0;
  Lng32 cliRC = 0;
  char sstrbuf[ComMAX_ANSI_NAME_EXTERNAL_LEN+1];

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;
  
  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;
  
  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getStatement()->getContext();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
	    // find the stats area.
	    // If statement name is specified, look for it in the statement
	    // list.
	    // Otherwise, get the current stats area from context.

	    HashQueue * stmtList = currContext->getStatementList();
	    stmtList->position();
	    char * inputStmtName = getStatsTdb().stmtName_;
	    stats_ = NULL;
	    if (inputStmtName != NULL)
            {
		Statement * stmt = NULL;
		NABoolean found = FALSE;
		while ((NOT found) &&
		       (stmt = (Statement *)stmtList->getNext()))
                {
		  const char *ident = stmt->getIdentifier();
		    
		  if ((ident) &&
			(str_len(inputStmtName) == str_len(ident)) &&
			(str_cmp(inputStmtName, ident, str_len(ident)) == 0)) // matches
		  {
		    stats_ = stmt->getStatsArea();
                    if (stats_ == NULL)
                      stats_ = stmt->getCompileStatsArea();
                    found = TRUE;
                  }
                } // while
	    }
	    else
	    {
		stats_ = currContext->getStats();
	    }

	    hdfsAccess_ = 0;

	    if (stats_)
            {
	      step_ = RETURN_COMPILER_STATS_;
              if (getStatsTdb().statsMergeType_ == SQLCLI_DEFAULT_STATS)
              {
                SessionDefaults *sd = currContext->getSessionDefaults();
                if (sd)
                  statsMergeType_ = (short)sd->getStatisticsViewType();
                else
                  statsMergeType_ = stats_->getOrigCollectStatsType();
              }
              else
                statsMergeType_ = getStatsTdb().statsMergeType_;
              if (statsMergeType_ == SQLCLI_SAME_STATS || 
                // If the collection stats type is ALL_STATS, ignore the statsMergeType
                stats_->getOrigCollectStatsType() == ComTdb::ALL_STATS)
                  statsMergeType_ = stats_->getOrigCollectStatsType();
            }
	    else
	      step_ = DONE_;
	  }
	break;

	case RETURN_COMPILER_STATS_:
	  {
	    if (NOT getStatsTdb().compilerStats())
	      {
		step_ = RETURN_EXECUTOR_STATS_;
		break;
	      }

	    // make sure there is enough space to move master stats
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 20)
	      return WORK_CALL_AGAIN;	//come back later
	    
	    moveRowToUpQueue(" ");
	    
	    ExMasterStats * masterStats = stats_->getMasterStats();
	    QueryCostInfo &qci = masterStats->queryCostInfo();
	    CompilerStatsInfo &csi = masterStats->compilerStatsInfo();

	    moveRowToUpQueue("Compiler Statistics");
	    moveRowToUpQueue("===================");
	    moveRowToUpQueue(" ");

	    char formattedFloatVal[25];
	    Lng32 intSize = 0;
	    Lng32 valSize = 0;

            strcpy(statsBuf_, "Stats Collection Type  ");
            strcat(statsBuf_, ExStatisticsArea::getStatsTypeText(csi.collectStatsType()));
            moveRowToUpQueue(statsBuf_);
	    strcpy(statsBuf_, "Cost(units)            ");
	    FormatFloat(formattedFloatVal, intSize, valSize, qci.cpuTime(),
			FALSE, TRUE);
	    strcat(statsBuf_, "CPU: ");
	    strcat(statsBuf_, formattedFloatVal);

	    FormatFloat(formattedFloatVal, intSize, valSize, qci.ioTime(),
			FALSE, TRUE);
	    strcat(statsBuf_, "  IO: ");
	    strcat(statsBuf_, formattedFloatVal);

	    FormatFloat(formattedFloatVal, intSize, valSize, qci.msgTime(),
			FALSE, TRUE);
	    strcat(statsBuf_, "  Msg: ");
	    strcat(statsBuf_, formattedFloatVal);

	    FormatFloat(formattedFloatVal, intSize, valSize, qci.idleTime(),
			FALSE, TRUE);
	    strcat(statsBuf_, "  Idle: ");
	    strcat(statsBuf_, formattedFloatVal);
	    moveRowToUpQueue(statsBuf_);

	    FormatFloat(formattedFloatVal, intSize, valSize, qci.numSeqIOs(),
			FALSE, TRUE);
	    strcat(statsBuf_, "  SeqIOs: ");
	    strcat(statsBuf_, formattedFloatVal);
	    moveRowToUpQueue(statsBuf_);

	    FormatFloat(formattedFloatVal, intSize, valSize, qci.numRandIOs(),
			FALSE, TRUE);
	    strcat(statsBuf_, "  RandIOs: ");
	    strcat(statsBuf_, formattedFloatVal);
	    moveRowToUpQueue(statsBuf_);

	    FormatFloat(formattedFloatVal, intSize, valSize, qci.totalTime(),
			FALSE, TRUE);
	    strcpy(statsBuf_,      "                       TotalTime: ");
	    strcat(statsBuf_, formattedFloatVal);

	    FormatFloat(formattedFloatVal, intSize, valSize, qci.totalMem(),
			FALSE, TRUE);
	    strcat(statsBuf_,      "  TotalMem: ");
	    strcat(statsBuf_, formattedFloatVal);

	    FormatFloat(formattedFloatVal, intSize, valSize, qci.totalMem(),
			FALSE, TRUE);
	    strcat(statsBuf_,      "  EstTotalMem: ");
	    strcat(statsBuf_, formattedFloatVal);
	    strcat(statsBuf_, " bytes");

	    FormatFloat(formattedFloatVal, intSize, valSize, qci.maxCpuUsage(),
	    			FALSE, TRUE);
	    strcat(statsBuf_,      "  MaxCpuUse: ");
	    strcat(statsBuf_, formattedFloatVal);
	    strcat(statsBuf_, "%");

	    moveRowToUpQueue(statsBuf_);

	    FormatFloat(formattedFloatVal, intSize, valSize, qci.cardinality(),
			FALSE, TRUE);
	    strcpy(statsBuf_, "Rows                   ReturnedToUser: ");
	    strcat(statsBuf_, formattedFloatVal);
	    moveRowToUpQueue(statsBuf_);

	    sprintf(statsBuf_, "Fragment Size(Kb)      Total: %-4d  Master: %-4d  ESP: %-4d  ",
			csi.totalFragmentSize(),
			csi.masterFragmentSize(),
	        	csi.espFragmentSize());
	    moveRowToUpQueue(statsBuf_);

	    sprintf(statsBuf_, "Operators              Total: %-3d",
			csi.totalOps());
	    moveRowToUpQueue(statsBuf_);
	    
            sprintf(statsBuf_, "  Joins                HJ: %-3d  MJ: %-3d  NJ: %-3d   Total: %-3d",
			csi.hj(), csi.mj(), csi.nj(),  csi.totalJoins());
	    moveRowToUpQueue(statsBuf_);
            sprintf(statsBuf_, "  Others               ESPExchange: %-3d  UDR: %-3d  BMO: %-3d",  
			csi.exchangeOps(), csi.udr(), csi.bmo());

	    moveRowToUpQueue(statsBuf_);
            
	    if (masterStats->numOfRootEsps() > 0)
	      {
		sprintf(statsBuf_, "Parallelism            Root(%d)  DOP(%d)",
			    masterStats->numOfRootEsps(), csi.dop());
	      }
	    else
	      {
		sprintf(statsBuf_, "Parallelism            Root(0)  DOP(%d)",
			    csi.dop());
	      }
	    moveRowToUpQueue(statsBuf_);
	      
	    sprintf(statsBuf_,   "Query Characteristics  MandatoryXP: %s  MissingStats: %s  FullScanOnTable: %s ",
			(csi.mandatoryCrossProduct() ? "Yes" : "No"),
			(csi.missingStats() ? "Yes" : "No"),
			(csi.fullScanOnTable() ? "Yes" : "No"));
	    moveRowToUpQueue(statsBuf_);

	    if (csi.fullScanOnTable())
	      {
		sprintf(statsBuf_,"                       RowsAccessedByFullScan %f",
			    csi.dp2RowsAccessedForFullScan());
		moveRowToUpQueue(statsBuf_);
	      }

	    sprintf(statsBuf_,   "Query Execution        DOP: %d  Affinity: %d  XnReqd: %s",
			csi.dop(), csi.affinityNumber(), 
			(masterStats->xnReqd() ? "Yes" : "No"));
	    moveRowToUpQueue(statsBuf_);
            if (csi.bmo() > 0)
            {
              sprintf(statsBuf_, "                       OverFlowMode: %s  OverFlowSize: %f",
			ExBMOStats::getScratchOverflowMode(csi.ofMode()),
                        csi.ofSize());
	      moveRowToUpQueue(statsBuf_);
            }

	    moveRowToUpQueue(" ");

	    step_ = RETURN_EXECUTOR_STATS_;
	  }
	break;

	case RETURN_EXECUTOR_STATS_:
	  {
	    if (NOT getStatsTdb().executorStats())
	      {
		step_ = RETURN_OTHER_STATS_;
		break;
	      }

	    // make sure there is enough space to move master stats
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 20)
	      return WORK_CALL_AGAIN;	//come back later
	    
	    moveRowToUpQueue(" ");
	    
	    ExMasterStats * masterStats = stats_->getMasterStats();

	    if (((! masterStats) ||
		 (masterStats->getElapsedStartTime() == -1) ||
		 (masterStats->getElapsedEndTime() == -1)))
	      {
		step_ = DONE_;
		break;
	      }

	    if ((NOT getStatsTdb().oldFormat()) &&
		(NOT getStatsTdb().shortFormat()))
	      {
		moveRowToUpQueue("Executor Statistics");
		moveRowToUpQueue("===================");
		moveRowToUpQueue(" ");
	      }

	    // Display Start Time
	    short timestamp[8];
	    Int64 juliantimestamp = 
	      CONVERTTIMESTAMP(masterStats->getElapsedStartTime(),0,-1,0);
	    
	    INTERPRETTIMESTAMP(juliantimestamp, timestamp);
	    sprintf(statsBuf_, "Start Time             %04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
			timestamp[0], timestamp[1], timestamp[2],
			timestamp[3], timestamp[4], timestamp[5],
			timestamp[6], timestamp[7]);
	    moveRowToUpQueue(statsBuf_);
	    
	    // Display first row return time
	    if ((masterStats->getFirstRowReturnTime() != -1) &&
		(NOT getStatsTdb().oldFormat()) &&
		(NOT getStatsTdb().shortFormat()))
	      {
		juliantimestamp = 
		  CONVERTTIMESTAMP(masterStats->getFirstRowReturnTime(),0,-1,0);
		
		INTERPRETTIMESTAMP(juliantimestamp, timestamp);
		sprintf(statsBuf_, "First Row Returned     %04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
			    timestamp[0], timestamp[1], timestamp[2],
			    timestamp[3], timestamp[4], timestamp[5],
			    timestamp[6], timestamp[7]);
		moveRowToUpQueue(statsBuf_);
	      }

	    // Display End Time
	    juliantimestamp = 
	      CONVERTTIMESTAMP(masterStats->getElapsedEndTime(),0,-1,0);

	    INTERPRETTIMESTAMP(juliantimestamp, timestamp);
	    sprintf(statsBuf_, "End Time               %04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
			timestamp[0], timestamp[1], timestamp[2],
			timestamp[3], timestamp[4], timestamp[5],
			timestamp[6], timestamp[7]);
	    moveRowToUpQueue(statsBuf_);
	    
	    // Display Elapsed Time
	    Int64 elapsedTime = masterStats->getElapsedEndTime() -
	      masterStats->getElapsedStartTime();
	    if (elapsedTime < 0)
	      elapsedTime = 0;
	    ULng32 sec = (ULng32) (elapsedTime / 1000000);
	    ULng32 usec = (ULng32) (elapsedTime % 1000000);
	    ULng32 min = sec/60;
	    sec = sec % 60;
	    ULng32 hour = min/60;
	    min = min % 60;
	    sprintf (statsBuf_,  "Elapsed Time                      %02u:%02u:%02u.%06u",
			 hour, min, sec, usec);
	    moveRowToUpQueue(statsBuf_);
	    
	    // Display Compile Time
	    Int64 compileTime = 
	      (((masterStats->isPrepare() || masterStats->isPrepAndExec()) &&
		(masterStats->getCompEndTime() != -1)) ?
	       masterStats->getCompEndTime() -
	       masterStats->getCompStartTime() : 0);
	    if (compileTime < 0)
	      compileTime = 0;
	    sec = (ULng32) (compileTime / 1000000);
	    usec = (ULng32) (compileTime % 1000000);
	    min = sec/60;
	    sec = sec % 60;
	    hour = min/60;
	    min = min % 60;
	    sprintf (statsBuf_,  "Compile Time                      %02u:%02u:%02u.%06u",
			 hour, min, sec, usec);
	    moveRowToUpQueue(statsBuf_);

	    if ((NOT getStatsTdb().oldFormat()) &&
		(NOT getStatsTdb().shortFormat()))
	      {
		// Display Fixup Time
		Int64 fixupTime = 
		  ((masterStats->getFixupEndTime() != -1) ?
		   (masterStats->getFixupEndTime() -
		    masterStats->getFixupStartTime()) : 0);
		if (fixupTime < 0)
		  fixupTime = 0;
		sec = (ULng32) (fixupTime / 1000000);
		usec = (ULng32) (fixupTime % 1000000);
		min = sec/60;
		sec = sec % 60;
		hour = min/60;
		min = min % 60;
		sprintf (statsBuf_,  "Fixup Time                        %02u:%02u:%02u.%06u",
			     hour, min, sec, usec);
		moveRowToUpQueue(statsBuf_);
		
		// Display Freeup Time
		Int64 freeupTime = masterStats->getFreeupEndTime() -
		  masterStats->getFreeupStartTime();
		if (freeupTime < 0)
		  freeupTime = 0;
		sec = (ULng32) (freeupTime / 1000000);
		usec = (ULng32) (freeupTime % 1000000);
		min = sec/60;
		sec = sec % 60;
		hour = min/60;
		min = min % 60;
		sprintf (statsBuf_,  "Freeup Time                       %02u:%02u:%02u.%06u",
			     hour, min, sec, usec);
		moveRowToUpQueue(statsBuf_);
	      }

	    // Display Execution Time
	    Int64 executionTime = masterStats->getExeEndTime() -
	      masterStats->getExeStartTime();
	    if (executionTime < 0)
	      executionTime = 0;
	    sec = (ULng32) (executionTime / 1000000);
	    usec = (ULng32) (executionTime % 1000000);
	    min = sec/60;
	    sec = sec % 60;
	    hour = min/60;
	    min = min % 60;
	    sprintf (statsBuf_,  "Execution Time                    %02u:%02u:%02u.%06u",
			 hour, min, sec, usec);
	    moveRowToUpQueue(statsBuf_);

	    if ((NOT getStatsTdb().oldFormat()) &&
		(NOT getStatsTdb().shortFormat()))
	      {
		sprintf (statsBuf_,  "Rows Affected          %ld",
			     masterStats->getRowsAffected());
		moveRowToUpQueue(statsBuf_);
	      }

#if defined(_DEBUG)
                    if( getenv("DISPLAY_COMPILATION_STATS"))
                    {			
                      ComTdbRoot *rootTdb = 
                        (ComTdbRoot*) masterGlob->getStatement()->getRootTdb();			
                      CompilationStatsData *cmpStats = rootTdb->getCompilationStatsData();	
                      if (cmpStats != NULL)
                      {
                        moveRowToUpQueue(" ");
                        moveRowToUpQueue("Compilation Stats");
                        moveRowToUpQueue("===================");
                        moveRowToUpQueue(" ");
                    	
                        moveCompilationStatsToUpQueue(cmpStats);
                      }
                    }
#endif // _DEBUG

	    moveRowToUpQueue(" ");

	    
	    step_ = RETURN_OTHER_STATS_;
	  }
	break;

	case RETURN_OTHER_STATS_:
	  {
	    if (NOT getStatsTdb().otherStats())
	      {
		step_ = SETUP_DETAILED_STATS_;
		break;
	      }

	    // make sure there is enough space to move master stats
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 22)
	      return WORK_CALL_AGAIN;	//come back later
	    
	    moveRowToUpQueue(" ");
	    
	    ExMasterStats * masterStats = stats_->getMasterStats();

	    moveRowToUpQueue("Other Statistics");
	    moveRowToUpQueue("================");
	    moveRowToUpQueue(" ");
	    
	    if (masterStats->getQueryId())
	      {
		// split queryId into multiple lines
		char line[80];

		strcpy(line, "UniqueQueryId          ");
		strncat(line, masterStats->getQueryId(), 43);
		sprintf(statsBuf_, line);
		moveRowToUpQueue(statsBuf_);

		strcpy(line, "                       ");
		strcat(line, &masterStats->getQueryId()[43]);
		sprintf(statsBuf_, line);
		moveRowToUpQueue(statsBuf_);

		//sprintf (statsBuf_,    "UniqueQueryId          %s",
		//	     masterStats->getQueryId());
	      }
	    else
	      {
		sprintf (statsBuf_,    "UniqueQueryId          NULL");
		moveRowToUpQueue(statsBuf_);
	      }

	    if (masterStats->compilerCacheHit())
	      sprintf (statsBuf_,  "Compiler Cache Hit     Yes");
	    else
	      sprintf (statsBuf_,  "Compiler Cache Hit     No");
	    moveRowToUpQueue(statsBuf_);
	    sprintf (statsBuf_,    "Executor Cache Hit     No");
	    moveRowToUpQueue(statsBuf_);

	    sprintf (statsBuf_,    "ESPs                   Total: %-4d  Reused: %-4d  New: %-4d",
			 (masterStats->numOfTotalEspsUsed() > 0 ? masterStats->numOfTotalEspsUsed() : 0),
			 (masterStats->numOfTotalEspsUsed() > 0 ? masterStats->numOfTotalEspsUsed() : 0) -
			 (masterStats->numOfNewEspsStarted() > 0 ? masterStats->numOfNewEspsStarted() : 0),
			 (masterStats->numOfNewEspsStarted() > 0 ? masterStats->numOfNewEspsStarted() : 0)
			 );
	    moveRowToUpQueue(statsBuf_);


	    moveRowToUpQueue(" ");

	    step_ = SETUP_DETAILED_STATS_;
	  }
	break;

	case SETUP_DETAILED_STATS_:
	  {
	    if (NOT getStatsTdb().detailedStats())
	      {
		step_ = DONE_;
		break;
	      }

	    if (statsMergeType_ == SQLCLIDEV_NO_STATS)
	      {
		step_ = DONE_;
		break;
	      }

	    // set sqlparserflags to disable stats collection. We don't want
	    // to collect stats on these internal statements as that will
	    // override stats collected for the actual user statement.
	    currContext->setSqlParserFlags(0x00080000); //DISABLE_RUNTIME_STATS

	    // disable any CQS in affect
	    cliRC = cliInterface()->
	      executeImmediate("control query shape hold;");
	    if (cliRC < 0)
	      {
		ExHandleErrors(qparent_,
			       pentry_down,
			       0,
			       getGlobals(),
			       NULL,
			       (ExeErrorCode)cliRC,
			       NULL,
			       NULL
			       );
		step_ = HANDLE_ERROR_;
		break;
	      }

            if ((statsMergeType_ == SQLCLIDEV_ACCUMULATED_STATS) ||
		(statsMergeType_ == SQLCLIDEV_PERTABLE_STATS) ||
                (statsMergeType_ == SQLCLI_PROGRESS_STATS))
	      {
                char * s = getStatsTdb().stmtName_;
                // Needs to use the getStatsTdb.statsMergeType_ since MERGE can't take operator stats as MERGE token
                // value and str_parse_stmt_name will convert it to the relevant stats type
                if (s == NULL)
		  sprintf(statsQuery_, "select variable_info from table(statistics(null, 'STMT=CURRENT,MERGE=%d'));",
                              getStatsTdb().statsMergeType_);
		else
		  sprintf(statsQuery_, "select variable_info from table(statistics(null, 'STMT=%s,MERGE=%d'));",
				s, getStatsTdb().statsMergeType_);
	      }
	    else
	      {
		Int32 stats_qry_array_size = 
		  sizeof(getStatsAllDefaultViewQuery) / sizeof(QueryString);
		const QueryString * getStatsQueryString =
		  getStatsAllDefaultViewQuery;

		char * gluedQuery;
		Lng32 gluedQuerySize;
		glueQueryFragments(stats_qry_array_size, 
				   getStatsQueryString,
				   gluedQuery, gluedQuerySize);
		
                const char *s = getStatsTdb().stmtName_;
                if (s == NULL)
                  s = "CURRENT";
                sprintf(statsQuery_, gluedQuery, s, getStatsTdb().statsMergeType_);
                NADELETEBASIC(gluedQuery, getMyHeap());
            }
	    step_ = FETCH_PROLOGUE_;
	  }
	break;

	case FETCH_PROLOGUE_:
	  {
	    cliRC = cliInterface()->fetchRowsPrologue(statsQuery_);
	    if (cliRC < 0)
	      {
                cliInterface()->allocAndRetrieveSQLDiagnostics(diagsArea_);
		step_ = HANDLE_ERROR_;
		break;
	      }

	    step_ = FETCH_FIRST_STATS_ROW_;
	    
	  }
	break;

	case FETCH_FIRST_STATS_ROW_:
	  {
	    cliRC = cliInterface()->fetch();
	    if (cliRC < 0)
	      {
                cliInterface()->allocAndRetrieveSQLDiagnostics(diagsArea_);
		step_ = HANDLE_ERROR_;
		break;
	      }
            if (cliRC == 100) // EOD
	      	step_ = FETCH_EPILOGUE_;
            else
            {
	      // Skip ROOT_OPER_STATS_ROW or BMO_STATS row
              if (statsMergeType_ == SQLCLIDEV_PERTABLE_STATS || statsMergeType_ == SQLCLI_PROGRESS_STATS) 
              {
                cliInterface()->getPtrAndLen(1, statsRow_, statsRowlen_);
                getSubstrInfo(statsRow_, statsRowlen_, "statsRowType:", sstrbuf);
                short statsRowType = (short)str_atoi(sstrbuf, str_len(sstrbuf));
                if (statsRowType == ExOperStats::ROOT_OPER_STATS || statsRowType == ExOperStats::BMO_STATS ||
                  statsRowType == ExOperStats::UDR_BASE_STATS)
		  {
		    if (statsRowType == ExOperStats::ROOT_OPER_STATS)
		      {
			hdfsAccess_ = 0;
			if (getSubstrInfo(statsRow_, statsRowlen_, "hdfsAccess:", sstrbuf) == 0)
			  {
			    hdfsAccess_ = (short)str_atoi(sstrbuf, str_len(sstrbuf));
			  }
		      }

		    step_ = FETCH_FIRST_STATS_ROW_;
		  }
                else
                  step_ = DISPLAY_HEADING_;
              }
              else
                step_ = DISPLAY_HEADING_;
            }           
          }
	  break;
	case DISPLAY_HEADING_:
	  {
	    // make sure there is enough space to move header
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 10)
	      return WORK_CALL_AGAIN;	//come back later

	    moveRowToUpQueue(" ");

	    char statsType[50];

	    if ((NOT getStatsTdb().oldFormat()) &&
		(NOT getStatsTdb().shortFormat()))
	      {
		if (statsMergeType_ == SQLCLIDEV_ACCUMULATED_STATS)
		  strcpy(statsType, "ACCUMULATED");
		else if (statsMergeType_ == SQLCLIDEV_PERTABLE_STATS)
		  strcpy(statsType, "PERTABLE");
                else if(statsMergeType_ == SQLCLI_PROGRESS_STATS)
                  strcpy(statsType, "PROGRESS");
		else if (statsMergeType_ == SQLCLIDEV_ALL_STATS)
		  strcpy(statsType, "ALL");
		else if (statsMergeType_ == SQLCLIDEV_OPERATOR_STATS)
		  strcpy(statsType, "OPERATOR");
		
		strcpy(statsBuf_, "Detailed Statistics (");
		strcat(statsBuf_, statsType);
		strcat(statsBuf_, ")");
		moveRowToUpQueue(statsBuf_);

		str_pad(statsBuf_, (Int32)strlen(statsBuf_), '=');
		moveRowToUpQueue(statsBuf_);
		moveRowToUpQueue(" ");
	      }

	    if ((statsMergeType_ == SQLCLIDEV_ALL_STATS) ||
		(statsMergeType_ == SQLCLIDEV_PERTABLE_STATS) ||
		(statsMergeType_ == SQLCLIDEV_OPERATOR_STATS) ||
                (statsMergeType_ == SQLCLI_PROGRESS_STATS))
	      {
		//the fetch was successful
		if (statsMergeType_ == SQLCLIDEV_PERTABLE_STATS || statsMergeType_ == SQLCLI_PROGRESS_STATS)
		  {
		    if (hdfsAccess_)
		      {
			sprintf(statsBuf_, "%-15s%15s%15s%10s%15s%15s",
				    "Table Name", "Records", "Records", "Hdfs",  "Hdfs I/O", "Hdfs Access");
			moveRowToUpQueue(statsBuf_);
			
			sprintf(statsBuf_, "%15s%15s%15s%10s%15s%15s",
				" ", "Accessed", "Used", "I/Os", "Bytes", "Time(usec)");

		      }
		    else if (getStatsTdb().oldFormat())
		      {
			sprintf(statsBuf_, "%-15s%15s%12s%8s%10s%13s%6s",
				    "Table Name", "Records", "Records", "Disk", "Message", "Message", "Lock");
			moveRowToUpQueue(statsBuf_);
			
			sprintf(statsBuf_, "%15s%15s%12s%8s%10s%13s%6s",
				    " ", "Accessed", "Used", "I/Os", "Count", "Bytes", "");
		      }
		    else
		      {
			sprintf(statsBuf_, "%-15s%15s%15s%10s%10s%15s%6s%6s%15s",
				    "Table Name", "Records", "Records", "Disk", "Message", "Message", "Lock", "Lock", "Disk Process");
			moveRowToUpQueue(statsBuf_);
			
			sprintf(statsBuf_, "%15s%15s%15s%10s%10s%15s%6s%6s%15s",
				" ", "Accessed", "Used", "I/Os", "Count", "Bytes", "Escl", "Wait", "Busy Time");
		      }

		    moveRowToUpQueue(statsBuf_);
		  }
		else if ((statsMergeType_ == SQLCLIDEV_ALL_STATS) ||
			 (statsMergeType_ == SQLCLIDEV_OPERATOR_STATS))
		  {
		    // Construct heading.
		    sprintf(statsBuf_, "%4s%4s%4s%4s%19s%9s%9s%9s%20s%20s",
				"OP", "LC", "RC", "EX", "TDB_NAME", "EstRows", "ActRows", "WC", "Oper Cpu Time", "Details");
		    moveRowToUpQueue(statsBuf_);
		    sprintf(statsBuf_, "%4s%4s%4s%4s%19s%9s%9s%9s%20s%20s",
				"--", "--", "--", "--", "--------", "-------", "-------", "--", "-------------", "-------");
		    moveRowToUpQueue(statsBuf_);
		    moveRowToUpQueue(" ");
		  }
	      }
	    else
	      {
		moveRowToUpQueue(" ");
	      }

	    step_ = RETURN_STATS_ROW_;
	  }
	break;
	
	case FETCH_STATS_ROW_:
	  {
	    cliRC = cliInterface()->fetch();
	    if (cliRC < 0)
	      {
                cliInterface()->allocAndRetrieveSQLDiagnostics(diagsArea_);
		step_ = HANDLE_ERROR_;
		break;
	      }
	    
	    if (cliRC == 100) //no more data
              step_ = FETCH_EPILOGUE_;
	    else
            {
              // Skip ROOT_OPER_STATS_ROW or BMO_STATS row
              if (statsMergeType_ == SQLCLIDEV_PERTABLE_STATS || statsMergeType_ == SQLCLI_PROGRESS_STATS) 
              {
                cliInterface()->getPtrAndLen(1, statsRow_, statsRowlen_);
                getSubstrInfo(statsRow_, statsRowlen_, "statsRowType:", sstrbuf);
                short statsRowType = (short)str_atoi(sstrbuf, str_len(sstrbuf));
                if (statsRowType == ExOperStats::ROOT_OPER_STATS || statsRowType == ExOperStats::BMO_STATS
                  || statsRowType == ExOperStats::UDR_BASE_STATS)
                  step_ = FETCH_STATS_ROW_;
                else
              	  step_ = RETURN_STATS_ROW_;
              }
              else
                  step_ = RETURN_STATS_ROW_;
            }
	  }
	break;
	
	case RETURN_STATS_ROW_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    cliInterface()->getPtrAndLen(1, statsRow_, statsRowlen_);

	    if ((statsMergeType_ == SQLCLIDEV_ALL_STATS) ||
		(statsMergeType_ == SQLCLIDEV_OPERATOR_STATS))
	      step_ = FORMAT_AND_RETURN_ALL_STATS_;
	    else if (statsMergeType_ == SQLCLIDEV_PERTABLE_STATS || statsMergeType_ == SQLCLI_PROGRESS_STATS)
	      step_ = FORMAT_AND_RETURN_PERTABLE_STATS_;
	    else if (statsMergeType_ == SQLCLIDEV_ACCUMULATED_STATS)
	      step_ = FORMAT_AND_RETURN_ACCUMULATED_STATS_;
	    else
	      step_ = HANDLE_ERROR_;
	  }
	break;
	
	case FORMAT_AND_RETURN_PERTABLE_STATS_:
	  {
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 4)
	      return WORK_CALL_AGAIN;	//come back later

	    getSubstrInfo(statsRow_, statsRowlen_, "AnsiName:", sstrbuf);
	    sprintf(statsBuf_, "%15s", sstrbuf);
	    moveRowToUpQueue(statsBuf_);

	    if (hdfsAccess_)
            {
	      sprintf(statsBuf_, "%15s", " ");
	      getSubstrInfo(statsRow_, statsRowlen_, "AccessedRows:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%15s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "UsedRows:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%15s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "HbaseSumIOCalls:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%10s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "MessagesBytes:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%15s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "HbaseSumIOTime:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%15s", sstrbuf);
	    }
            else if (getStatsTdb().oldFormat())
            {
              sprintf(statsBuf_, "%15s", " ");
	      getSubstrInfo(statsRow_, statsRowlen_, "AccessedRows:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%15s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "UsedRows:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%12s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "DiskIOs:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%8s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "NumMessages:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%10s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "MessagesBytes:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%13s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "Escalations:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%6s", sstrbuf);
            }
            else
            {
	      sprintf(statsBuf_, "%15s", " ");
	      getSubstrInfo(statsRow_, statsRowlen_, "AccessedRows:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%15s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "UsedRows:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%15s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "DiskIOs:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%10s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "NumMessages:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%10s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "MessagesBytes:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%15s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "Escalations:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%6s", sstrbuf);

	      getSubstrInfo(statsRow_, statsRowlen_, "LockWaits:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%6s", sstrbuf);
  	    
	      getSubstrInfo(statsRow_, statsRowlen_, "ProcessBusyTime:", sstrbuf);
	      sprintf(&statsBuf_[strlen(statsBuf_)], "%15s", sstrbuf);
	    }

	    moveRowToUpQueue(statsBuf_);

	    step_ = FETCH_STATS_ROW_;
	  }
	break;

	case FORMAT_AND_RETURN_ACCUMULATED_STATS_:
	  {
	    // make sure there is enough space to move header
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 31)
	      return WORK_CALL_AGAIN;	//come back later
	   
	    getSubstrInfo(statsRow_, statsRowlen_, "AccessedRows:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Accessed Rows", sstrbuf);
	    moveRowToUpQueue(statsBuf_);
	
	    getSubstrInfo(statsRow_, statsRowlen_, "UsedRows:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Used Rows", sstrbuf);
	    moveRowToUpQueue(statsBuf_);

	    getSubstrInfo(statsRow_, statsRowlen_, "NumMessages:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Message Count", sstrbuf);
	    moveRowToUpQueue(statsBuf_);

	    getSubstrInfo(statsRow_, statsRowlen_, "MessagesBytes:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Message Bytes", sstrbuf);
	    moveRowToUpQueue(statsBuf_);

	    getSubstrInfo(statsRow_, statsRowlen_, "StatsBytes:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Stats Bytes", sstrbuf);
	    moveRowToUpQueue(statsBuf_);

	    getSubstrInfo(statsRow_, statsRowlen_, "DiskIOs:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Disk IOs", sstrbuf);
	    moveRowToUpQueue(statsBuf_);

	    getSubstrInfo(statsRow_, statsRowlen_, "LockWaits:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Lock Waits", sstrbuf);
	    moveRowToUpQueue(statsBuf_);

	    getSubstrInfo(statsRow_, statsRowlen_, "Escalations:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Lock Escalations", sstrbuf);
	    moveRowToUpQueue(statsBuf_);
		
	
	    getSubstrInfo(statsRow_, statsRowlen_, "CpuTime:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "SQL Process Busy Time", sstrbuf);
	    moveRowToUpQueue(statsBuf_);
	    
	    getSubstrInfo(statsRow_, statsRowlen_, "SpaceTotal:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10sKB", "SQL Space Allocated", sstrbuf);
	    moveRowToUpQueue(statsBuf_);
	    
	    getSubstrInfo(statsRow_, statsRowlen_, "SpaceUsed:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10sKB", "SQL Space Used", sstrbuf);
	    moveRowToUpQueue(statsBuf_);
	    
	    getSubstrInfo(statsRow_, statsRowlen_, "HeapTotal:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10sKB", "SQL Heap Allocated", sstrbuf);
	    moveRowToUpQueue(statsBuf_);
	    
	    getSubstrInfo(statsRow_, statsRowlen_, "HeapUsed:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10sKB", "SQL Heap Used", sstrbuf);
	    moveRowToUpQueue(statsBuf_);
	    
	    getSubstrInfo(statsRow_, statsRowlen_, "Opens:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Opens", sstrbuf);
	    moveRowToUpQueue(statsBuf_);
    
	    getSubstrInfo(statsRow_, statsRowlen_, "OpenTime:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Open Time", sstrbuf);
	    moveRowToUpQueue(statsBuf_);

	    getSubstrInfo(statsRow_, statsRowlen_, "Newprocess:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Processes Created", sstrbuf);
	    moveRowToUpQueue(statsBuf_);

	    getSubstrInfo(statsRow_, statsRowlen_, "NewprocessTime:", sstrbuf);
	    sprintf(statsBuf_, "%-25s%10s", "Process Create Time", sstrbuf);
	    moveRowToUpQueue(statsBuf_);

	    step_ = FETCH_STATS_ROW_;
	  }
	break;

	case FORMAT_AND_RETURN_ALL_STATS_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    str_cpy_all(statsBuf_, statsRow_, statsRowlen_);
	    moveRowToUpQueue(statsBuf_, statsRowlen_);

	    step_ = FETCH_STATS_ROW_;
	  }
	break;

	case HANDLE_ERROR_:
	  {
	    step_ = FETCH_EPILOGUE_;
	  }
	break;

	case FETCH_EPILOGUE_:
	  {
	    cliRC = cliInterface()->fetchRowsEpilogue(statsQuery_);

	    // restore the original shape before return.
	    cliRC = cliInterface()->
	      executeImmediate("control query shape restore;");

	    // reset stats collection to the original value
	    currContext->resetSqlParserFlags(0x00080000); //DISABLE_RUNTIME_STATS

	    step_ = DONE_;
	  }
	break;

	case DONE_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    // Return EOF.
	    ex_queue_entry * up_entry = qparent_.up->getTailEntry();
	    
	    up_entry->upState.parentIndex = 
	      pentry_down->downState.parentIndex;
	    
	    up_entry->upState.setMatchNo(0);
	    up_entry->upState.status = ex_queue::Q_NO_DATA;
	    
	    // insert into parent
	    qparent_.up->insert();
	    
	    //	    pstate.matches_ = 0;
	    qparent_.down->removeHead();
	    
	    return WORK_OK;
	  }
	break;

	}
    }
}

////////////////////////////////////////////////////////////////////////
// Redefine virtual method allocatePstates, to be used by dynamic queue
// resizing, as well as the initial queue construction.
////////////////////////////////////////////////////////////////////////
ex_tcb_private_state * ExExeUtilGetStatisticsTcb::allocatePstates(
     Lng32 &numElems,      // inout, desired/actual elements
     Lng32 &pstateLength)  // out, length of one element
{
  PstateAllocator<ExExeUtilGetStatisticsPrivateState> pa;

  return pa.allocatePstates(this, numElems, pstateLength);
}

/////////////////////////////////////////////////////////////////////////////
// Constructor and destructor for ExeUtil_private_state
/////////////////////////////////////////////////////////////////////////////
ExExeUtilGetStatisticsPrivateState::ExExeUtilGetStatisticsPrivateState()
{
}

ExExeUtilGetStatisticsPrivateState::~ExExeUtilGetStatisticsPrivateState()
{
};

ExExeUtilGetRTSStatisticsTcb::ExExeUtilGetRTSStatisticsTcb(
     const ComTdbExeUtilGetStatistics & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilTcb( exe_util_tdb, NULL, glob)
{
   // Allocate the private state in each entry of the down queue
  qparent_.down->allocatePstate(this);

  step_ = INITIAL_;
   
  // buffer where output will be formatted
  statsBuf_ = new(glob->getDefaultHeap()) char[4096];
  sqlStatsDesc_ = NULL;
  currStatsDescEntry_ = -1;
  currStatsItemEntry_ = -1;
  masterStatsItems_ = NULL;
  measStatsItems_ = NULL;
  operatorStatsItems_ = NULL;
  rootOperStatsItems_ = NULL;
  partitionAccessStatsItems_ = NULL;
  pertableStatsItems_ = NULL;
  rmsStatsItems_ = NULL;
  bmoStatsItems_ = NULL;
  udrbaseStatsItems_ = NULL;
  replicateStatsItems_ = NULL;
  replicatorStatsItems_ = NULL;
  hbaseStatsItems_ = NULL;
  hiveStatsItems_ = NULL;
  isHeadingDisplayed_ = FALSE;
  isBMOHeadingDisplayed_ = FALSE;
  isUDRBaseHeadingDisplayed_ = FALSE;
  isHbaseHeadingDisplayed_ = FALSE;
  isHiveHeadingDisplayed_ = FALSE;
  maxMasterStatsItems_ = 0;
  maxMeasStatsItems_ = 0;
  maxOperatorStatsItems_ = 0;
  maxRootOperStatsItems_ = 0;
  maxPartitionAccessStatsItems_ = 0;
  maxPertableStatsItems_ = 0;
  maxRMSStatsItems_ = 0;
  maxBMOStatsItems_ = 0;
  maxUDRBaseStatsItems_ = 0;
  maxReplicateStatsItems_ = 0;
  maxReplicatorStatsItems_ = 0;
  maxHbaseStatsItems_ = 0;
  maxHiveStatsItems_ = 0;
  singleLineFormat_ = ((ComTdbExeUtilGetStatistics &)exe_util_tdb).singleLineFormat();
}

ExExeUtilGetRTSStatisticsTcb::~ExExeUtilGetRTSStatisticsTcb()
{
  NADELETEBASIC(statsBuf_, getGlobals()->getDefaultHeap());
  if (sqlStatsDesc_ != NULL)
    NADELETEBASIC(sqlStatsDesc_, getGlobals()->getDefaultHeap());
  if (masterStatsItems_ != NULL)
  {
    deleteSqlStatItems(masterStatsItems_, maxMasterStatsItems_);
    masterStatsItems_ = NULL;
  }
  if (measStatsItems_ != NULL)
  {
    deleteSqlStatItems(measStatsItems_, maxMeasStatsItems_);
    measStatsItems_ = NULL;
  }
  if (operatorStatsItems_ != NULL)
  {
    deleteSqlStatItems(operatorStatsItems_, maxOperatorStatsItems_);
    operatorStatsItems_ = NULL;
  }
  if (rootOperStatsItems_ != NULL)
  {
    deleteSqlStatItems(rootOperStatsItems_, maxRootOperStatsItems_);
    rootOperStatsItems_ = NULL;
  }
  if (partitionAccessStatsItems_ != NULL)
  {
    deleteSqlStatItems(partitionAccessStatsItems_, maxPartitionAccessStatsItems_);
    partitionAccessStatsItems_ = NULL;
  }
  if (pertableStatsItems_ != NULL)
  {
    deleteSqlStatItems(pertableStatsItems_, maxPertableStatsItems_);
    pertableStatsItems_ = NULL;
  }
  if (rmsStatsItems_ != NULL)
  {
    deleteSqlStatItems(rmsStatsItems_, maxRMSStatsItems_);
    rmsStatsItems_ = NULL;
  }
  if (bmoStatsItems_ != NULL)
  {
    deleteSqlStatItems(bmoStatsItems_, maxBMOStatsItems_);
    bmoStatsItems_ = NULL;
  }
  if (udrbaseStatsItems_ != NULL)
  {
    deleteSqlStatItems(udrbaseStatsItems_, maxUDRBaseStatsItems_);
    udrbaseStatsItems_ = NULL;
  }
  if (replicateStatsItems_ != NULL)
  {
    deleteSqlStatItems(replicateStatsItems_, maxReplicateStatsItems_);
    replicateStatsItems_ = NULL;
  }
  if (replicatorStatsItems_ != NULL)
  {
    deleteSqlStatItems(replicatorStatsItems_, maxReplicatorStatsItems_);
    replicatorStatsItems_ = NULL;
  }
  if (hbaseStatsItems_ != NULL)
  {
    deleteSqlStatItems(hbaseStatsItems_, maxHbaseStatsItems_);
    hbaseStatsItems_ = NULL;
  }
  if (hiveStatsItems_ != NULL)
  {
    deleteSqlStatItems(hiveStatsItems_, maxHiveStatsItems_);
    hiveStatsItems_ = NULL;
  }
}

void ExExeUtilGetRTSStatisticsTcb::formatInt64(SQLSTATS_ITEM stat, char* targetString)
{
  Int64 value = stat.int64_value;
  sprintf(targetString, "%ld", value);
  if (value >= 1000)
  {
    Lng32 intSize = str_len(targetString);
    AddCommas(targetString,intSize);
  }
}


void ExExeUtilGetRTSStatisticsTcb::formatWInt64(SQLSTATS_ITEM stat, char* targetString)
{
  if (stat.error_code)
    strcpy(targetString,"");   
  else
  {
    Int64 value = stat.int64_value;
    sprintf(targetString, "%ld", value);
    Lng32 intSize = str_len(targetString);
    AddCommas(targetString,intSize);
  }
}


void ExExeUtilGetRTSStatisticsTcb::formatOperStatItems(SQLSTATS_ITEM operStatsItems[])
{
  operStatsItems[0].statsItem_id = SQLSTATS_TDB_ID;
  operStatsItems[1].statsItem_id = SQLSTATS_LEFT_CHILD;
  operStatsItems[2].statsItem_id = SQLSTATS_RIGHT_CHILD;
  operStatsItems[3].statsItem_id = SQLSTATS_PARENT_TDB_ID;
  operStatsItems[4].statsItem_id = SQLSTATS_EXPLAIN_NODE_ID;
  operStatsItems[5].statsItem_id = SQLSTATS_FRAG_NUM;
  operStatsItems[6].statsItem_id = SQLSTATS_TDB_NAME;
  operStatsItems[6].str_value    = new (getGlobals()->getDefaultHeap())
                                                char[MAX_TDB_NAME_LEN+1];
  operStatsItems[6].str_max_len  = MAX_TDB_NAME_LEN;
  operStatsItems[7].statsItem_id = SQLSTATS_NUM_CALLS;  
  operStatsItems[8].statsItem_id = SQLSTATS_OPER_CPU_TIME;                  
  operStatsItems[9].statsItem_id = SQLSTATS_EST_ROWS_USED;
  operStatsItems[10].statsItem_id = SQLSTATS_ACT_ROWS_USED;
  operStatsItems[11].statsItem_id = SQLSTATS_DETAIL;
  operStatsItems[11].str_value    = new (getGlobals()->getDefaultHeap())
                                              char[1001];
  operStatsItems[11].str_max_len = 1000;
  operStatsItems[12].statsItem_id = SQLSTATS_DOP;
}
                
// operStatsItems must be in the following order for formatOperStats()
// Tdb Id, LeftChild, RightChild, Explain Node Id, TdbName,  NumCalls, SQL CPU Busy Time,
// Est Rows Accessed, Est Rows Used, Act Rows Used,
// SQL Space Alloc, SQL Space Used, SQL Heap Alloc, SQL Heap used

void ExExeUtilGetRTSStatisticsTcb::formatOperStats(SQLSTATS_ITEM* operStatsItems)
{
  char valString[25];
  Lng32 intSize=0;
  Lng32 valSize=0;
  if(!isHeadingDisplayed_ )
  {
    moveRowToUpQueue("");
    isHeadingDisplayed_ = TRUE;
    sprintf(statsBuf_, "%5s%5s%5s%5s%5s%5s %-25s%5s%13s%19s%19s%19s %s", 
      "LC","RC","Id","PaId", "ExId","Frag","TDBName","DOP", "Dispatches","OperCPUTime","EstRowsUsed", 
      "ActRowsUsed","Details");
    moveRowToUpQueue(statsBuf_);
    moveRowToUpQueue("");
  } 

  // Left Child TdbId
  if(operStatsItems[1].int64_value > 0)
    formatInt64(operStatsItems[1], valString);
  else
    strcpy(valString, "."); 
  sprintf(statsBuf_, "%5s", valString);        
 
  // Right Child TdbId
  if(operStatsItems[2].int64_value > 0)
    formatInt64(operStatsItems[2], valString);
  else
    strcpy(valString, ".");       
  sprintf(&statsBuf_[strlen(statsBuf_)], "%5s", valString);      

  // Id
  formatInt64(operStatsItems[0], valString);
  sprintf(&statsBuf_[strlen(statsBuf_)], "%5s", valString);        

  // Parent Tdb Id
  if(operStatsItems[3].int64_value > 0)
    formatInt64(operStatsItems[3], valString);
  else
    strcpy(valString, ".");
  sprintf(&statsBuf_[strlen(statsBuf_)], "%5s", valString);      

  // Explain Node Id
  formatInt64(operStatsItems[4], valString);
  sprintf(&statsBuf_[strlen(statsBuf_)], "%5s", valString);
  // Frag Num 
  formatInt64(operStatsItems[5], valString);
  sprintf(&statsBuf_[strlen(statsBuf_)], "%5s", valString);
   
  // Tdb Name
  if (operStatsItems[6].error_code)
    sprintf(&statsBuf_[strlen(statsBuf_)], " %-25s", "");   
  else
  {
    operStatsItems[6].str_value[operStatsItems[6].str_ret_len] = '\0'; 
    sprintf(&statsBuf_[strlen(statsBuf_)], " %-25s", operStatsItems[6].str_value);
  }

  // dop 
  formatInt64(operStatsItems[12], valString);
  sprintf(&statsBuf_[strlen(statsBuf_)], "%5s", valString);
  
  // Number of Work Calls
  formatInt64(operStatsItems[7], valString);
  sprintf(&statsBuf_[strlen(statsBuf_)], "%13s", valString);
  
  // CPU Time
  formatInt64(operStatsItems[8], valString);
  sprintf(&statsBuf_[strlen(statsBuf_)], "%19s", valString);
  
  // Estimated Rows Used
  sprintf(valString, "%.6g", operStatsItems[9].double_value);
  sprintf(&statsBuf_[strlen(statsBuf_)], "%19s", valString); 
  
  // Actual Rows Used 
  formatInt64(operStatsItems[10], valString);
  sprintf(&statsBuf_[strlen(statsBuf_)], "%19s", valString);

  // Detail
  if (operStatsItems[11].error_code)
    sprintf(&statsBuf_[strlen(statsBuf_)], "%s", "");   
  else
  {
    operStatsItems[11].str_value[operStatsItems[11].str_ret_len] = '\0'; 
    sprintf(&statsBuf_[strlen(statsBuf_)], " %s", operStatsItems[11].str_value);
  }
}


void ExExeUtilGetRTSStatisticsTcb::deleteSqlStatItems(SQLSTATS_ITEM *sqlStatsItem, 
                              ULng32  noOfStatsItem)
{
  for (ULng32 i= 0; i < noOfStatsItem; i++)
  {
    if (sqlStatsItem[i].str_value != NULL)
      NADELETEBASIC(sqlStatsItem[i].str_value, getGlobals()->getDefaultHeap());
  }
  NADELETEBASIC(sqlStatsItem, getGlobals()->getDefaultHeap()); 
}

void ExExeUtilGetRTSStatisticsTcb::initSqlStatsItems(SQLSTATS_ITEM *sqlStatsItem,
                                  ULng32  noOfStatsItem, NABoolean initTdbIdOnly)
{
  for (ULng32 i = 0; i < noOfStatsItem; i++)
  {
    if (initTdbIdOnly)
    {
      sqlStatsItem[i].tdb_id = sqlStatsDesc_[currStatsDescEntry_].tdb_id;
    }
    else
    {
      sqlStatsItem[i].stats_type = sqlStatsDesc_[currStatsDescEntry_].stats_type;
      sqlStatsItem[i].tdb_id = sqlStatsDesc_[currStatsDescEntry_].tdb_id;
      sqlStatsItem[i].str_value = NULL;
    }
  }
}

//////////////////////////////////////////////////////
// work() for ExExeUtilGetRTSStatisticsTcb
//////////////////////////////////////////////////////
short ExExeUtilGetRTSStatisticsTcb::work()
{
  //  short rc = 0;
  Lng32 cliRC = 0;
  ULng32 sec;
  ULng32 usec;
  ULng32 min;
  ULng32 hour;
  ULng32 i;
  short rc;
  Int64 jtime;
  
  short stmtState;
  short queryType;
  short timestamp[8];
  short subqueryType;

  char formattedFloatVal[25];
  char Int64Val[50];
  Lng32 intSize = 0;
  Lng32 valSize = 0;
  char timestampVal[50];
  Lng32 microSecs;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;
  
  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;
  
  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getStatement()->getContext();
  SessionDefaults *sd = currContext->getSessionDefaults();
  short statsMergeType = 0;

  while (1)
  {
    switch (step_)
    {
    case INITIAL_:
      {
        switch (getStatsTdb().statsMergeType_)
        {
        case SQLCLI_ACCUMULATED_STATS:
          sqlStatsDesc_ = new (getGlobals()->getDefaultHeap()) SQLSTATS_DESC[MAX_ACCUMULATED_STATS_DESC];
          maxStatsDescEntries_ = MAX_ACCUMULATED_STATS_DESC;
          break;
        case SQLCLI_PERTABLE_STATS:
          sqlStatsDesc_ = new (getGlobals()->getDefaultHeap()) SQLSTATS_DESC[MAX_PERTABLE_STATS_DESC];
          maxStatsDescEntries_ = MAX_PERTABLE_STATS_DESC;
          break;
        case SQLCLI_PROGRESS_STATS:
          sqlStatsDesc_ = new (getGlobals()->getDefaultHeap()) SQLSTATS_DESC[MAX_PROGRESS_STATS_DESC];
          maxStatsDescEntries_ = MAX_PROGRESS_STATS_DESC;
          break;
        case SQLCLI_OPERATOR_STATS:
          sqlStatsDesc_ = new (getGlobals()->getDefaultHeap()) SQLSTATS_DESC[MAX_OPERATOR_STATS_DESC];
          maxStatsDescEntries_ = MAX_OPERATOR_STATS_DESC;
          break;
        case SQLCLI_RMS_INFO_STATS:
          sqlStatsDesc_ = new (getGlobals()->getDefaultHeap()) SQLSTATS_DESC[MAX_RMS_STATS_DESC];
          maxStatsDescEntries_ = MAX_RMS_STATS_DESC;
          break;
        default:
          sqlStatsDesc_ = new (getGlobals()->getDefaultHeap()) SQLSTATS_DESC[MAX_OPERATOR_STATS_DESC];
          maxStatsDescEntries_ = MAX_OPERATOR_STATS_DESC;
          break;
        }
        Lng32 diagMarkValue = currContext ->getDiagsArea() -> mark();
        cliRC = SQL_EXEC_GetStatistics2(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                getStatsTdb().activeQueryNum_,
                getStatsTdb().statsMergeType_,
                &statsCollectType_,
                sqlStatsDesc_,
                maxStatsDescEntries_,
                &retStatsDescEntries_);
        
        // if not enough stats desc array, make a larger one
        if( cliRC == -CLI_INSUFFICIENT_STATS_DESC)
        {
          currContext ->getDiagsArea() -> rewind(diagMarkValue);
          step_ = EXPAND_STATS_ARRAY_;        
        }
        else
        if (cliRC < 0)
        {
          step_ = HANDLE_ERROR_;
        }
        else
        {
          currStatsDescEntry_ = -1;
          currStatsItemEntry_ = -1;
          isHeadingDisplayed_ = FALSE;
          isBMOHeadingDisplayed_ = FALSE;
          isUDRBaseHeadingDisplayed_ = FALSE;
          if (getStatsTdb().statsMergeType_ == SQLCLI_DEFAULT_STATS)
          {
            if (sd)
              statsMergeType = (short)sd->getStatisticsViewType();
            else
              statsMergeType = statsCollectType_;
          }
          else
            statsMergeType = getStatsTdb().statsMergeType_;
          if (statsMergeType == SQLCLI_SAME_STATS)
            statsMergeType = statsCollectType_;
          step_ = GET_NEXT_STATS_DESC_ENTRY_;
        }
      }
      break;
    case EXPAND_STATS_ARRAY_:
      {
         NADELETEBASIC(sqlStatsDesc_, getGlobals()->getDefaultHeap());
         maxStatsDescEntries_ = retStatsDescEntries_;
         sqlStatsDesc_ = new (getGlobals()->getDefaultHeap()) SQLSTATS_DESC[maxStatsDescEntries_];
         cliRC = SQL_EXEC_GetStatistics2(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                getStatsTdb().activeQueryNum_,
                getStatsTdb().statsMergeType_,
                &statsCollectType_,
                sqlStatsDesc_,
                maxStatsDescEntries_,
                &retStatsDescEntries_);
        
        if (cliRC < 0)
        {
          step_ = HANDLE_ERROR_;
        }
        else
        {
          currStatsDescEntry_ = -1;
          currStatsItemEntry_ = -1;
          isHeadingDisplayed_ = FALSE;
          isBMOHeadingDisplayed_ = FALSE;
          isUDRBaseHeadingDisplayed_ = FALSE;
          if (getStatsTdb().statsMergeType_ == SQLCLI_DEFAULT_STATS)
          {
            if (sd)
              statsMergeType = (short)sd->getStatisticsViewType();
            else
              statsMergeType = statsCollectType_;
          }
          else
            statsMergeType = getStatsTdb().statsMergeType_;
          if (statsMergeType == SQLCLI_SAME_STATS)
            statsMergeType = statsCollectType_;
          step_ = GET_NEXT_STATS_DESC_ENTRY_;
        }
      }
      break;
    case GET_NEXT_STATS_DESC_ENTRY_:
      {
        currStatsDescEntry_++;
        currStatsItemEntry_ = 0;
        if (currStatsDescEntry_ >= retStatsDescEntries_)
          step_ = DONE_;
        else
        {
          if (statsMergeType == SQLCLI_OPERATOR_STATS)
          {
            if (sqlStatsDesc_[currStatsDescEntry_].stats_type == SQLSTATS_DESC_MASTER_STATS)
              step_ = GET_MASTER_STATS_ENTRY_;
            else
              step_ = GET_OPER_STATS_ENTRY_;
          }
          else
          {
            switch (sqlStatsDesc_[currStatsDescEntry_].stats_type)
            {
            case SQLSTATS_DESC_MASTER_STATS:
              step_ = GET_MASTER_STATS_ENTRY_;
              break;
            case SQLSTATS_DESC_ROOT_OPER_STATS:
              step_ = GET_ROOTOPER_STATS_ENTRY_;
              break;
            case SQLSTATS_DESC_BMO_STATS:
              step_ = GET_BMO_STATS_ENTRY_;
              break;
            case SQLSTATS_DESC_REPLICATE_STATS:
              step_ = GET_REPLICATE_STATS_ENTRY_;
              break;
            case SQLSTATS_DESC_REPLICATOR_STATS:
              step_ = GET_REPLICATOR_STATS_ENTRY_;
              break;
            case SQLSTATS_DESC_MEAS_STATS:
              step_ = GET_MEAS_STATS_ENTRY_;
              break;
            case SQLSTATS_DESC_RMS_STATS:
              step_ = GET_RMS_STATS_ENTRY_;
              break;
            case SQLSTATS_DESC_UDR_BASE_STATS:
              step_ = GET_UDR_BASE_STATS_ENTRY_;
              break;
            case SQLSTATS_DESC_HBASE_ACCESS_STATS:
              step_ = GET_HBASE_STATS_ENTRY_;
              break;
            case SQLSTATS_DESC_HDFSSCAN_STATS:
              step_ = GET_HIVE_STATS_ENTRY_;
              break;
            default:
              step_ = GET_NEXT_STATS_DESC_ENTRY_;
              break;
            }
          }
        }
      }
      break;
    case GET_MASTER_STATS_ENTRY_:
      {
        if (masterStatsItems_ == NULL)
        {
          maxMasterStatsItems_ = 36;
          masterStatsItems_ = new (getGlobals()->getDefaultHeap()) 
                  SQLSTATS_ITEM[maxMasterStatsItems_];
          initSqlStatsItems(masterStatsItems_, maxMasterStatsItems_, FALSE);
          masterStatsItems_[0].statsItem_id = SQLSTATS_QUERY_ID;
          masterStatsItems_[1].statsItem_id = SQLSTATS_COMP_START_TIME;
          masterStatsItems_[2].statsItem_id = SQLSTATS_COMP_END_TIME;
          masterStatsItems_[3].statsItem_id = SQLSTATS_COMP_TIME;
          masterStatsItems_[4].statsItem_id = SQLSTATS_EXECUTE_START_TIME;
          masterStatsItems_[5].statsItem_id = SQLSTATS_EXECUTE_END_TIME;
          masterStatsItems_[6].statsItem_id = SQLSTATS_EXECUTE_TIME;
          masterStatsItems_[7].statsItem_id = SQLSTATS_STMT_STATE;
          masterStatsItems_[8].statsItem_id = SQLSTATS_ROWS_AFFECTED;
          masterStatsItems_[9].statsItem_id = SQLSTATS_SQL_ERROR_CODE;
          masterStatsItems_[10].statsItem_id = SQLSTATS_STATS_ERROR_CODE;
          masterStatsItems_[11].statsItem_id = SQLSTATS_QUERY_TYPE;
          masterStatsItems_[12].statsItem_id = SQLSTATS_SUBQUERY_TYPE;
          masterStatsItems_[13].statsItem_id = SQLSTATS_EST_ROWS_ACCESSED;
          masterStatsItems_[14].statsItem_id = SQLSTATS_EST_ROWS_USED;
          masterStatsItems_[15].statsItem_id = SQLSTATS_PARENT_QUERY_ID;   
          masterStatsItems_[16].statsItem_id = SQLSTATS_PARENT_QUERY_SYSTEM;   
          masterStatsItems_[17].statsItem_id = SQLSTATS_CHILD_QUERY_ID;
          masterStatsItems_[18].statsItem_id = SQLSTATS_NUM_SQLPROCS;
          masterStatsItems_[19].statsItem_id = SQLSTATS_NUM_CPUS;
          masterStatsItems_[20].statsItem_id  = SQLSTATS_MASTER_PRIORITY;
          masterStatsItems_[21].statsItem_id  = SQLSTATS_TRANSID;
          masterStatsItems_[22].statsItem_id = SQLSTATS_SOURCE_STR;
          masterStatsItems_[23].statsItem_id = SQLSTATS_SOURCE_STR_LEN;
          masterStatsItems_[24].statsItem_id = SQLSTATS_ROWS_RETURNED;
          masterStatsItems_[25].statsItem_id = SQLSTATS_FIRST_ROW_RET_TIME;
          masterStatsItems_[26].statsItem_id = SQLSTATS_AQR_LAST_ERROR;
          masterStatsItems_[27].statsItem_id = SQLSTATS_AQR_NUM_RETRIES;
          masterStatsItems_[28].statsItem_id = SQLSTATS_AQR_DELAY_BEFORE_RETRY;
          masterStatsItems_[29].statsItem_id = SQLSTATS_RECLAIM_SPACE_COUNT;
          masterStatsItems_[30].statsItem_id = SQLSTATS_CANCEL_TIME_ID;
          masterStatsItems_[31].statsItem_id = SQLSTATS_SUSPEND_TIME_ID;
          masterStatsItems_[32].statsItem_id = SQLSTATS_EXECUTE_COUNT;
          masterStatsItems_[33].statsItem_id = SQLSTATS_EXECUTE_TIME_MIN;
          masterStatsItems_[34].statsItem_id = SQLSTATS_EXECUTE_TIME_MAX;
          masterStatsItems_[35].statsItem_id = SQLSTATS_EXECUTE_TIME_AVG;
          // maxMasterStatsItems_ is set to 36
          masterStatsItems_[0].str_value = new (getGlobals()->getDefaultHeap())
                          char[ComSqlId::MAX_QUERY_ID_LEN+1];
          masterStatsItems_[0].str_max_len = ComSqlId::MAX_QUERY_ID_LEN;
          // Parent Qid
          masterStatsItems_[15].str_value = new (getGlobals()->getDefaultHeap())
                          char[ComSqlId::MAX_QUERY_ID_LEN+1];
          masterStatsItems_[15].str_max_len = ComSqlId::MAX_QUERY_ID_LEN;
          // Parent Qid System
          masterStatsItems_[16].str_value = new (getGlobals()->getDefaultHeap())
                          char[24];
          masterStatsItems_[16].str_max_len = 23;
          // Child Qid
          masterStatsItems_[17].str_value = new (getGlobals()->getDefaultHeap())
                          char[ComSqlId::MAX_QUERY_ID_LEN+1];
          masterStatsItems_[17].str_max_len = ComSqlId::MAX_QUERY_ID_LEN;
          // Source Str
          masterStatsItems_[22].str_value = new (getGlobals()->getDefaultHeap())
                          char[RMS_STORE_SQL_SOURCE_LEN+2];
          masterStatsItems_[22].str_max_len = RMS_STORE_SQL_SOURCE_LEN;
        }
        else
          initSqlStatsItems(masterStatsItems_, maxMasterStatsItems_, TRUE);
        cliRC = SQL_EXEC_GetStatisticsItems(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                maxMasterStatsItems_,
                masterStatsItems_);
        if (cliRC < 0)
        {
          step_ = HANDLE_ERROR_;
        }
        else
          step_ = FORMAT_AND_RETURN_MASTER_STATS_;
      }
      break;
    case FORMAT_AND_RETURN_MASTER_STATS_:
      {
        for (; currStatsItemEntry_ < maxMasterStatsItems_; currStatsItemEntry_++)
        {
          i = (short)currStatsItemEntry_;
          statsBuf_[0] = '\0';
          if (masterStatsItems_[i].error_code != 0)
            continue;
          switch (masterStatsItems_[i].statsItem_id)
          {
          case SQLSTATS_QUERY_ID:
            masterStatsItems_[i].str_value[masterStatsItems_[i].str_ret_len] = '\0';
            sprintf(statsBuf_, "%-25s%s", "Qid", masterStatsItems_[i].str_value);
            break;
          case SQLSTATS_SOURCE_STR:
            masterStatsItems_[i].str_value[masterStatsItems_[i].str_ret_len] = '\0';
            masterStatsItems_[i].str_value[masterStatsItems_[i].str_ret_len+1] = '\0';
            sprintf(statsBuf_, "%-25s%s", "Source String ", masterStatsItems_[i].str_value);
            break;
          case SQLSTATS_SOURCE_STR_LEN:
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "SQL Source Length", Int64Val);

            break;
          case SQLSTATS_COMP_START_TIME:
	    jtime = CONVERTTIMESTAMP(masterStatsItems_[i].int64_value,0,-1,NULL);
	    INTERPRETTIMESTAMP(jtime, timestamp);
	    sprintf(statsBuf_, "%-25s%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                        "Compile Start Time",
			timestamp[0], timestamp[1], timestamp[2],
			timestamp[3], timestamp[4], timestamp[5],
			timestamp[6], timestamp[7]);
	    break;
          case SQLSTATS_COMP_END_TIME:
            if (masterStatsItems_[i].int64_value != -1)
            {
	      jtime = CONVERTTIMESTAMP(masterStatsItems_[i].int64_value,0,-1,NULL);
	      INTERPRETTIMESTAMP(jtime, timestamp);
	      sprintf(statsBuf_, "%-25s%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                          "Compile End Time",
			  timestamp[0], timestamp[1], timestamp[2],
			  timestamp[3], timestamp[4], timestamp[5],
			  timestamp[6], timestamp[7]);
            }
            else
              sprintf(statsBuf_, "%-25s%s", "Compile End Time", "-1");
	    break;
          case SQLSTATS_COMP_TIME:
            sec = (ULng32) (masterStatsItems_[i].int64_value / 1000000);
            usec = (ULng32) (masterStatsItems_[i].int64_value % 1000000);
            min = sec/60;
            sec = sec % 60;
            hour = min/60;
            min = min % 60;

            sprintf (statsBuf_,  "%-34s%4u:%02u:%02u.%06u", 
                          "Compile Elapsed Time",hour, min, sec,usec);   
            break;
          case SQLSTATS_EXECUTE_START_TIME:
            if (masterStatsItems_[i].int64_value != -1)
            {
	      jtime = CONVERTTIMESTAMP(masterStatsItems_[i].int64_value,0,-1,NULL);
	      INTERPRETTIMESTAMP(jtime, timestamp);
	      sprintf(statsBuf_, "%-25s%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                          "Execute Start Time",
			  timestamp[0], timestamp[1], timestamp[2],
			  timestamp[3], timestamp[4], timestamp[5],
			  timestamp[6], timestamp[7]);
            }
            else
              sprintf(statsBuf_, "%-25s%s", "Execute Start Time", "-1");
	    break;
          case SQLSTATS_FIRST_ROW_RET_TIME:
            if (masterStatsItems_[i].int64_value != -1)
            {
	      jtime =  CONVERTTIMESTAMP(masterStatsItems_[i].int64_value,0,-1,NULL);
    	    
              INTERPRETTIMESTAMP(jtime, timestamp);
	      sprintf(statsBuf_, "%-25s%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                          "First Row Returned Time",
			  timestamp[0], timestamp[1], timestamp[2],
			  timestamp[3], timestamp[4], timestamp[5],
			  timestamp[6], timestamp[7]);
            }
            else
            {
              sprintf(statsBuf_, "%-25s%s",
                            "First Row Returned Time", "-1");
            }
            break;
         case SQLSTATS_CANCEL_TIME_ID:
            if (masterStatsItems_[i].int64_value != -1)
            {
	      jtime = CONVERTTIMESTAMP(masterStatsItems_[i].int64_value,0,-1,NULL);
	      INTERPRETTIMESTAMP(jtime, timestamp);
	      sprintf(statsBuf_, "%-25s%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                          "Cancel Time",
			  timestamp[0], timestamp[1], timestamp[2],
			  timestamp[3], timestamp[4], timestamp[5],
			  timestamp[6], timestamp[7]);
            }
            else
              sprintf(statsBuf_, "%-25s%s", "Cancel Time", "-1");
            break;
         case SQLSTATS_EXECUTE_END_TIME:
            if (masterStatsItems_[i].int64_value != -1)
            {
	      jtime = CONVERTTIMESTAMP(masterStatsItems_[i].int64_value,0,-1,NULL);
	      INTERPRETTIMESTAMP(jtime, timestamp);
	      sprintf(statsBuf_, "%-25s%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                          "Execute End Time",
			  timestamp[0], timestamp[1], timestamp[2],
			  timestamp[3], timestamp[4], timestamp[5],
			  timestamp[6], timestamp[7]);
            }
            else
              sprintf(statsBuf_, "%-25s%s", "Execute End Time", "-1");
	    break;
          case SQLSTATS_EXECUTE_TIME:
            sec = (ULng32) (masterStatsItems_[i].int64_value / 1000000);
            usec = (ULng32) (masterStatsItems_[i].int64_value % 1000000);
            min = sec/60;
            sec = sec % 60;
            hour = min/60;
            min = min % 60;

            sprintf (statsBuf_,  "%-34s%4u:%02u:%02u.%06u", "Execute Elapsed Time",
  	                  hour, min, sec,usec);   
            break;
          case SQLSTATS_FIXUP_TIME:
            sec = (ULng32) (masterStatsItems_[i].int64_value / 1000000);
            usec = (ULng32) (masterStatsItems_[i].int64_value % 1000000);
            min = sec/60;
            sec = sec % 60;
            hour = min/60;
            min = min % 60;
            sprintf (statsBuf_,  "%34s%4u:%02u:%02u.%06u", "Fixup Elapsed Time",
  	                  hour, min, sec,usec);   
            break;
          case SQLSTATS_STMT_STATE:
            stmtState  = (short)masterStatsItems_[i].int64_value;
            if (stmtState >= SQLSTMT_STATE_UNKNOWN)
              stmtState = SQLSTMT_STATE_UNKNOWN;
            sprintf(statsBuf_, "%-25s%s", "State", 
                  Statement::stmtState((Statement::State)stmtState));
            break;
          case SQLSTATS_ROWS_AFFECTED:
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Rows Affected", Int64Val);
            break;
          case SQLSTATS_ROWS_RETURNED:
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Rows Returned", Int64Val);
            break;
          case SQLSTATS_SQL_ERROR_CODE:
            sprintf(statsBuf_, "%-25s%-d", "SQL Error Code", 
                      (Lng32)masterStatsItems_[i].int64_value);
            break;
          case SQLSTATS_STATS_ERROR_CODE:
            sprintf(statsBuf_, "%-25s%-d", "Stats Error Code", 
                      (Lng32)masterStatsItems_[i].int64_value);
            break;
          case SQLSTATS_QUERY_TYPE:
            queryType = (short)masterStatsItems_[i].int64_value;
            sprintf(statsBuf_, "%-25s%s", "Query Type",
                    ComTdbRoot::getQueryTypeText(queryType));
            break;
          case SQLSTATS_SUBQUERY_TYPE:
            subqueryType = (short)masterStatsItems_[i].int64_value;
            sprintf(statsBuf_, "%-25s%s", "Sub Query Type",
                    ComTdbRoot::getSubqueryTypeText(subqueryType));
            break;
          case SQLSTATS_EST_ROWS_ACCESSED:
            sprintf(statsBuf_, "%-25s%.6g", "Estimated Accessed Rows", masterStatsItems_[i].double_value);
            break;
          case SQLSTATS_EST_ROWS_USED:
            sprintf(statsBuf_, "%-25s%.6g", "Estimated Used Rows", masterStatsItems_[i].double_value);
            break;
          case SQLSTATS_PARENT_QUERY_ID:
            masterStatsItems_[i].str_value[masterStatsItems_[i].str_ret_len] = '\0';
            sprintf(statsBuf_, "%-25s%s", "Parent Qid", masterStatsItems_[i].str_value);
            break;
          case SQLSTATS_PARENT_QUERY_SYSTEM:
            masterStatsItems_[i].str_value[masterStatsItems_[i].str_ret_len] = '\0';
            sprintf(statsBuf_, "%-25s%s", "Parent Query System", masterStatsItems_[i].str_value);
            break;
          case SQLSTATS_CHILD_QUERY_ID:
            masterStatsItems_[i].str_value[masterStatsItems_[i].str_ret_len] = '\0';
            sprintf(statsBuf_, "%-25s%s", "Child Qid", masterStatsItems_[i].str_value);
            break;
          case SQLSTATS_NUM_SQLPROCS:
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Number of SQL Processes", Int64Val);
            break;
          case SQLSTATS_NUM_CPUS:
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Number of Cpus", Int64Val);
            break;
          case SQLSTATS_TRANSID:
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            sprintf(statsBuf_, "%-25s%s", "Transaction Id", 
                              Int64Val);
            break;
          case SQLSTATS_SUSPEND_TIME_ID:
            if (masterStatsItems_[i].int64_value != -1)
            {
	      jtime = CONVERTTIMESTAMP(masterStatsItems_[i].int64_value,0,-1,NULL);
	      INTERPRETTIMESTAMP(jtime, timestamp);
	      sprintf(statsBuf_, "%-25s%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                          "Last Suspend Time",
			  timestamp[0], timestamp[1], timestamp[2],
			  timestamp[3], timestamp[4], timestamp[5],
			  timestamp[6], timestamp[7]);
            }
            else
              sprintf(statsBuf_, "%-25s%s", "Last Suspend Time", "-1");
            break;
          case SQLSTATS_AQR_LAST_ERROR:
            sprintf(statsBuf_, "%-25s%-d", "Last Error before AQR", 
		 (Lng32)masterStatsItems_[i].int64_value);         
            break;
          case SQLSTATS_AQR_NUM_RETRIES:
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Number of AQR retries", Int64Val);
            break;
          case SQLSTATS_AQR_DELAY_BEFORE_RETRY:
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Delay before AQR", Int64Val);
            break;
          case SQLSTATS_RECLAIM_SPACE_COUNT:
            sprintf(statsBuf_, "%-25s%-d", "No. of times reclaimed", 
		 (Lng32)masterStatsItems_[i].int64_value);         
            break;
          case SQLSTATS_EXECUTE_COUNT:
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "No. of times executed", Int64Val);
            break;
          case SQLSTATS_EXECUTE_TIME_MIN:
            microSecs = masterStatsItems_[i].int64_value % 1000000L;
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value/1000000);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s.%06d secs", "Min. Execute Time", Int64Val,microSecs);
            break;
          case SQLSTATS_EXECUTE_TIME_MAX:
            microSecs = masterStatsItems_[i].int64_value % 1000000L;
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value/1000000);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s.%06d secs", "Max. Execute Time", Int64Val,microSecs);
            break;
          case SQLSTATS_EXECUTE_TIME_AVG:
            microSecs = masterStatsItems_[i].int64_value % 1000000L;
            sprintf(Int64Val, "%ld", masterStatsItems_[i].int64_value/1000000);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s.%06d secs", "Avg. Execute Time", Int64Val,microSecs);
            break;
          default:
            statsBuf_[0] = '\0';
            break;
          }
          if (strlen(statsBuf_) > 0)
            if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
              return rc;
        }
        sprintf(statsBuf_, "%-25s%s", "Stats Collection Type", 
                    ExStatisticsArea::getStatsTypeText(statsCollectType_));
        if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
          return rc;
        step_ = GET_NEXT_STATS_DESC_ENTRY_;
      }
      break;
    case GET_MEAS_STATS_ENTRY_:
      {
        if (measStatsItems_ == NULL)
        {
          maxMeasStatsItems_ = 30;
          measStatsItems_ = new (getGlobals()->getDefaultHeap()) 
                  SQLSTATS_ITEM[maxMeasStatsItems_];
          initSqlStatsItems(measStatsItems_, maxMeasStatsItems_, FALSE);
          measStatsItems_[0].statsItem_id = SQLSTATS_ACT_ROWS_ACCESSED;
          measStatsItems_[1].statsItem_id = SQLSTATS_ACT_ROWS_USED;
          measStatsItems_[2].statsItem_id = SQLSTATS_SE_IOS;
          measStatsItems_[3].statsItem_id = SQLSTATS_SE_IO_BYTES;
          measStatsItems_[4].statsItem_id = SQLSTATS_SE_IO_MAX_TIME;
          measStatsItems_[5].statsItem_id = SQLSTATS_SQL_CPU_BUSY_TIME;
          measStatsItems_[6].statsItem_id = SQLSTATS_UDR_CPU_BUSY_TIME;
          measStatsItems_[7].statsItem_id = SQLSTATS_SQL_SPACE_ALLOC;
          measStatsItems_[8].statsItem_id = SQLSTATS_SQL_SPACE_USED;
          measStatsItems_[9].statsItem_id = SQLSTATS_SQL_HEAP_ALLOC;
          measStatsItems_[10].statsItem_id = SQLSTATS_SQL_HEAP_USED;
          measStatsItems_[11].statsItem_id = SQLSTATS_SQL_HEAP_WM;
          measStatsItems_[12].statsItem_id = SQLSTATS_OPENS;
          measStatsItems_[13].statsItem_id = SQLSTATS_OPEN_TIME;
          measStatsItems_[14].statsItem_id = SQLSTATS_PROCESS_CREATED;
          measStatsItems_[15].statsItem_id = SQLSTATS_PROCESS_CREATE_TIME;
          measStatsItems_[16].statsItem_id = SQLSTATS_REQ_MSG_CNT;
          measStatsItems_[17].statsItem_id = SQLSTATS_REQ_MSG_BYTES;
          measStatsItems_[18].statsItem_id = SQLSTATS_REPLY_MSG_CNT;
          measStatsItems_[19].statsItem_id = SQLSTATS_REPLY_MSG_BYTES;
          measStatsItems_[20].statsItem_id = SQLSTATS_BMO_SPACE_BUFFER_SIZE;
          measStatsItems_[21].statsItem_id = SQLSTATS_BMO_SPACE_BUFFER_COUNT;
          measStatsItems_[22].statsItem_id = SQLSTATS_INTERIM_ROW_COUNT;
          measStatsItems_[23].statsItem_id = SQLSTATS_SCRATCH_OVERFLOW_MODE;
          measStatsItems_[24].statsItem_id = SQLSTATS_SCRATCH_FILE_COUNT;
          measStatsItems_[25].statsItem_id = SQLSTATS_SCRATCH_IO_SIZE;
          measStatsItems_[26].statsItem_id = SQLSTATS_SCRATCH_READ_COUNT;
          measStatsItems_[27].statsItem_id = SQLSTATS_SCRATCH_WRITE_COUNT;
          measStatsItems_[28].statsItem_id = SQLSTATS_SCRATCH_IO_MAX_TIME;
          measStatsItems_[29].statsItem_id = SQLSTATS_TOPN;
          // maxMeasStatsItems_ is set to  30
        }
        else
          initSqlStatsItems(measStatsItems_, maxMeasStatsItems_, TRUE);
        cliRC = SQL_EXEC_GetStatisticsItems(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                maxMeasStatsItems_,
                measStatsItems_);
        if (cliRC < 0)
        {
          step_ = HANDLE_ERROR_;
        }
        else
          step_ = FORMAT_AND_RETURN_MEAS_STATS_;
      }
      break;
    case FORMAT_AND_RETURN_MEAS_STATS_:
      {
        for (; currStatsItemEntry_ < maxMeasStatsItems_; currStatsItemEntry_++)
        {
          i = (short)currStatsItemEntry_;
          if (measStatsItems_[i].error_code != 0)
            continue;
          switch (measStatsItems_[i].statsItem_id)
          {
          case SQLSTATS_ACT_ROWS_ACCESSED:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Accessed Rows", Int64Val);
            break;          
          case SQLSTATS_ACT_ROWS_USED:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Used Rows", Int64Val);
            break;
          case SQLSTATS_SE_IOS:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "SE IOs", Int64Val);
            break;
          case SQLSTATS_SE_IO_BYTES:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "SE IO Bytes", Int64Val);
            break;
          case SQLSTATS_SE_IO_MAX_TIME:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "SE IO MAX Time", Int64Val);
            break;
          case SQLSTATS_SQL_CPU_BUSY_TIME:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "SQL Process Busy Time", Int64Val);
            break;
          case SQLSTATS_UDR_CPU_BUSY_TIME:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "UDR Process Busy Time", Int64Val);
            break;
          case SQLSTATS_SQL_SPACE_ALLOC:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s KB", "SQL Space Allocated", Int64Val); 
            break;
          case SQLSTATS_SQL_SPACE_USED:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s KB", "SQL Space Used", Int64Val); 
            break;
          case SQLSTATS_SQL_HEAP_ALLOC:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s KB", "SQL Heap Allocated", Int64Val);
            break;
          case SQLSTATS_SQL_HEAP_USED:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s KB", "SQL Heap Used", Int64Val);
            break;
          case SQLSTATS_SQL_HEAP_WM:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s KB", "SQL Heap WM", Int64Val);
            break;
          case SQLSTATS_OPENS:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Opens", Int64Val);
            break;
          case SQLSTATS_OPEN_TIME:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Open Time", Int64Val);
            break;
          case SQLSTATS_PROCESS_CREATED:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Processes Created", Int64Val);
            break;
          case SQLSTATS_PROCESS_CREATE_TIME:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Process Create Time", Int64Val);
            break;
          case SQLSTATS_REQ_MSG_CNT:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Request Message Count", Int64Val);
            break;
          case SQLSTATS_REQ_MSG_BYTES:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Request Message Bytes", Int64Val);
            break;
          case SQLSTATS_REPLY_MSG_CNT:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Reply Message Count", Int64Val);
            break;
          case SQLSTATS_REPLY_MSG_BYTES:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Reply Message Bytes", Int64Val);
            break;
          case SQLSTATS_SCRATCH_OVERFLOW_MODE:
            sprintf(statsBuf_, "%-25s%s", "Scr. Overflow Mode", 
              ExBMOStats::getScratchOverflowMode((Int16)measStatsItems_[i].int64_value));
            break;
          case SQLSTATS_TOPN:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Sort TopN", Int64Val);
            break;
          case SQLSTATS_SCRATCH_FILE_COUNT:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Scr. File Count", Int64Val);
            break;
          case SQLSTATS_BMO_SPACE_BUFFER_SIZE:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "BMO Space Buffer Size", Int64Val);
            break;
          case SQLSTATS_BMO_SPACE_BUFFER_COUNT:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "BMO Space Buffer Count", Int64Val);
            break;
          case SQLSTATS_SCRATCH_READ_COUNT:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Scr. Read Count", Int64Val);
            break;
          case SQLSTATS_SCRATCH_WRITE_COUNT:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Scr. Write Count", Int64Val);
            break;
          case SQLSTATS_SCRATCH_IO_SIZE:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Scr. IO Size", Int64Val);
            break;
          case SQLSTATS_SCRATCH_IO_MAX_TIME:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "Scr. IO Max Time", Int64Val);
            break;
          case SQLSTATS_INTERIM_ROW_COUNT:
            sprintf(Int64Val, "%ld", measStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-25s%s", "BMO Interim Row Count", Int64Val);
            break;
          default:
            statsBuf_[0] = '\0';
            break;
          }
          if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
            return rc;
        }
        step_ = GET_NEXT_STATS_DESC_ENTRY_;
      }
      break;
    case GET_ROOTOPER_STATS_ENTRY_:
      {
        if (rootOperStatsItems_ == NULL)
        {
          maxRootOperStatsItems_ = 27;
          rootOperStatsItems_ = new (getGlobals()->getDefaultHeap()) 
                  SQLSTATS_ITEM[maxRootOperStatsItems_];
          initSqlStatsItems(rootOperStatsItems_, maxRootOperStatsItems_, FALSE);
          rootOperStatsItems_[0].statsItem_id = SQLSTATS_SQL_CPU_BUSY_TIME;
          rootOperStatsItems_[1].statsItem_id = SQLSTATS_SQL_MAX_WAIT_TIME;
          rootOperStatsItems_[2].statsItem_id = SQLSTATS_SQL_AVG_WAIT_TIME;
          rootOperStatsItems_[3].statsItem_id = SQLSTATS_UDR_CPU_BUSY_TIME;
          rootOperStatsItems_[4].statsItem_id = SQLSTATS_SQL_SPACE_ALLOC;
          rootOperStatsItems_[5].statsItem_id = SQLSTATS_SQL_SPACE_USED;
          rootOperStatsItems_[6].statsItem_id = SQLSTATS_SQL_HEAP_ALLOC;
          rootOperStatsItems_[7].statsItem_id = SQLSTATS_SQL_HEAP_USED;
          rootOperStatsItems_[8].statsItem_id = SQLSTATS_SQL_HEAP_WM;
          rootOperStatsItems_[9].statsItem_id = SQLSTATS_OPENS;
          rootOperStatsItems_[10].statsItem_id = SQLSTATS_OPEN_TIME;
          rootOperStatsItems_[11].statsItem_id = SQLSTATS_PROCESS_CREATED;
          rootOperStatsItems_[12].statsItem_id = SQLSTATS_PROCESS_CREATE_TIME;
          rootOperStatsItems_[13].statsItem_id = SQLSTATS_REQ_MSG_CNT;
          rootOperStatsItems_[14].statsItem_id = SQLSTATS_REQ_MSG_BYTES;
          rootOperStatsItems_[15].statsItem_id = SQLSTATS_REPLY_MSG_CNT;
          rootOperStatsItems_[16].statsItem_id = SQLSTATS_REPLY_MSG_BYTES;
          rootOperStatsItems_[17].statsItem_id = SQLSTATS_BMO_SPACE_BUFFER_SIZE;
          rootOperStatsItems_[18].statsItem_id = SQLSTATS_BMO_SPACE_BUFFER_COUNT;
          rootOperStatsItems_[19].statsItem_id = SQLSTATS_INTERIM_ROW_COUNT;
          rootOperStatsItems_[20].statsItem_id = SQLSTATS_SCRATCH_OVERFLOW_MODE;
          rootOperStatsItems_[21].statsItem_id = SQLSTATS_SCRATCH_FILE_COUNT;
          rootOperStatsItems_[22].statsItem_id = SQLSTATS_SCRATCH_IO_SIZE;
          rootOperStatsItems_[23].statsItem_id = SQLSTATS_SCRATCH_READ_COUNT;
          rootOperStatsItems_[24].statsItem_id = SQLSTATS_SCRATCH_WRITE_COUNT;
          rootOperStatsItems_[25].statsItem_id = SQLSTATS_SCRATCH_IO_MAX_TIME;
          rootOperStatsItems_[26].statsItem_id = SQLSTATS_TOPN;
          // maxRootOperStatsItems_ is set to 27
        }
        else
          initSqlStatsItems(rootOperStatsItems_, maxRootOperStatsItems_, TRUE);

        cliRC = SQL_EXEC_GetStatisticsItems(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                maxRootOperStatsItems_,
                rootOperStatsItems_);
        if (cliRC < 0)
        {
          step_ = HANDLE_ERROR_;
        }
        else
          step_ = FORMAT_AND_RETURN_ROOTOPER_STATS_;
      }
      break;
    case FORMAT_AND_RETURN_ROOTOPER_STATS_:
      {
        for (; currStatsItemEntry_ < maxRootOperStatsItems_; currStatsItemEntry_++)
        {
          i = (short)currStatsItemEntry_;
          if (rootOperStatsItems_[i].error_code != 0)
            continue;
          switch (rootOperStatsItems_[i].statsItem_id)
          {         
          case SQLSTATS_SQL_CPU_BUSY_TIME:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s", "SQL Process Busy Time", Int64Val);
            break;
          case SQLSTATS_SQL_MAX_WAIT_TIME:
            if (getenv("SQL_DISPLAY_WAIT_TIME"))
            {
               // Convert it into microseconds
               sprintf(statsBuf_, "%-25s%s", "SQL Max Wait Time",
                 formatElapsedTime(timestampVal, rootOperStatsItems_[i].int64_value/1000));
            }
            else
               continue;
            break;
          case SQLSTATS_SQL_AVG_WAIT_TIME:
            if (getenv("SQL_DISPLAY_WAIT_TIME"))
            {
               // Convert it into microseconds
               sprintf(statsBuf_, "%-25s%s", "SQL Avg Wait Time",
                 formatElapsedTime(timestampVal, rootOperStatsItems_[i].int64_value/1000));
            }
            else
               continue;
            break;
          case SQLSTATS_UDR_CPU_BUSY_TIME:
            if (statsMergeType != SQLCLI_PROGRESS_STATS)
            {
              formatWInt64( rootOperStatsItems_[i], Int64Val);
              sprintf(statsBuf_, "%-25s%s", "UDR Process Busy Time", Int64Val);
            }
            else
              continue;
            break;
          case SQLSTATS_SQL_SPACE_ALLOC:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s KB", "SQL Space Allocated", Int64Val);
            break;
          case SQLSTATS_SQL_SPACE_USED:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s KB", "SQL Space Used", Int64Val);
            break;
          case SQLSTATS_SQL_HEAP_ALLOC:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s KB", "SQL Heap Allocated", Int64Val);
            break;
          case SQLSTATS_SQL_HEAP_USED:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s KB", "SQL Heap Used", Int64Val);
            break;
          case SQLSTATS_SQL_HEAP_WM:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s KB", "SQL Heap WM", Int64Val);
            break;
          case SQLSTATS_OPENS:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s", "Opens", Int64Val);
            break;
          case SQLSTATS_OPEN_TIME:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s", "Open Time", Int64Val);
            break;
          case SQLSTATS_PROCESS_CREATED:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s", "Processes Created", Int64Val);
            break;
          case SQLSTATS_PROCESS_CREATE_TIME:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s", "Process Create Time", Int64Val);
            break;
          case SQLSTATS_REQ_MSG_CNT:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s", "Request Message Count", Int64Val);
            break;
          case SQLSTATS_REQ_MSG_BYTES:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s", "Request Message Bytes", Int64Val);
            break;
          case SQLSTATS_REPLY_MSG_CNT:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s", "Reply Message Count", Int64Val);
            break;
          case SQLSTATS_REPLY_MSG_BYTES:
            formatWInt64( rootOperStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s", "Reply Message Bytes", Int64Val);
            break;
          case SQLSTATS_SCRATCH_OVERFLOW_MODE:
            if (statsMergeType != SQLCLI_PROGRESS_STATS)
            {
              sprintf(statsBuf_, "%-25s%s", "Scr. Overflow Mode", 
                ExBMOStats::getScratchOverflowMode((Int16)rootOperStatsItems_[i].int64_value));
            }
            else
              continue;
            break;
          case SQLSTATS_BMO_SPACE_BUFFER_SIZE:
            if (statsMergeType != SQLCLI_PROGRESS_STATS)
            {
              formatWInt64( rootOperStatsItems_[i], Int64Val);
              sprintf(statsBuf_, "%-25s%s", "BMO Space Buffer Size", Int64Val);
            }
            else
              continue;
            break;
          case SQLSTATS_BMO_SPACE_BUFFER_COUNT:
            if (statsMergeType != SQLCLI_PROGRESS_STATS)
            {
              formatWInt64( rootOperStatsItems_[i], Int64Val);
              sprintf(statsBuf_, "%-25s%s", "BMO Space Buffer Count", Int64Val);
            }
            else
              continue;
            break;
          case SQLSTATS_TOPN:
            if (statsMergeType != SQLCLI_PROGRESS_STATS)
            {
              formatWInt64( rootOperStatsItems_[i], Int64Val);
              sprintf(statsBuf_, "%-25s%s", "Sort TopN", Int64Val);
            }
            else
              continue;
            break;
          case SQLSTATS_SCRATCH_FILE_COUNT:
            if (statsMergeType != SQLCLI_PROGRESS_STATS)
            {
              formatWInt64( rootOperStatsItems_[i], Int64Val);
              sprintf(statsBuf_, "%-25s%s", "Scr. File Count", Int64Val);
            }
            else
              continue;
            break;
          case SQLSTATS_SCRATCH_IO_SIZE:
            if (statsMergeType != SQLCLI_PROGRESS_STATS)
            {
              formatWInt64( rootOperStatsItems_[i], Int64Val);
              sprintf(statsBuf_, "%-25s%s", "Scr. IO Size", Int64Val);
            }
            else
              continue;
            break;
          case SQLSTATS_SCRATCH_READ_COUNT:
            if (statsMergeType != SQLCLI_PROGRESS_STATS)
            {
              formatWInt64( rootOperStatsItems_[i], Int64Val);
              sprintf(statsBuf_, "%-25s%s", "Scr. Read Count", Int64Val);
            }
            else
              continue;
            break;
          case SQLSTATS_SCRATCH_WRITE_COUNT:
            if (statsMergeType != SQLCLI_PROGRESS_STATS)
            {
              formatWInt64( rootOperStatsItems_[i], Int64Val);
              sprintf(statsBuf_, "%-25s%s", "Scr. Write Count", Int64Val);
            }
            else
              continue;
            break;
          case SQLSTATS_SCRATCH_IO_MAX_TIME:
            if (statsMergeType != SQLCLI_PROGRESS_STATS)
            {
              formatWInt64( rootOperStatsItems_[i], Int64Val);
              sprintf(statsBuf_, "%-25s%s", "Scr. IO Max Time", Int64Val);
            }
            else
              continue;
            break;
          case SQLSTATS_INTERIM_ROW_COUNT:
            if (statsMergeType != SQLCLI_PROGRESS_STATS)
            {
              formatWInt64( rootOperStatsItems_[i], Int64Val);
              sprintf(statsBuf_, "%-25s%s", "BMO Interim Row Count", Int64Val);
            }
            else
              continue;
            break;
          default:
            statsBuf_[0] = '\0';
            break;
          }
          if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
            return rc;
        }
        step_ = GET_NEXT_STATS_DESC_ENTRY_;
      }
      break;
    case GET_HBASE_STATS_ENTRY_:
      {
        if (hbaseStatsItems_ == NULL)
        {
          maxHbaseStatsItems_ = 11;
          hbaseStatsItems_ = new (getGlobals()->getDefaultHeap()) 
                  SQLSTATS_ITEM[maxHbaseStatsItems_];
          initSqlStatsItems(hbaseStatsItems_, maxHbaseStatsItems_, FALSE);
          hbaseStatsItems_[0].statsItem_id = SQLSTATS_TDB_ID;
          hbaseStatsItems_[1].statsItem_id = SQLSTATS_DOP;
          hbaseStatsItems_[2].statsItem_id = SQLSTATS_TABLE_ANSI_NAME;
          hbaseStatsItems_[3].statsItem_id = SQLSTATS_EST_ROWS_ACCESSED;
          hbaseStatsItems_[4].statsItem_id = SQLSTATS_ACT_ROWS_ACCESSED;
          hbaseStatsItems_[5].statsItem_id = SQLSTATS_EST_ROWS_USED;
          hbaseStatsItems_[6].statsItem_id = SQLSTATS_ACT_ROWS_USED;
          hbaseStatsItems_[7].statsItem_id = SQLSTATS_HBASE_IOS;
          hbaseStatsItems_[8].statsItem_id = SQLSTATS_HBASE_IO_BYTES;
          hbaseStatsItems_[9].statsItem_id = SQLSTATS_HBASE_IO_ELAPSED_TIME;
          hbaseStatsItems_[10].statsItem_id = SQLSTATS_HBASE_IO_MAX_TIME;
          // maxHbaseStatsItems_ is set to 11
          // SQLSTATS_TABLE_ANSI_NAM
          hbaseStatsItems_[2].str_value = new (getGlobals()->getDefaultHeap())
            char[ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES+1];
          hbaseStatsItems_[2].str_max_len = ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES;
        }
        else
          initSqlStatsItems(hbaseStatsItems_, maxHbaseStatsItems_, TRUE);
        cliRC = SQL_EXEC_GetStatisticsItems(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                maxHbaseStatsItems_,
                hbaseStatsItems_);
        if (cliRC < 0)
        {
          step_ = HANDLE_ERROR_;
        }
        else
        {
          if (! isHeadingDisplayed_)
            step_ = DISPLAY_HBASE_STATS_HEADING_;
          else
            step_ = FORMAT_AND_RETURN_HBASE_STATS_;
        }
      }
      break;
    case DISPLAY_HBASE_STATS_HEADING_:
    case DISPLAY_HIVE_STATS_HEADING_:
      {
        if ((qparent_.up->getSize() - qparent_.up->getLength()) < 5)
	      return WORK_CALL_AGAIN;
        moveRowToUpQueue(" ");
        if (singleLineFormat_) {
           sprintf(statsBuf_, "%5s%10s%15s%20s%15s%20s%20s%20s%20s%20s%10s",
                "Id", "DOP",
                "EstRowsAccess", "ActRowsAccess", "EstRowUsed", "ActRowsUsed", "SE_IOs",
                "SE_IO_KBytes", "SE_IO_SumTime", "SE_IO_MaxTime", "TableName");
           moveRowToUpQueue(statsBuf_);
        }
        else {
           sprintf(statsBuf_, "%5s%10s %-20s", 
                "Id", "DOP","Table Name");
	   moveRowToUpQueue(statsBuf_);
           sprintf(statsBuf_, "%15s%20s%15s%20s%20s%20s%20s%20s",
		"EstRowsAccess", "ActRowsAccess", "EstRowsUsed", "ActRowsUsed", "SE_IOs", "SE_IO_KBytes", "SE_IO_SumTime", "SE_IO_MaxTime");
           moveRowToUpQueue(statsBuf_);
        }
        isHeadingDisplayed_ = TRUE;
        if (step_ == DISPLAY_HBASE_STATS_HEADING_)
           step_ = FORMAT_AND_RETURN_HBASE_STATS_;
        else
           step_ = FORMAT_AND_RETURN_HIVE_STATS_;
      }
      break;
    case FORMAT_AND_RETURN_HBASE_STATS_:
    case FORMAT_AND_RETURN_HIVE_STATS_:
      {
        short tableNameIndex = 2;
        SQLSTATS_ITEM *statsItems;
        Lng32 maxStatsItems;

        if (step_ == FORMAT_AND_RETURN_HBASE_STATS_) {
           statsItems = hbaseStatsItems_;
           maxStatsItems = maxHbaseStatsItems_;
        }
        else {
           statsItems = hiveStatsItems_;
           maxStatsItems = maxHiveStatsItems_;
        } 
        for (; currStatsItemEntry_ < maxStatsItems; currStatsItemEntry_++)
        {
          i = (short)currStatsItemEntry_;
          if (statsItems[i].error_code != 0)
            continue;
          switch (statsItems[i].statsItem_id)
          {
          case SQLSTATS_TDB_ID:
            sprintf(statsBuf_, "%5ld", statsItems[i].int64_value);
            break;
          case SQLSTATS_DOP:
            sprintf(&statsBuf_[strlen(statsBuf_)], "%10ld", statsItems[i].int64_value);
            break;
          case SQLSTATS_TABLE_ANSI_NAME:
            statsItems[i].str_value[statsItems[i].str_ret_len] = '\0';
            if (singleLineFormat_)
               tableNameIndex = i;
            else {
               sprintf(&statsBuf_[strlen(statsBuf_)], " %s", statsItems[i].str_value);
               if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
                  return rc;
            }
            break;
          case SQLSTATS_EST_ROWS_ACCESSED:
            sprintf(formattedFloatVal, "%.6g", statsItems[i].double_value);
            if (singleLineFormat_)
               sprintf(&statsBuf_[strlen(statsBuf_)], "%15s", formattedFloatVal);
            else
               sprintf(statsBuf_, "%15s", formattedFloatVal);
            break;
          case SQLSTATS_EST_ROWS_USED:
            sprintf(formattedFloatVal, "%.6g", statsItems[i].double_value);
            sprintf(&statsBuf_[strlen(statsBuf_)], "%15s", formattedFloatVal);
            break;
          case SQLSTATS_ACT_ROWS_ACCESSED:
            sprintf(Int64Val, "%ld", statsItems[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;          
          case SQLSTATS_ACT_ROWS_USED:
            sprintf(Int64Val, "%ld", statsItems[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          case SQLSTATS_HBASE_IOS:
          case SQLSTATS_HIVE_IOS:
           sprintf(Int64Val, "%ld", statsItems[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          case SQLSTATS_HBASE_IO_BYTES:
          case SQLSTATS_HIVE_IO_BYTES:
            sprintf(Int64Val, "%ld", statsItems[i].int64_value/1024);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          case SQLSTATS_HBASE_IO_ELAPSED_TIME:
          case SQLSTATS_HIVE_IO_ELAPSED_TIME:
            sprintf(Int64Val, "%ld", statsItems[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          case SQLSTATS_HBASE_IO_MAX_TIME:
          case SQLSTATS_HIVE_IO_MAX_TIME:
            sprintf(Int64Val, "%ld", statsItems[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          default:
            break;
          }
        }
        if (singleLineFormat_)
           sprintf(&statsBuf_[strlen(statsBuf_)], " %s", statsItems[2].str_value);
        if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
          return rc;
        step_ = GET_NEXT_STATS_DESC_ENTRY_;
      }
      break;
    case GET_HIVE_STATS_ENTRY_:
      {
        if (hiveStatsItems_ == NULL)
        {
          maxHiveStatsItems_ = 11;
          hiveStatsItems_ = new (getGlobals()->getDefaultHeap()) 
                  SQLSTATS_ITEM[maxHiveStatsItems_];
          initSqlStatsItems(hiveStatsItems_, maxHiveStatsItems_, FALSE);
          hiveStatsItems_[0].statsItem_id = SQLSTATS_TDB_ID;
          hiveStatsItems_[1].statsItem_id = SQLSTATS_DOP;
          hiveStatsItems_[2].statsItem_id = SQLSTATS_TABLE_ANSI_NAME;
          hiveStatsItems_[3].statsItem_id = SQLSTATS_EST_ROWS_ACCESSED;
          hiveStatsItems_[4].statsItem_id = SQLSTATS_ACT_ROWS_ACCESSED;
          hiveStatsItems_[5].statsItem_id = SQLSTATS_EST_ROWS_USED;
          hiveStatsItems_[6].statsItem_id = SQLSTATS_ACT_ROWS_USED;
          hiveStatsItems_[7].statsItem_id = SQLSTATS_HIVE_IOS;
          hiveStatsItems_[8].statsItem_id = SQLSTATS_HIVE_IO_BYTES;
          hiveStatsItems_[9].statsItem_id = SQLSTATS_HIVE_IO_ELAPSED_TIME;
          hiveStatsItems_[10].statsItem_id = SQLSTATS_HIVE_IO_MAX_TIME;
          // maxHiveStatsItems_ is set to 11 
          // SQLSTATS_TABLE_ANSI_NAME
          hiveStatsItems_[2].str_value = new (getGlobals()->getDefaultHeap())
            char[ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES+1];
          hiveStatsItems_[2].str_max_len = ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES;
        }
        else
          initSqlStatsItems(hiveStatsItems_, maxHiveStatsItems_, TRUE);
        cliRC = SQL_EXEC_GetStatisticsItems(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                maxHiveStatsItems_,
                hiveStatsItems_);
        if (cliRC < 0)
        {
          step_ = HANDLE_ERROR_;
        }
        else
        {
          if (! isHeadingDisplayed_)
            step_ = DISPLAY_HIVE_STATS_HEADING_;
          else
            step_ = FORMAT_AND_RETURN_HIVE_STATS_;
        }
      }
      break;
    case GET_BMO_STATS_ENTRY_:
      {
        if (bmoStatsItems_ == NULL)
        {
          maxBMOStatsItems_ = 20;
          bmoStatsItems_ = new (getGlobals()->getDefaultHeap()) 
                  SQLSTATS_ITEM[maxBMOStatsItems_];
          initSqlStatsItems(bmoStatsItems_, maxBMOStatsItems_, FALSE);
          bmoStatsItems_[0].statsItem_id = SQLSTATS_TDB_ID;
          bmoStatsItems_[1].statsItem_id = SQLSTATS_TDB_NAME;
          bmoStatsItems_[2].statsItem_id = SQLSTATS_SCRATCH_OVERFLOW_MODE;
          bmoStatsItems_[3].statsItem_id = SQLSTATS_DOP;
          bmoStatsItems_[4].statsItem_id = SQLSTATS_TOPN;
          bmoStatsItems_[5].statsItem_id = SQLSTATS_BMO_PHASE;
          bmoStatsItems_[6].statsItem_id = SQLSTATS_INTERIM_ROW_COUNT;
          bmoStatsItems_[7].statsItem_id = SQLSTATS_OPER_CPU_TIME;
          bmoStatsItems_[8].statsItem_id = SQLSTATS_BMO_HEAP_USED;
          bmoStatsItems_[9].statsItem_id = SQLSTATS_BMO_HEAP_ALLOC;
          bmoStatsItems_[10].statsItem_id = SQLSTATS_BMO_HEAP_WM;
          bmoStatsItems_[11].statsItem_id = SQLSTATS_BMO_EST_MEMORY;
          bmoStatsItems_[12].statsItem_id = SQLSTATS_BMO_SPACE_BUFFER_SIZE;
          bmoStatsItems_[13].statsItem_id = SQLSTATS_BMO_SPACE_BUFFER_COUNT;
          bmoStatsItems_[14].statsItem_id = SQLSTATS_SCRATCH_FILE_COUNT;
          bmoStatsItems_[15].statsItem_id = SQLSTATS_SCRATCH_IO_SIZE;
          bmoStatsItems_[16].statsItem_id = SQLSTATS_SCRATCH_READ_COUNT;
          bmoStatsItems_[17].statsItem_id = SQLSTATS_SCRATCH_WRITE_COUNT;
          bmoStatsItems_[18].statsItem_id = SQLSTATS_SCRATCH_IO_TIME;
          bmoStatsItems_[19].statsItem_id = SQLSTATS_SCRATCH_IO_MAX_TIME;
                  
          // maxBMOStatsItems_ is set to 20 
          // TDB_NAME
          bmoStatsItems_[1].str_value = new (getGlobals()->getDefaultHeap())
                      char[MAX_TDB_NAME_LEN+1];
          bmoStatsItems_[1].str_max_len = MAX_TDB_NAME_LEN;
          // OVERFLOW_MODE
          bmoStatsItems_[2].str_value = new (getGlobals()->getDefaultHeap())
                      char[13];
          bmoStatsItems_[2].str_max_len = 12;
          // BMO_PHASE
          bmoStatsItems_[5].str_value = new (getGlobals()->getDefaultHeap())
                      char[12];
          bmoStatsItems_[5].str_max_len = 11;
        }
        else
          initSqlStatsItems(bmoStatsItems_, maxBMOStatsItems_, TRUE);
  
        cliRC = SQL_EXEC_GetStatisticsItems(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                maxBMOStatsItems_,
                bmoStatsItems_);
        if (cliRC < 0)
        {
          step_ = HANDLE_ERROR_;
        }
        else
        {
          if (! isBMOHeadingDisplayed_)
            step_ = DISPLAY_BMO_STATS_HEADING_;
          else
            step_ = FORMAT_AND_RETURN_BMO_STATS_;
        }
      }
      break;
    case DISPLAY_BMO_STATS_HEADING_:
      {
       if ((qparent_.up->getSize() - qparent_.up->getLength()) < 4)
	      return WORK_CALL_AGAIN;
       moveRowToUpQueue(" ");
       if (singleLineFormat()) {       
          sprintf(statsBuf_, "%5s%20s%5s%10s%10s%12s%20s%20s%20s%20s%20s%20s%20s%20s%10s%10s%20s%20s%20s%20s",
               "Id", "TDBName", "Mode", "DOP", "TopN", "BMOPhase", "InterimRowCount", "CPUTime",
                "BMOHeapUsed", "BMOHeapAllocated", "BMOHeapWM", "EstMemory", 
                "BMOSpaceBufSz","BMOSpaceBufCnt", "FileCnt", "ScrIOSize",
                "ScrIORead", "ScrIOWritten", "ScrIOTime", "ScrIOMaxTime");
          moveRowToUpQueue(statsBuf_);
       }
       else {
          sprintf(statsBuf_, "%5s%20s%20s%10s%10s%20s%20s%20s",
               "Id", "TDBName", "Mode", "DOP", "TopN", "BMOPhase", "InterimRowCount", "CPUTime");
          moveRowToUpQueue(statsBuf_);
        
          sprintf(statsBuf_, "%25s%20s%20s%20s%20s%20s",
                "BMOHeapUsed", "BMOHeapAllocated", "BMOHeapWM", "EstMemory",
                "BMOSpaceBufSz","BMOSpaceBufCnt");
          moveRowToUpQueue(statsBuf_);
       
          sprintf(statsBuf_, "%25s%20s%20s%20s%20s%20s",
                "ScrFileCnt", "ScrIOSize", "ScrIORead", "ScrIOWritten", "ScrIOTime", "ScrIOMaxTime");
          moveRowToUpQueue(statsBuf_);
        }
        isBMOHeadingDisplayed_ = TRUE;
        step_ = FORMAT_AND_RETURN_BMO_STATS_;
      }
      break;
    case FORMAT_AND_RETURN_BMO_STATS_:
      {
        const char *ofMode;
        Int32 dop = 1;
        for (; currStatsItemEntry_ < maxBMOStatsItems_; currStatsItemEntry_++)
        {
          i = (short)currStatsItemEntry_;
          if (bmoStatsItems_[i].error_code != 0)
            continue;
          switch (bmoStatsItems_[i].statsItem_id)
          {
          case SQLSTATS_TDB_ID:
            sprintf(statsBuf_, "%5ld", bmoStatsItems_[i].int64_value);
            break;
          case SQLSTATS_TDB_NAME:
            bmoStatsItems_[i].str_value[bmoStatsItems_[i].str_ret_len] = '\0';
            if (singleLineFormat_) 
               sprintf(&statsBuf_[strlen(statsBuf_)], " %19s", bmoStatsItems_[i].str_value);
            else 
               sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", bmoStatsItems_[i].str_value);
            break;
          case SQLSTATS_SCRATCH_OVERFLOW_MODE:
            ofMode = ExBMOStats::getScratchOverflowMode((Int16) bmoStatsItems_[i].int64_value);
            if (singleLineFormat_) 
               sprintf(&statsBuf_[strlen(statsBuf_)], "%5s", ofMode);
            else
               sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", ofMode);
            break;
          case SQLSTATS_DOP:
            dop = (Int32)bmoStatsItems_[i].int64_value;
            sprintf(&statsBuf_[strlen(statsBuf_)], "%10ld", bmoStatsItems_[i].int64_value);
            break;
          case SQLSTATS_TOPN:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%10s", Int64Val);
            break;
          case SQLSTATS_BMO_PHASE:
            bmoStatsItems_[i].str_value[bmoStatsItems_[i].str_ret_len] = '\0';
            if (singleLineFormat_) 
               sprintf(&statsBuf_[strlen(statsBuf_)], "%12s", bmoStatsItems_[i].str_value);
            else
               sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", bmoStatsItems_[i].str_value);
            break;
          case SQLSTATS_INTERIM_ROW_COUNT:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          case SQLSTATS_OPER_CPU_TIME:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            if (! singleLineFormat_) {
               if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
                  return rc;
            }
            break;
          case SQLSTATS_BMO_HEAP_USED:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            if (singleLineFormat_) 
               sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            else
               sprintf(statsBuf_, "%25s", Int64Val);
            break;
          case SQLSTATS_BMO_HEAP_ALLOC:
          case SQLSTATS_BMO_HEAP_WM:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          case SQLSTATS_BMO_EST_MEMORY:
            sprintf(formattedFloatVal, "%.6g",  bmoStatsItems_[i].double_value * dop);
            str_sprintf(&statsBuf_[strlen(statsBuf_)], "%-20s", formattedFloatVal);
            break;
          case SQLSTATS_BMO_SPACE_BUFFER_SIZE:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          case SQLSTATS_BMO_SPACE_BUFFER_COUNT:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            if (! singleLineFormat_) {
               if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
                  return rc;
            }
            break;
          case SQLSTATS_SCRATCH_FILE_COUNT:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            if (singleLineFormat_) 
               sprintf(&statsBuf_[strlen(statsBuf_)], "%10s", Int64Val);
            else
               sprintf(statsBuf_, "%25s", Int64Val);
            break;
          case SQLSTATS_SCRATCH_IO_SIZE:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            if (singleLineFormat_) 
               sprintf(&statsBuf_[strlen(statsBuf_)], "%10s", Int64Val);
            else
               sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          case SQLSTATS_SCRATCH_READ_COUNT:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          case SQLSTATS_SCRATCH_WRITE_COUNT:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          case SQLSTATS_SCRATCH_IO_TIME:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            break;
          case SQLSTATS_SCRATCH_IO_MAX_TIME:
            sprintf(Int64Val, "%ld", bmoStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(&statsBuf_[strlen(statsBuf_)], "%20s", Int64Val);
            if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
              return rc;
            break;
          default:
            break;
          }
        }
        step_ = GET_NEXT_STATS_DESC_ENTRY_;
      }
      break;
    case GET_REPLICATE_STATS_ENTRY_:
      {
        if (replicateStatsItems_ == NULL)
        {
          maxReplicateStatsItems_ = 31;
          replicateStatsItems_ = new (getGlobals()->getDefaultHeap())
                  SQLSTATS_ITEM[maxReplicateStatsItems_];
          initSqlStatsItems(replicateStatsItems_, maxReplicateStatsItems_, FALSE);
          replicateStatsItems_[0].statsItem_id = SQLSTATS_REPL_ANSI_NAME;
          replicateStatsItems_[1].statsItem_id = SQLSTATS_REPL_SOURCE_SYSTEM;
          replicateStatsItems_[2].statsItem_id = SQLSTATS_REPL_TARGET_SYSTEM;
          replicateStatsItems_[3].statsItem_id = SQLSTATS_REPL_OBJECT_TYPE;
          replicateStatsItems_[4].statsItem_id = SQLSTATS_REPL_TYPE;
          replicateStatsItems_[5].statsItem_id = SQLSTATS_REPL_NUM_PARTNS;
          replicateStatsItems_[6].statsItem_id = SQLSTATS_REPL_CONCURRENCY;
          replicateStatsItems_[7].statsItem_id = SQLSTATS_REPL_PHASE0_START_TIME;
          replicateStatsItems_[8].statsItem_id = SQLSTATS_REPL_PHASE0_END_TIME;
          replicateStatsItems_[9].statsItem_id = SQLSTATS_REPL_PHASE0_ELAPSED_TIME;
          replicateStatsItems_[10].statsItem_id = SQLSTATS_REPL_PHASE1_START_TIME;
          replicateStatsItems_[11].statsItem_id = SQLSTATS_REPL_PHASE1_END_TIME;
          replicateStatsItems_[12].statsItem_id = SQLSTATS_REPL_PHASE1_ELAPSED_TIME;
          replicateStatsItems_[13].statsItem_id = SQLSTATS_REPL_PHASE2_START_TIME;
          replicateStatsItems_[14].statsItem_id = SQLSTATS_REPL_PHASE2_END_TIME;
          replicateStatsItems_[15].statsItem_id = SQLSTATS_REPL_PHASE2_ELAPSED_TIME;
          replicateStatsItems_[16].statsItem_id = SQLSTATS_REPL_PHASE3_START_TIME;
          replicateStatsItems_[17].statsItem_id = SQLSTATS_REPL_PHASE3_END_TIME;
          replicateStatsItems_[18].statsItem_id = SQLSTATS_REPL_PHASE3_ELAPSED_TIME;
          replicateStatsItems_[19].statsItem_id = SQLSTATS_REPL_PHASE4_START_TIME;
          replicateStatsItems_[20].statsItem_id = SQLSTATS_REPL_PHASE4_END_TIME;
          replicateStatsItems_[21].statsItem_id = SQLSTATS_REPL_PHASE4_ELAPSED_TIME;
          replicateStatsItems_[22].statsItem_id = SQLSTATS_REPL_PHASE5_START_TIME;
          replicateStatsItems_[23].statsItem_id = SQLSTATS_REPL_PHASE5_END_TIME;
          replicateStatsItems_[24].statsItem_id = SQLSTATS_REPL_PHASE5_ELAPSED_TIME;
          replicateStatsItems_[25].statsItem_id = SQLSTATS_REPL_PHASE6_START_TIME;
          replicateStatsItems_[26].statsItem_id = SQLSTATS_REPL_PHASE6_END_TIME;
          replicateStatsItems_[27].statsItem_id = SQLSTATS_REPL_PHASE6_ELAPSED_TIME;
          replicateStatsItems_[28].statsItem_id = SQLSTATS_REPL_PERCENT_DONE;
          replicateStatsItems_[29].statsItem_id = SQLSTATS_REPL_STATUS;
          replicateStatsItems_[30].statsItem_id = SQLSTATS_REPL_COMPLETED_PARTNS;

          // maxReplicateStatsItems_ is set to 31
          // ANSI_NAME
          replicateStatsItems_[0].str_value = new (getGlobals()->getDefaultHeap())
                      char[ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES+1];
          replicateStatsItems_[0].str_max_len = ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES;
          // SOURCE_SYSTEM_NAME
          replicateStatsItems_[1].str_value = new (getGlobals()->getDefaultHeap())
                      char[24];
          replicateStatsItems_[1].str_max_len = 23;
          // TARGET_SYSTEM_NAME
          replicateStatsItems_[2].str_value = new (getGlobals()->getDefaultHeap())
                      char[24];
          replicateStatsItems_[2].str_max_len = 23;
          // OBJECT_TYPE
          replicateStatsItems_[3].str_value = new (getGlobals()->getDefaultHeap())
                      char[51];
          replicateStatsItems_[3].str_max_len = 50;
          // REPL_TYPE
          replicateStatsItems_[4].str_value = new (getGlobals()->getDefaultHeap())
                      char[51];
          replicateStatsItems_[4].str_max_len = 50;
          // STATUS
          replicateStatsItems_[29].str_value = new (getGlobals()->getDefaultHeap())
                      char[51];
          replicateStatsItems_[29].str_max_len = 50;
        }
        else
          initSqlStatsItems(replicateStatsItems_, maxReplicateStatsItems_, TRUE);

        cliRC = SQL_EXEC_GetStatisticsItems(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                maxReplicateStatsItems_,
                replicateStatsItems_);
        if (cliRC < 0)
          step_ = HANDLE_ERROR_;
        else
          step_ = FORMAT_AND_RETURN_REPLICATE_STATS_;
      }
      break;
   case FORMAT_AND_RETURN_REPLICATE_STATS_:
      {
        for (; currStatsItemEntry_ < maxReplicateStatsItems_; currStatsItemEntry_++)
        {
          i = (short)currStatsItemEntry_;
          if (replicateStatsItems_[i].error_code != 0)
            continue;
          switch (replicateStatsItems_[i].statsItem_id)
          {
          case SQLSTATS_REPL_ANSI_NAME:
            replicateStatsItems_[i].str_value[replicateStatsItems_[i].str_ret_len] = '\0';
            sprintf(statsBuf_, "%-25s%s", "Object Ansi Name", replicateStatsItems_[i].str_value);
            break;
          case SQLSTATS_REPL_SOURCE_SYSTEM:
            replicateStatsItems_[i].str_value[replicateStatsItems_[i].str_ret_len] = '\0';
            sprintf(statsBuf_, "%-25s%s", "Source System ", replicateStatsItems_[i].str_value);
            break;
          case SQLSTATS_REPL_TARGET_SYSTEM:
            replicateStatsItems_[i].str_value[replicateStatsItems_[i].str_ret_len] = '\0';
            sprintf(statsBuf_, "%-25s%s", "Target System ", replicateStatsItems_[i].str_value);
            break;
          case SQLSTATS_REPL_OBJECT_TYPE:
            replicateStatsItems_[i].str_value[replicateStatsItems_[i].str_ret_len] = '\0';
            sprintf(statsBuf_, "%-25s%s", "Object Type ", replicateStatsItems_[i].str_value);
            break;
          case SQLSTATS_REPL_TYPE:
            replicateStatsItems_[i].str_value[replicateStatsItems_[i].str_ret_len] = '\0';
            sprintf(statsBuf_, "%-25s%s", "Replicate Type ", replicateStatsItems_[i].str_value);
            break;
          case SQLSTATS_REPL_NUM_PARTNS:
            sprintf(statsBuf_, "%-25s%-ld", "Number of Partitions ", replicateStatsItems_[i].int64_value);
            break;
          case SQLSTATS_REPL_CONCURRENCY:
            sprintf(statsBuf_, "%-25s%-ld", "Replication Concurrency ", replicateStatsItems_[i].int64_value);
            break;
          case SQLSTATS_REPL_PHASE0_START_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase0 Start Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE0_END_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase0 End Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE0_ELAPSED_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase0 Elapsed Time", 
                      formatElapsedTime(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE1_START_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase1 Start Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE1_END_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase1 End Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE1_ELAPSED_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase1 Elapsed Time", 
                      formatElapsedTime(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE2_START_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase2 Start Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE2_END_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase2 End Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE2_ELAPSED_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase2 Elapsed Time", 
                      formatElapsedTime(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE3_START_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase3 Start Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE3_END_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase3 End Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE3_ELAPSED_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase3 Elapsed Time", 
                      formatElapsedTime(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE4_START_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase4 Start Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE4_END_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase4 End Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE4_ELAPSED_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase4 Elapsed Time", 
                      formatElapsedTime(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE5_START_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase5 Start Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE5_END_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase5 End Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE5_ELAPSED_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase5 Elapsed Time", 
                      formatElapsedTime(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE6_START_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase6 Start Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE6_END_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase6 End Time", 
                      formatTimestamp(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PHASE6_ELAPSED_TIME:
            if (replicateStatsItems_[i].int64_value == -1)
               continue;
            sprintf(statsBuf_, "%-25s%s", "Phase6 Elapsed Time", 
                      formatElapsedTime(timestampVal, replicateStatsItems_[i].int64_value));
            break;
          case SQLSTATS_REPL_PERCENT_DONE:
            formatWInt64(replicateStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s ", "Percent Done", Int64Val);
            break;
          case SQLSTATS_REPL_STATUS:
            replicateStatsItems_[i].str_value[replicateStatsItems_[i].str_ret_len] = '\0';
            sprintf(statsBuf_, "%-25s%s", "Replicate Status", replicateStatsItems_[i].str_value);
            break;
          case SQLSTATS_REPL_COMPLETED_PARTNS:
            sprintf(statsBuf_, "%-25s%-ld", "Replicated Partitions ", replicateStatsItems_[i].int64_value);
            break;
          default:
            statsBuf_[0] = '\0';
            break;
          }
          if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
            return rc;
        }
        step_ = GET_NEXT_STATS_DESC_ENTRY_;
      }
      break;
    case GET_REPLICATOR_STATS_ENTRY_:
      {
        if (replicatorStatsItems_ == NULL)
        {
          maxReplicatorStatsItems_ = 8;
          replicatorStatsItems_ = new (getGlobals()->getDefaultHeap())
                  SQLSTATS_ITEM[maxReplicatorStatsItems_];
          initSqlStatsItems(replicatorStatsItems_, maxReplicatorStatsItems_, FALSE);
          replicatorStatsItems_[0].statsItem_id = SQLSTATS_REPL_BLOCK_LEN;
          replicatorStatsItems_[1].statsItem_id = SQLSTATS_REPL_TOTAL_BLOCKS;
          replicatorStatsItems_[2].statsItem_id = SQLSTATS_REPL_BLOCKS_READ;
          replicatorStatsItems_[3].statsItem_id = SQLSTATS_REPL_ROWS_READ;
          replicatorStatsItems_[4].statsItem_id = SQLSTATS_REPL_BLOCKS_REPLICATED;
          replicatorStatsItems_[5].statsItem_id = SQLSTATS_REPL_TOTAL_COMPRESS_TIME;
          replicatorStatsItems_[6].statsItem_id = SQLSTATS_REPL_TOTAL_COMPRESS_BYTES;
          replicatorStatsItems_[7].statsItem_id = SQLSTATS_REPL_TOTAL_UNCOMPRESS_TIME;
        }
        else
          initSqlStatsItems(replicatorStatsItems_, maxReplicatorStatsItems_, TRUE);

        cliRC = SQL_EXEC_GetStatisticsItems(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                maxReplicatorStatsItems_,
                replicatorStatsItems_);
        if (cliRC < 0)
          step_ = HANDLE_ERROR_;
        else
          step_ = FORMAT_AND_RETURN_REPLICATOR_STATS_;
      }
      break;
    case FORMAT_AND_RETURN_REPLICATOR_STATS_:
      {
        for (; currStatsItemEntry_ < maxReplicatorStatsItems_; currStatsItemEntry_++)
        {
          i = (short)currStatsItemEntry_;
          if (replicatorStatsItems_[i].error_code != 0)
            continue;
          switch (replicatorStatsItems_[i].statsItem_id)
          {
          case SQLSTATS_REPL_BLOCK_LEN:
            formatWInt64(replicatorStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s ", "Block Length", Int64Val);
            break;
          case SQLSTATS_REPL_TOTAL_BLOCKS:
            formatWInt64(replicatorStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s ", "Total Blocks", Int64Val);
            break;
          case SQLSTATS_REPL_BLOCKS_READ:
            formatWInt64(replicatorStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s ", "Blocks Read", Int64Val);
            break;
          case SQLSTATS_REPL_ROWS_READ:
            formatWInt64(replicatorStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s ", "Rows Read", Int64Val);
            break;
          case SQLSTATS_REPL_BLOCKS_REPLICATED:
            formatWInt64(replicatorStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s ", "Blocks Replicated", Int64Val);
            break;
          case SQLSTATS_REPL_TOTAL_COMPRESS_TIME:
            formatWInt64(replicatorStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s ", "Total Compress Time", Int64Val);
            break;
          case SQLSTATS_REPL_TOTAL_COMPRESS_BYTES:
            formatWInt64(replicatorStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s ", "Total Compress Bytes", Int64Val);
            break;
          case SQLSTATS_REPL_TOTAL_UNCOMPRESS_TIME:
            formatWInt64(replicatorStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-25s%s ", "Total Uncompress Time", Int64Val);
            break;
          default:
            statsBuf_[0] = '\0';
            break;
          }
          if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
            return rc;
        }
        step_ = GET_NEXT_STATS_DESC_ENTRY_;
      }
      break;
    case GET_OPER_STATS_ENTRY_:
      {
       maxOperatorStatsItems_ = 13;
       if (operatorStatsItems_ == NULL)
        {
          operatorStatsItems_ = new (getGlobals()->getDefaultHeap()) 
                                            SQLSTATS_ITEM[maxOperatorStatsItems_];
          initSqlStatsItems(operatorStatsItems_, maxOperatorStatsItems_, FALSE);

          formatOperStatItems(operatorStatsItems_);                
        }
        else
        {
          // reset tdb_id and stats type
          for (i = 0; i < maxOperatorStatsItems_; i++)
          {
            operatorStatsItems_[i].tdb_id = sqlStatsDesc_[currStatsDescEntry_].tdb_id;
            operatorStatsItems_[i].stats_type = sqlStatsDesc_[currStatsDescEntry_].stats_type;            
          }
        }
        cliRC = SQL_EXEC_GetStatisticsItems(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                maxOperatorStatsItems_,
                operatorStatsItems_);
        if (cliRC < 0)
	{
	  step_ = HANDLE_ERROR_;
	}
        else
        {
          step_ = FORMAT_AND_RETURN_OPER_STATS_;
        }
      }
      break;

    case FORMAT_AND_RETURN_OPER_STATS_:
      {
      formatOperStats(operatorStatsItems_);	            
      if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
        return rc;
      step_ = GET_NEXT_STATS_DESC_ENTRY_;
      }
      break;
    case GET_RMS_STATS_ENTRY_:
      {
        if (rmsStatsItems_ == NULL)
        {
          maxRMSStatsItems_ = 34;
          rmsStatsItems_ = new (getGlobals()->getDefaultHeap()) 
                  SQLSTATS_ITEM[maxRMSStatsItems_];
          initSqlStatsItems(rmsStatsItems_, maxRMSStatsItems_, FALSE);
          rmsStatsItems_[0].statsItem_id = SQLSTATS_NODE_NAME;
          rmsStatsItems_[1].statsItem_id = SQLSTATS_CPU;
          rmsStatsItems_[2].statsItem_id = SQLSTATS_RMS_VER;
          rmsStatsItems_[3].statsItem_id = SQLSTATS_RMS_ENV_TYPE;
          rmsStatsItems_[4].statsItem_id = SQLSTATS_SSCP_PID;
          rmsStatsItems_[5].statsItem_id = SQLSTATS_SSCP_PRIORITY;
          rmsStatsItems_[6].statsItem_id = SQLSTATS_SSCP_TIMESTAMP;
          rmsStatsItems_[7].statsItem_id = SQLSTATS_SSMP_PID;
          rmsStatsItems_[8].statsItem_id = SQLSTATS_SSMP_PRIORITY;
          rmsStatsItems_[9].statsItem_id = SQLSTATS_SSMP_TIMESTAMP;
          rmsStatsItems_[10].statsItem_id = SQLSTATS_STORE_SRC_LEN;
          rmsStatsItems_[11].statsItem_id = SQLSTATS_STATS_HEAP_ALLOC;
          rmsStatsItems_[12].statsItem_id = SQLSTATS_STATS_HEAP_USED;
          rmsStatsItems_[13].statsItem_id = SQLSTATS_STATS_HEAP_HIGH_WM;
          rmsStatsItems_[14].statsItem_id = SQLSTATS_PROCESS_STATS_HEAPS;
          rmsStatsItems_[15].statsItem_id = SQLSTATS_PROCESSES_REGD;
          rmsStatsItems_[16].statsItem_id = SQLSTATS_QUERIES_REGD;
          rmsStatsItems_[17].statsItem_id = SQLSTATS_RMS_SEMAPHORE_PID;
          rmsStatsItems_[18].statsItem_id = SQLSTATS_SSCPS_OPENED;
          rmsStatsItems_[19].statsItem_id = SQLSTATS_SSCPS_DELETED_OPENS;
          rmsStatsItems_[20].statsItem_id = SQLSTATS_LAST_GC_TIME;
          rmsStatsItems_[21].statsItem_id = SQLSTATS_QUERIES_GCED_IN_LAST_RUN;
          rmsStatsItems_[22].statsItem_id = SQLSTATS_TOTAL_QUERIES_GCED;
          rmsStatsItems_[23].statsItem_id = SQLSTATS_SSMP_REQ_MSG_CNT;
          rmsStatsItems_[24].statsItem_id = SQLSTATS_SSMP_REQ_MSG_BYTES;
          rmsStatsItems_[25].statsItem_id = SQLSTATS_SSMP_REPLY_MSG_CNT;
          rmsStatsItems_[26].statsItem_id = SQLSTATS_SSMP_REPLY_MSG_BYTES;
          rmsStatsItems_[27].statsItem_id = SQLSTATS_SSCP_REQ_MSG_CNT;
          rmsStatsItems_[28].statsItem_id = SQLSTATS_SSCP_REQ_MSG_BYTES;
          rmsStatsItems_[29].statsItem_id = SQLSTATS_SSCP_REPLY_MSG_CNT;
          rmsStatsItems_[30].statsItem_id = SQLSTATS_SSCP_REPLY_MSG_BYTES;
          rmsStatsItems_[31].statsItem_id = SQLSTATS_RMS_STATS_RESET_TIMESTAMP;
          rmsStatsItems_[32].statsItem_id = SQLSTATS_RMS_STATS_NUM_SQL_SIK;
          rmsStatsItems_[33].statsItem_id = SQLSTATS_RMS_CONFIGURED_PID_MAX;
          // maxRMSStatsItems_ is set to 34
          rmsStatsItems_[0].str_value = new (getGlobals()->getDefaultHeap())
            char[MAX_SEGMENT_NAME_LEN+1];
          rmsStatsItems_[0].str_max_len = MAX_SEGMENT_NAME_LEN;
        }
        else
          initSqlStatsItems(rmsStatsItems_, maxRMSStatsItems_, TRUE);

        cliRC = SQL_EXEC_GetStatisticsItems(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                maxRMSStatsItems_,
                rmsStatsItems_);
        if (cliRC < 0)
        {
          step_ = HANDLE_ERROR_;
        }
        else
          step_ = FORMAT_AND_RETURN_RMS_STATS_;
      }
      break;
    case FORMAT_AND_RETURN_RMS_STATS_:
      {
        for (; currStatsItemEntry_ < maxRMSStatsItems_; currStatsItemEntry_++)
        {
          i = (short)currStatsItemEntry_;
          statsBuf_[0] = '\0';
          if (rmsStatsItems_[i].error_code != 0)
            continue;
          switch (rmsStatsItems_[i].statsItem_id)
          {
          case SQLSTATS_NODE_NAME:
            rmsStatsItems_[i].str_value[rmsStatsItems_[i].str_ret_len] = '\0';
            sprintf(statsBuf_, "%-30s%s", "Node name", rmsStatsItems_[i].str_value);
            break;
          case SQLSTATS_CPU:
            sprintf(statsBuf_, "%-30s%-ld", "Node Id",  rmsStatsItems_[i].int64_value);
            break;  
          case SQLSTATS_RMS_VER:
            sprintf(statsBuf_, "%-30s%-ld", "RMS Version",  rmsStatsItems_[i].int64_value);
            break;  
          case SQLSTATS_RMS_ENV_TYPE:
            if ((StatsGlobals::RTSEnvType)rmsStatsItems_[i].int64_value == StatsGlobals::RTS_PRIVATE_ENV)
              sprintf(statsBuf_, "%-30s%s", "RMS Env Type",  
                StatsGlobals::rmsEnvType((StatsGlobals::RTSEnvType)rmsStatsItems_[i].int64_value));
            else
              continue;
            break;          
          case SQLSTATS_SSCP_PID:
            sprintf(statsBuf_, "%-30s%-ld", "SSCP PID",  rmsStatsItems_[i].int64_value);
            break;          
          case SQLSTATS_SSCP_TIMESTAMP:
	    jtime = CONVERTTIMESTAMP(rmsStatsItems_[i].int64_value,0,-1,NULL);
	    INTERPRETTIMESTAMP(jtime, timestamp);
	    sprintf(statsBuf_, "%-30s%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                        "SSCP Creation Timestamp ",
			timestamp[0], timestamp[1], timestamp[2],
			timestamp[3], timestamp[4], timestamp[5],
			timestamp[6], timestamp[7]);
	    break;
          case SQLSTATS_SSMP_PID:
            sprintf(statsBuf_, "%-30s%-ld", "SSMP PID",  rmsStatsItems_[i].int64_value);
            break;          
          case SQLSTATS_SSMP_TIMESTAMP:
	    jtime = CONVERTTIMESTAMP(rmsStatsItems_[i].int64_value,0,-1,NULL);
	    INTERPRETTIMESTAMP(jtime, timestamp);
	    sprintf(statsBuf_, "%-30s%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                        "SSMP Creation Timestamp ",
			timestamp[0], timestamp[1], timestamp[2],
			timestamp[3], timestamp[4], timestamp[5],
			timestamp[6], timestamp[7]);
	    break;
          case SQLSTATS_STORE_SRC_LEN:
            sprintf(statsBuf_, "%-30s%-ld", "Source String Store Len",  rmsStatsItems_[i].int64_value);
            break;          
          case SQLSTATS_STATS_HEAP_ALLOC:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "Stats Heap Allocated", Int64Val);
            break;
          case SQLSTATS_STATS_HEAP_USED:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "Stats Heap Used", Int64Val);
            break;
          case SQLSTATS_STATS_HEAP_HIGH_WM:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "Stats Heap High WM", Int64Val);
            break;
          case SQLSTATS_PROCESS_STATS_HEAPS:
            sprintf(statsBuf_, "%-30s%-ld", "No.of Process Stats Heaps",  rmsStatsItems_[i].int64_value);
            break;
          case SQLSTATS_PROCESSES_REGD:
            sprintf(statsBuf_, "%-30s%-ld", "No.of Process Regd.",  rmsStatsItems_[i].int64_value);
            break;
          case SQLSTATS_QUERIES_REGD:
            sprintf(statsBuf_, "%-30s%-ld", "No.of Query Fragments Regd.",  rmsStatsItems_[i].int64_value);
            break;
          case SQLSTATS_RMS_SEMAPHORE_PID:
            sprintf(statsBuf_, "%-30s%-ld", "RMS Semaphore Owner",  rmsStatsItems_[i].int64_value);
            break;
          case SQLSTATS_RMS_STATS_NUM_SQL_SIK:
            sprintf(statsBuf_, "%-30s%-ld", "No. Query Invalidation Keys", rmsStatsItems_[i].int64_value);
            break;
          case SQLSTATS_SSCPS_OPENED:
            sprintf(statsBuf_, "%-30s%-ld", "No.of SSCPs Opened",  rmsStatsItems_[i].int64_value);
            break;  
          case SQLSTATS_SSCPS_DELETED_OPENS:
            sprintf(statsBuf_, "%-30s%-ld", "No.of SSCPs Open Deleted",  rmsStatsItems_[i].int64_value);
            break; 
          case SQLSTATS_LAST_GC_TIME:
	    jtime = CONVERTTIMESTAMP(rmsStatsItems_[i].int64_value,0,-1,NULL);
	    INTERPRETTIMESTAMP(jtime, timestamp);
	    sprintf(statsBuf_, "%-30s%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                        "Last GC Time ",
			timestamp[0], timestamp[1], timestamp[2],
			timestamp[3], timestamp[4], timestamp[5],
			timestamp[6], timestamp[7]);
	    break;
          case SQLSTATS_QUERIES_GCED_IN_LAST_RUN:
            sprintf(statsBuf_, "%-30s%-ld", "Queries GCed in Last Run",  rmsStatsItems_[i].int64_value);
            break; 
          case SQLSTATS_TOTAL_QUERIES_GCED:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "Total Queries GCed ",  Int64Val);
            break; 
          case SQLSTATS_SSMP_REQ_MSG_CNT:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "SSMP Request Message Count", Int64Val);
            break;
          case SQLSTATS_SSMP_REQ_MSG_BYTES:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "SSMP Request Message Bytes", Int64Val);
            break;
          case SQLSTATS_SSMP_REPLY_MSG_CNT:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "SSMP Reply Message Count", Int64Val);
            break;
          case SQLSTATS_SSMP_REPLY_MSG_BYTES:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "SSMP Reply Message Bytes", Int64Val);
            break;
          case SQLSTATS_SSCP_REQ_MSG_CNT:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "SSCP Request Message Count", Int64Val);
            break;
          case SQLSTATS_SSCP_REQ_MSG_BYTES:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "SSCP Request Message Bytes", Int64Val);
            break;
          case SQLSTATS_SSCP_REPLY_MSG_CNT:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "SSCP Reply Message Count", Int64Val);
            break;
          case SQLSTATS_SSCP_REPLY_MSG_BYTES:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            intSize = str_len(Int64Val);
            AddCommas(Int64Val,intSize); 
            sprintf(statsBuf_, "%-30s%s", "SSCP Reply Message Bytes", Int64Val);
            break;
          case SQLSTATS_RMS_STATS_RESET_TIMESTAMP:
	    jtime = CONVERTTIMESTAMP(rmsStatsItems_[i].int64_value,0,-1,NULL);
	    INTERPRETTIMESTAMP(jtime, timestamp);
	    sprintf(statsBuf_, "%-30s%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                        "RMS Stats Reset Timestamp ",
			timestamp[0], timestamp[1], timestamp[2],
			timestamp[3], timestamp[4], timestamp[5],
			timestamp[6], timestamp[7]);
	    break;
          case SQLSTATS_RMS_CONFIGURED_PID_MAX:
            sprintf(Int64Val, "%ld", rmsStatsItems_[i].int64_value);
            sprintf(statsBuf_, "%-30s%s", "Configured Pid Max", Int64Val);
            break;
          }
          if (strlen(statsBuf_) > 0)
            if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
              return rc;
        }
        // Leave a blank line between two CPUs RMS stats
        if (moveRowToUpQueue(" ", strlen(" "), &rc) == -1)
          return rc;
        step_ = GET_NEXT_STATS_DESC_ENTRY_;
      }
      break;
    case GET_UDR_BASE_STATS_ENTRY_:
     {
        if (udrbaseStatsItems_ == NULL)
        {
          maxUDRBaseStatsItems_ = 8;
          udrbaseStatsItems_ = new (getGlobals()->getDefaultHeap()) 
                  SQLSTATS_ITEM[maxUDRBaseStatsItems_];
          initSqlStatsItems(udrbaseStatsItems_, maxUDRBaseStatsItems_, FALSE);
          udrbaseStatsItems_[0].statsItem_id = SQLSTATS_TDB_ID;
          udrbaseStatsItems_[1].statsItem_id = SQLSTATS_UDR_CPU_BUSY_TIME;
          udrbaseStatsItems_[2].statsItem_id = SQLSTATS_RECENT_REQ_TS;
          udrbaseStatsItems_[3].statsItem_id = SQLSTATS_RECENT_REPLY_TS;
          udrbaseStatsItems_[4].statsItem_id = SQLSTATS_REQ_MSG_CNT;
          udrbaseStatsItems_[5].statsItem_id = SQLSTATS_REQ_MSG_BYTES;
          udrbaseStatsItems_[6].statsItem_id = SQLSTATS_REPLY_MSG_CNT;
          udrbaseStatsItems_[7].statsItem_id = SQLSTATS_REPLY_MSG_BYTES;
          // maxUDRBaseStatsItems_ is set to 8
        }
        else
          initSqlStatsItems(udrbaseStatsItems_, maxUDRBaseStatsItems_, TRUE);
  
        cliRC = SQL_EXEC_GetStatisticsItems(getStatsTdb().statsReqType_,
                getStatsTdb().stmtName_,
                getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
                maxUDRBaseStatsItems_,
                udrbaseStatsItems_);
        if (cliRC < 0)
        {
          step_ = HANDLE_ERROR_;
        }
        else
        {
          if (! isUDRBaseHeadingDisplayed_)
            step_ = DISPLAY_UDR_BASE_STATS_HEADING_;
          else
            step_ = FORMAT_AND_RETURN_UDR_BASE_STATS_;
        }
      }
      break;
    case DISPLAY_UDR_BASE_STATS_HEADING_:
      {
        if ((qparent_.up->getSize() - qparent_.up->getLength()) < 3)
	      return WORK_CALL_AGAIN;
        moveRowToUpQueue(" ");
        sprintf(statsBuf_, "%5s%-21s%-27s%-27s",
                "   Id", "UDR CPU Busy Time", "Recent Req.Timestamp", "Recent Reply Timestamp");
        moveRowToUpQueue(statsBuf_);
	sprintf(statsBuf_, "%-20s%-20s%-20s%-20s",
		"Req. Msg count", "Req. Msg Bytes", "Reply Msg Count", "Reply Msg Bytes");
        moveRowToUpQueue(statsBuf_);
        isUDRBaseHeadingDisplayed_ = TRUE;
        step_ = FORMAT_AND_RETURN_UDR_BASE_STATS_;
      }
      break;
    case FORMAT_AND_RETURN_UDR_BASE_STATS_:
      {
        for (; currStatsItemEntry_ < maxUDRBaseStatsItems_; currStatsItemEntry_++)
        {
          i = (short)currStatsItemEntry_;
          if (udrbaseStatsItems_[i].error_code != 0)
            continue;
          switch (udrbaseStatsItems_[i].statsItem_id)
          {
          case SQLSTATS_TDB_ID:
            sprintf(statsBuf_, "%5ld", udrbaseStatsItems_[i].int64_value);
            break;
          case SQLSTATS_UDR_CPU_BUSY_TIME:
            formatWInt64( udrbaseStatsItems_[i], Int64Val);
            sprintf(&statsBuf_[strlen(statsBuf_)], "%-21s", Int64Val);
            break;
          case SQLSTATS_RECENT_REQ_TS:
            if (udrbaseStatsItems_[i].int64_value == -1)
            {
              sprintf(&statsBuf_[strlen(statsBuf_)], "%-27s", " ");
            }
            else
            {
	      jtime = CONVERTTIMESTAMP(udrbaseStatsItems_[i].int64_value,0,-1,NULL);
	      INTERPRETTIMESTAMP(jtime, timestamp);
	      sprintf(&statsBuf_[strlen(statsBuf_)], " %04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                          timestamp[0], timestamp[1], timestamp[2],
			  timestamp[3], timestamp[4], timestamp[5],
                          timestamp[6], timestamp[7]);
            }
            break;
          case SQLSTATS_RECENT_REPLY_TS:
            if (udrbaseStatsItems_[i].int64_value == -1)
            {
              sprintf(&statsBuf_[strlen(statsBuf_)], "%-27s", " ");
            }
            else
            {
	      jtime = CONVERTTIMESTAMP(udrbaseStatsItems_[i].int64_value,0,-1,NULL);
	      INTERPRETTIMESTAMP(jtime, timestamp);
	      sprintf(&statsBuf_[strlen(statsBuf_)], " %04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
                          timestamp[0], timestamp[1], timestamp[2],
			  timestamp[3], timestamp[4], timestamp[5],
                          timestamp[6], timestamp[7]);
            }
            if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
              return rc;
            break;
          case SQLSTATS_REQ_MSG_CNT:
            formatWInt64( udrbaseStatsItems_[i], Int64Val);
            sprintf(statsBuf_, "%-20s", Int64Val);
            break;
          case SQLSTATS_REQ_MSG_BYTES:
            formatWInt64( udrbaseStatsItems_[i], Int64Val);
            sprintf(&statsBuf_[strlen(statsBuf_)], "%-20s", Int64Val);
            break;
          case SQLSTATS_REPLY_MSG_CNT:
            formatWInt64( udrbaseStatsItems_[i], Int64Val);
            sprintf(&statsBuf_[strlen(statsBuf_)], "%-20s", Int64Val);
            break;
          case SQLSTATS_REPLY_MSG_BYTES:
            formatWInt64( udrbaseStatsItems_[i], Int64Val);
            sprintf(&statsBuf_[strlen(statsBuf_)], "%-20s", Int64Val);
            if (moveRowToUpQueue(statsBuf_, strlen(statsBuf_), &rc) == -1)
              return rc;
            break;
          default:
            break;
          }
        }
        step_ = GET_NEXT_STATS_DESC_ENTRY_;
      }
      break;
    case HANDLE_ERROR_:
      {
        // SQL_EXEC_GetStatistics2 CLI call populates the diagnostics area
        // in context directly. However, ExHandleErrors will push this
        // into queue entry. CLI layer populates from queue into context
        // causing the errors to be displayed twice. Hence clear
        // Context diagnostics area here
        ComDiagsArea *diagsArea = currContext->getDiagsArea();
        ExHandleErrors(qparent_,
			        pentry_down,
			        0,
			        getGlobals(),
			        (diagsArea->getNumber() > 0 ? diagsArea : NULL),
			        (ExeErrorCode)cliRC,
			        NULL,
			        NULL
			        );
        if (diagsArea->getNumber() > 0)
           diagsArea->clear();
        step_ = DONE_;
      }
      break;
    case DONE_:
      {
	if (qparent_.up->isFull())
	  return WORK_OK;

	// Return EOF.
	ex_queue_entry * up_entry = qparent_.up->getTailEntry();
	
	up_entry->upState.parentIndex = 
	  pentry_down->downState.parentIndex;
	
	up_entry->upState.setMatchNo(0);
	up_entry->upState.status = ex_queue::Q_NO_DATA;
	
	// insert into parent
	qparent_.up->insert();
	
	//	    pstate.matches_ = 0;
	qparent_.down->removeHead();
	
        step_ = INITIAL_;
	return WORK_OK;
      }
      break;
    default:
      break;
    }
  } // while
}

char *ExExeUtilGetRTSStatisticsTcb::formatTimestamp(char *buf, Int64 inTime)
{
    Int64 jtime;
    short timestamp[8];

    if (inTime == -1)
       sprintf(buf, "%s", "-1");
    else if (inTime == 0)
       sprintf(buf, "%ld", inTime);
    else
    {
       jtime = CONVERTTIMESTAMP(inTime,0,-1,NULL);
       INTERPRETTIMESTAMP(jtime, timestamp);
       sprintf(buf, "%04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
               timestamp[0], timestamp[1], timestamp[2],
               timestamp[3], timestamp[4], timestamp[5],
               timestamp[6], timestamp[7]);
    }
    return buf;
}

char *ExExeUtilGetRTSStatisticsTcb::formatElapsedTime(char *buf, Int64 inTime)
{
   ULng32 sec = (ULng32) (inTime / 1000000);
   ULng32 usec = (ULng32) (inTime  % 1000000);
   ULng32 min = sec/60;
   sec = sec % 60;
   ULng32 hour = min/60;
   min = min % 60;

   sprintf (buf, "%4u:%02u:%02u.%06u",
                          hour, min, sec,usec);
   return buf;
}


////////////////////////////////////////////////////////////////////////
// Redefine virtual method allocatePstates, to be used by dynamic queue
// resizing, as well as the initial queue construction.
////////////////////////////////////////////////////////////////////////
ex_tcb_private_state * ExExeUtilGetRTSStatisticsTcb::allocatePstates(
     Lng32 &numElems,      // inout, desired/actual elements
     Lng32 &pstateLength)  // out, length of one element
{
  PstateAllocator<ExExeUtilGetRTSStatisticsPrivateState> pa;

  return pa.allocatePstates(this, numElems, pstateLength);
}

/////////////////////////////////////////////////////////////////////////////
// Constructor and destructor for ExExeUtilGetRTSStatisticsPrivateState
/////////////////////////////////////////////////////////////////////////////
ExExeUtilGetRTSStatisticsPrivateState::ExExeUtilGetRTSStatisticsPrivateState()
{
}

ExExeUtilGetRTSStatisticsPrivateState::~ExExeUtilGetRTSStatisticsPrivateState()
{
};


ex_tcb * ExExeUtilGetProcessStatisticsTdb::build(ex_globals * glob)
{
  ex_tcb * exe_util_tcb = NULL;

  exe_util_tcb = new(glob->getSpace()) ExExeUtilGetProcessStatisticsTcb(*this, glob);

  exe_util_tcb->registerSubtasks();

  return (exe_util_tcb);
}

////////////////////////////////////////////////////////////////
//// Constructor for class ExExeUtilGetProcessStatisticsTcb
/////////////////////////////////////////////////////////////////
ExExeUtilGetProcessStatisticsTcb::ExExeUtilGetProcessStatisticsTcb(
     const ComTdbExeUtilGetProcessStatistics & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilGetStatisticsTcb( exe_util_tdb, glob)
{
  step_ = INITIAL_;

  statsArea_ = NULL;
  processStats_ = NULL;
}

short ExExeUtilGetProcessStatisticsTcb::work()
{
  Lng32 cliRC = 0;
  char outBuf[1024];
  short timestamp[8];
  Int64 juliantimestamp;

  // if no parent request, return
  if (qparent_.down->isEmpty())
     return WORK_OK;

  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
     return WORK_OK;

  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getCliGlobals()->currContext();

  while (1)
  {
    switch (step_)
    {
      case INITIAL_:
       {
         statsArea_ = NULL;
         processStats_ = NULL;
         step_ = GET_PROCESS_STATS_AREA_;
       }
       break;
      case GET_PROCESS_STATS_AREA_:
       {
         cliRC = SQL_EXEC_GetStatisticsArea_Internal
            (getStatsTdb().statsReqType_,
             getStatsTdb().stmtName_,
             getStatsTdb().stmtName_ ? str_len(getStatsTdb().stmtName_) : 0,
             getStatsTdb().activeQueryNum_,
             getStatsTdb().statsMergeType_,
             statsArea_);

         if (cliRC < 0)
            step_ = HANDLE_ERROR_;
         else
            step_ = GET_PROCESS_STATS_ENTRY_;
       }
       break;
      case GET_PROCESS_STATS_ENTRY_:
       {
         processStats_ = (ExProcessStats *)
            ((ExStatisticsArea *)statsArea_)->get(ExOperStats::PROCESS_STATS,
                    _UNINITIALIZED_TDB_ID);
         if (processStats_ == NULL)
         {
            cliRC = -EXE_STAT_NOT_FOUND;
            step_ = HANDLE_ERROR_;
         }
         else
           step_ = FORMAT_AND_RETURN_PROCESS_STATS_;
       }
       break;
      case FORMAT_AND_RETURN_PROCESS_STATS_: 
       {
          if ((qparent_.up->getSize() - qparent_.up->getLength()) < 30)
             return -1;
          sprintf(outBuf, "Node Id:                      %d", 
             processStats_->getNid());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "PID                           %d", 
             processStats_->getPid());
          moveRowToUpQueue(outBuf);

          if (processStats_->getStartTime() == -1)
           strcpy(outBuf, "Start Time                    -1");
          else
          {
	     juliantimestamp = 
	         CONVERTTIMESTAMP(processStats_->getStartTime(),0,-1,0);

	     INTERPRETTIMESTAMP(juliantimestamp, timestamp);
	  sprintf(outBuf, "Start Time                    %04d/%02d/%02d %02d:%02d:%02d.%03u%03u",
			timestamp[0], timestamp[1], timestamp[2],
			timestamp[3], timestamp[4], timestamp[5],
			timestamp[6], timestamp[7]);
          }
	  moveRowToUpQueue(outBuf);

          sprintf(outBuf, "EXE Memory Allocated          %ld MB", 
               (processStats_->getExeMemAlloc() >> 20));
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "EXE Memory Used High WM       %ld MB", 
               (processStats_->getExeMemHighWM() >> 20));
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "EXE Memory Used               %ld MB", 
               (processStats_->getExeMemUsed() >> 20));
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "IPC Memory Allocated          %ld MB", 
               (processStats_->getIpcMemAlloc() >> 20));
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "IPC Memory Used High WM       %ld MB", 
               (processStats_->getIpcMemHighWM() >> 20));
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "IPC Memory Used               %ld MB", 
               (processStats_->getIpcMemUsed() >> 20));
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Static Stmt Count             %d", 
               processStats_->getStaticStmtCount());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Dynamic Stmt Count            %d", 
               processStats_->getDynamicStmtCount());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Open Stmt Count               %d", 
               processStats_->getOpenStmtCount());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Reclaimable Stmt Count        %d", 
               processStats_->getCloseStmtCount());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Reclaimed Stmt Count          %d", 
               processStats_->getReclaimStmtCount());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Total ESPs Started            %d", 
               processStats_->getNumESPsStarted());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Total ESPs Startup Completed  %d", 
               processStats_->getNumESPsStartupCompleted());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Total ESPs Error in Startup   %d", 
               processStats_->getNumESPsBad());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Total ESPs Deleted            %d", 
               processStats_->getNumESPsDeleted());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Num ESPs In Use               %d", 
               processStats_->getNumESPsInUse());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Num ESPs Free                 %d", 
               processStats_->getNumESPsFree());
          moveRowToUpQueue(outBuf);

          sprintf(outBuf, "Recent Qid                    %s", 
              ( processStats_->getRecentQid() ?
                processStats_->getRecentQid() : "NULL"));
          moveRowToUpQueue(outBuf);

          step_ = DONE_;
       }
       break;
     case HANDLE_ERROR_:         
       {
         ExHandleErrors(qparent_,
               pentry_down,
               0,
               getGlobals(),
               NULL,
               (ExeErrorCode)cliRC,
               NULL,
               NULL
             );
         step_ = DONE_;
       }
       break;
     case DONE_:
       {
         if (qparent_.up->isFull())
            return WORK_OK;
	 // Return EOF.
	 ex_queue_entry * up_entry = qparent_.up->getTailEntry();
	 up_entry->upState.parentIndex = 
	      pentry_down->downState.parentIndex;
	 up_entry->upState.setMatchNo(0);
	 up_entry->upState.status = ex_queue::Q_NO_DATA;
	 // insert into parent
	 qparent_.up->insert();
	 qparent_.down->removeHead();
	 step_ = INITIAL_;
	 return WORK_OK;
       }
       break;
     default:
       break;
    }
  }
}