/**********************************************************************
// @@@ 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:         ExExeUtilCli.cpp
 * Description:  
 *               
 *               
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */

//#include "ComCextdecs.h"
#include  "cli_stdh.h"
#include  "ex_stdh.h"
#include  "sql_id.h"
#include  "ComSqlId.h"
#include  "ExExeUtilCli.h"
OutputInfo::OutputInfo(Lng32 numEntries)
  : numEntries_(numEntries)
{
  
   ex_assert( numEntries <= MAX_OUTPUT_ENTRIES, "try to fetch more than max rows allowed");
  
   for (Int32 i = 0; i < numEntries_; i++)
    {
      data_[i] = NULL;
      len_[i] = 0;
    }
}

void OutputInfo::insert(Lng32 index, char * data)
{
  data_[index] = data;
}

void OutputInfo::insert(Lng32 index, char * data, Lng32 len)
{
  data_[index] = data;
  len_[index] = len;
}

void OutputInfo::insert(Lng32 index, char * data, Lng32 len, Lng32 type, Lng32 *indOffset , Lng32 *varOffset )
{
  data_[index] = data;
  len_[index] = len;
  type_[index] = type;
}

char * OutputInfo::get(Lng32 index)
{
  if (index < numEntries_)
    return data_[index];
  else
    return NULL;
}

short OutputInfo::get(Lng32 index, char* &data, Lng32 &len)
{
  if (index < numEntries_)
    {
      data = data_[index];
      len = len_[index];
      return 0;
    }

  return -1;
}

short OutputInfo::get(Lng32 index, char* &data, Lng32 &len, Lng32 &type, Lng32 *indOffset , Lng32 *varOffset )
{
  if (index < numEntries_)
    {
      data = data_[index];
      len = len_[index];
      type = type_[index];
      return 0;
    }

  return -1;
}

void OutputInfo::dealloc(CollHeap * heap)
{
  for (Int32 i = 0; i < numEntries_; i++)
    {
      if(data_[i] != NULL)
        NADELETEBASIC(data_[i], heap);
    }
}

/////////////////////////////////////////////////////////////////
// class ExeCliInterface
/////////////////////////////////////////////////////////////////
ExeCliInterface::ExeCliInterface(CollHeap * heap, Int32 isoMapping,
				 ContextCli * currContext,
                                 const char *parentQid)
     : heap_(heap),
       module_(NULL),
       stmt_(NULL),
       sql_src_(NULL),
       input_desc_(NULL),
       output_desc_(NULL),
       rs_input_maxsize_desc_(NULL),
       outputBuf_(NULL),
       inputBuf_(NULL),
       currContext_(currContext),
       moduleWithCK_(NULL),
       stmtWithCK_(NULL),
       sql_src_withCK_(NULL),
       input_desc_withCK_(NULL),
       output_desc_withCK_(NULL),
       outputBuf_withCK_(NULL),
       rsInputBuffer_(NULL),
       isoMapping_((Int32)SQLCHARSETCODE_ISO88591), // ISO_MAPPING=ISO88591
       parentQid_(parentQid),
       inputAttrs_(NULL),
       outputAttrs_(NULL),
       explainData_(NULL),
       explainDataLen_(0),
       flags_(0)
{
  if (parentQid_)
  {
    Int32 len = str_len(parentQid_);
    ex_assert( len >= ComSqlId::MIN_QUERY_ID_LEN, "parentQid too short.");
    ex_assert( len <= ComSqlId::MAX_QUERY_ID_LEN, "parentQid too long.");
    ex_assert( !str_cmp(parentQid_, COM_SESSION_ID_PREFIX, 4), 
               "invalid parentQid.");
  }  
}

ExeCliInterface::~ExeCliInterface()
{
   dealloc();
}

Lng32 ExeCliInterface::deallocStuff(SQLMODULE_ID * &module,
				SQLSTMT_ID * &stmt,
				SQLDESC_ID * &sql_src,
				SQLDESC_ID * &input_desc,
				SQLDESC_ID * &output_desc)
{
  if (sql_src)
    {
      SQL_EXEC_DeallocDesc(sql_src);
      NADELETEBASIC(sql_src, heap_);
      sql_src = NULL;
    }

  if (stmt)
    {
      SQL_EXEC_DeallocStmt(stmt);
      NADELETEBASIC(stmt, heap_);
      stmt = NULL;
    }

  if (input_desc)
    {
      SQL_EXEC_DeallocDesc(input_desc);
      NADELETEBASIC(input_desc, heap_);
      input_desc = NULL;
    }

  if (output_desc)
    {
      SQL_EXEC_DeallocDesc(output_desc);
      NADELETEBASIC(output_desc, heap_);
      output_desc = NULL;
    }

  if (module)
    {
      NADELETEBASIC(module, heap_);
      module = NULL;
    }

  if (rsInputBuffer_)
    {
      NADELETEBASIC(rsInputBuffer_, heap_);
      rsInputBuffer_ = NULL;
    }

  if (outputAttrs_)
    {
      NADELETEBASIC(outputAttrs_, heap_);
      outputAttrs_ = NULL;
    }

  if (outputBuf_)
    {
      NADELETEBASIC(outputBuf_, heap_);
      outputBuf_ = NULL;
    }

  return 0;
}

Lng32 ExeCliInterface::dealloc()
{
  return deallocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_);
}

void ExeCliInterface::clearGlobalDiags()
{
  SQL_EXEC_ClearDiagnostics(NULL);
}

Lng32 ExeCliInterface::allocStuff(SQLMODULE_ID * &module,
				  SQLSTMT_ID * &stmt,
				  SQLDESC_ID * &sql_src,
				  SQLDESC_ID * &input_desc,
				  SQLDESC_ID * &output_desc,
				  const char * stmtName
  )
{
  Lng32 retcode = 0;
  deallocStuff(module, stmt, sql_src, input_desc, output_desc);

  clearGlobalDiags();

  module = new(heap_) SQLMODULE_ID;
  init_SQLMODULE_ID(module);

  // Allocate a SQL statement
  stmt = new(heap_) SQLSTMT_ID;
  if (stmtName)
    {
      init_SQLSTMT_ID(stmt, SQLCLI_CURRENT_VERSION, stmt_name, module);
      stmt->identifier = 
	new(heap_) char[strlen(stmtName) +1];
      strcpy((char*)stmt->identifier, stmtName);
      stmt->identifier_len = (Lng32)strlen(stmtName);
    }
  else
    init_SQLSTMT_ID(stmt, SQLCLI_CURRENT_VERSION, stmt_handle, module);

  retcode = SQL_EXEC_AllocStmt(stmt, 0);
  if (retcode < 0)
    return retcode;

  // Allocate a descriptor which will hold the SQL statement source
  sql_src = new(heap_) SQLSTMT_ID;
  init_SQLDESC_ID(sql_src, SQLCLI_CURRENT_VERSION, desc_handle, module);

  retcode = SQL_EXEC_AllocDesc(sql_src, 1);
  if (retcode < 0)
    return retcode;

  retcode = SQL_EXEC_SetDescItem(sql_src, 1, SQLDESC_TYPE_FS,
				 REC_BYTE_V_ANSI, 0);
  if (retcode < 0)
    return retcode;

  // Allocate a descriptor which will hold the SQL statement input
  input_desc = new(heap_) SQLSTMT_ID;
  init_SQLDESC_ID(input_desc, SQLCLI_CURRENT_VERSION, desc_handle, module);

  retcode = SQL_EXEC_AllocDesc(input_desc, 1);
  if (retcode < 0)
    return retcode;

  // Allocate a descriptor which will hold the SQL statement output
  output_desc = new(heap_) SQLSTMT_ID;
  init_SQLDESC_ID(output_desc, SQLCLI_CURRENT_VERSION, desc_handle, module);

  retcode = SQL_EXEC_AllocDesc(output_desc, 1);
  if (retcode < 0)
    return retcode;

  return 0;
}

Lng32 ExeCliInterface::prepare(const char * stmtStr,
                              SQLMODULE_ID * module,
                              SQLSTMT_ID * stmt,
                              SQLDESC_ID * sql_src,
                              SQLDESC_ID * input_desc,
                              SQLDESC_ID * output_desc,
                              char ** outputBuf,
                              Queue * outputVarPtrList,
                              char ** inputBuf,
                              Queue * inputVarPtrList,
                              char *uniqueStmtId,
                              Lng32 *uniqueStmtIdLen,
                              SQL_QUERY_COST_INFO *query_cost_info, 
                              SQL_QUERY_COMPILER_STATS_INFO *comp_stats_info,
                              NABoolean monitorThis,
                              NABoolean doNotCachePlan)
{
  Lng32 retcode = 0;
  ULng32 prepFlags = 0;
  SQL_QUERY_COST_INFO local_query_cost_info;
  SQL_QUERY_COMPILER_STATS_INFO local_comp_stats_info;

  if (monitorThis)
    prepFlags |= PREPARE_MONITOR_THIS_QUERY;

  if ((currContext_) && (currContext_->getSessionDefaults()))
    {
      if(currContext_->getSessionDefaults()->callEmbeddedArkcmp())
	prepFlags |= PREPARE_USE_EMBEDDED_ARKCMP;
    }

  if (doNotCachePlan)
    {
      prepFlags |= PREPARE_NO_TEXT_CACHE;
      prepFlags |= PREPARE_DONT_CACHE;
    }

  retcode = SQL_EXEC_SetDescItem(sql_src, 1, SQLDESC_LENGTH,
				 strlen(stmtStr) + 1, 0);
  if (retcode != SUCCESS)
    return retcode;
  retcode = SQL_EXEC_SetDescItem(sql_src, 1, SQLDESC_VAR_PTR,
				 (Long)stmtStr, 0);
  if (retcode != SUCCESS)
    return retcode;

    retcode = SQL_EXEC_SetDescItem(sql_src, 1, SQLDESC_CHAR_SET,  
                                   (Int32)SQLCHARSETCODE_UTF8,0);
  if (retcode != SUCCESS)
    return retcode;

  char parentQid[ComSqlId::MAX_QUERY_ID_LEN + 1];
  char *pQidPtr = NULL;
  if (parentQid_)
  {
    // The parentQid_ is a const char *, but the CLI doesn't 
    // want a const char * arg, so convert it safely here.
    memset(parentQid, 0, sizeof(parentQid));
    memcpy(parentQid,  parentQid_, ComSqlId::MAX_QUERY_ID_LEN);
    pQidPtr = parentQid;
  }
  retcode = SQL_EXEC_SetStmtAttr(stmt, SQL_ATTR_PARENT_QID, 0, pQidPtr);
  if (retcode < 0)
    return retcode;

  // set parserflags to indicate that this is an internal query from exeutil
  NABoolean flagWasSetHere = FALSE;
  if (currContext_)
    {
      if (((currContext_->getSqlParserFlags() & 0x20000) == 0) &&
	  (NOT notExeUtilInternalQuery())) // this is an exeutil internal query. This is the default.
	{
	  flagWasSetHere = TRUE;
	  currContext_->setSqlParserFlags(0x20000); // INTERNAL_QUERY_FROM EXEUTIL
	}
    }
   
  if (uniqueStmtId == NULL)
    retcode = SQL_EXEC_Prepare2(stmt, sql_src,NULL,0,NULL,
				(query_cost_info?query_cost_info:&local_query_cost_info), 
				(comp_stats_info?comp_stats_info:&local_comp_stats_info),
				NULL,0,prepFlags);
  else
  {
    prepFlags |= PREPARE_STANDALONE_QUERY;
    retcode = SQL_EXEC_Prepare2(stmt, sql_src, NULL, 0, NULL,
				(query_cost_info?query_cost_info:&local_query_cost_info), 
				(comp_stats_info?comp_stats_info:&local_comp_stats_info),
				uniqueStmtId, uniqueStmtIdLen, prepFlags);
  }
  // reset internal exeutil query parserflags if it was set in this method.
  if ((currContext_) && (flagWasSetHere))
    currContext_->resetSqlParserFlags(0x20000); // INTERNAL_QUERY_FROM EXEUTIL

  // return the error code that was returned from SQL_EXEC_Prepare
  if (retcode < 0)
    return retcode;

  // clear diagnostics to reset any warnings.
  SQL_EXEC_ClearDiagnostics(NULL);

  Lng32 num_input_entries, num_output_entries;
  retcode = SQL_EXEC_DescribeStmt(stmt, input_desc, output_desc);
  if (retcode != SUCCESS)
    return retcode;
  
  retcode = SQL_EXEC_GetDescEntryCount(input_desc, &num_input_entries);
  if (retcode != SUCCESS)
    return retcode;

  retcode = SQL_EXEC_GetDescEntryCount(output_desc, &num_output_entries);
  if (retcode != SUCCESS)
    return retcode;

  numInputEntries_ = num_input_entries;
  numOutputEntries_ = num_output_entries;

  inputAttrs_ = NULL;
  outputAttrs_ = NULL;
  if (numInputEntries_ > 0)
    inputAttrs_ = (Attrs*) (new(heap_) char[sizeof(Attrs) * numInputEntries_]);

  if (numOutputEntries_ > 0)
    outputAttrs_ = (Attrs*) (new(heap_) char[sizeof(Attrs) * numOutputEntries_]);

  short entry=1;
  Lng32 datatype = 0;
  Lng32 datacharset = 0;
  Lng32 length = 0;
  Lng32 null_flag = 0;
  Lng32 dataOffset = -1;
  Lng32 nullIndOffset = -1;

  outputDatalen_ = 0;
  inputDatalen_ = 0;
  for (; entry <= num_output_entries; entry++)
    {
      retcode = SQL_EXEC_GetDescItem(output_desc, entry,
				     SQLDESC_TYPE_FS,
				     &datatype, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;

      retcode = SQL_EXEC_GetDescItem(output_desc, entry,
				     SQLDESC_OCTET_LENGTH,
				     &length, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;

      retcode = SQL_EXEC_GetDescItem(output_desc, entry,
				     SQLDESC_NULLABLE,
				     &null_flag, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;

      retcode = SQL_EXEC_GetDescItem(output_desc, entry,
				     SQLDESC_CHAR_SET,
				     &datacharset, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;

      outputDatalen_ += length;
      if (null_flag)
	outputDatalen_ += SQL_NULL_HDR_SIZE;
      if (datatype == REC_BYTE_V_ASCII ||
	  datatype == REC_BYTE_V_ASCII_LONG ||
	  datatype == REC_BYTE_V_DOUBLE)
	outputDatalen_ += SQL_VARCHAR_HDR_SIZE;

      retcode = SQL_EXEC_GetDescItem(output_desc, entry,
				     SQLDESC_NULL_IND_OFFSET,
				     &nullIndOffset, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;
      
      retcode = SQL_EXEC_GetDescItem(output_desc, entry,
				     SQLDESC_DATA_OFFSET,
				     &dataOffset, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;
      
      outputAttrs_[entry-1].fsDatatype_ = datatype;
      outputAttrs_[entry-1].length_ = length;
      outputAttrs_[entry-1].nullFlag_ = null_flag;
      outputAttrs_[entry-1].indOffset_ = nullIndOffset;
      outputAttrs_[entry-1].varOffset_ = dataOffset;
    }

  if (outputBuf)
    {
      if ((*outputBuf == NULL) &&
	  (outputDatalen_ > 0))
	*outputBuf = new (heap_) char[outputDatalen_];
      
      Lng32 curpos = 0;
      for (entry=1; entry <= num_output_entries; entry++)
	{
	  retcode = SQL_EXEC_GetDescItem(output_desc, entry,
					 SQLDESC_NULLABLE,
					 &null_flag, 0, 0, 0, 0);
	  if (retcode != SUCCESS)
	    return retcode;
	  
	  if (null_flag)
	    {
	      retcode = SQL_EXEC_SetDescItem(output_desc, entry,
					     SQLDESC_IND_PTR,
					     (Long)&(*outputBuf)[curpos],0);
	      if (retcode != SUCCESS)
		return retcode;

	      curpos += SQL_NULL_HDR_SIZE;
	    }

	  retcode = SQL_EXEC_SetDescItem(output_desc, entry,
					 SQLDESC_VAR_PTR,
					 (Long)&(*outputBuf)[curpos],0);
	  if (retcode != SUCCESS)
	    return retcode;
	  
	  retcode = SQL_EXEC_GetDescItem(output_desc, entry,
					 SQLDESC_OCTET_LENGTH,
					 &length, 0, 0, 0, 0);

          if (outputVarPtrList)
          {
            outputVarPtrList->insert((char*) &(*outputBuf)[curpos]);
          }

	  curpos += length;
	  
	  retcode = SQL_EXEC_GetDescItem(output_desc, entry,
					 SQLDESC_TYPE_FS,
					 &datatype, 0, 0, 0, 0);
	  if (retcode != SUCCESS)
	    return retcode;
	  
	  retcode = SQL_EXEC_GetDescItem(output_desc, entry,
					 SQLDESC_CHAR_SET,
					 &datacharset, 0, 0, 0, 0);
	  if (retcode != SUCCESS)
	    return retcode;

	  if (datatype == REC_BYTE_V_ASCII ||
	      datatype == REC_BYTE_V_ASCII_LONG ||
	      datatype == REC_BYTE_V_DOUBLE)
	    curpos += SQL_VARCHAR_HDR_SIZE;

	}
    }

  entry=1;
  inputDatalen_ = 0;
  for (; entry <= num_input_entries; entry++)
    {
      Lng32 alignedLen = 0;
      retcode = SQL_EXEC_GetDescItem(input_desc, entry,
				     SQLDESC_ALIGNED_LENGTH,
				     &alignedLen, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;

      inputDatalen_ += alignedLen;

      retcode = SQL_EXEC_GetDescItem(input_desc, entry,
				     SQLDESC_TYPE_FS,
				     &datatype, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;

      retcode = SQL_EXEC_GetDescItem(input_desc, entry,
				     SQLDESC_OCTET_LENGTH,
				     &length, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;

      retcode = SQL_EXEC_GetDescItem(input_desc, entry,
				     SQLDESC_NULLABLE,
				     &null_flag, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;

      retcode = SQL_EXEC_GetDescItem(input_desc, entry,
				     SQLDESC_NULL_IND_OFFSET,
				     &nullIndOffset, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;
      
      retcode = SQL_EXEC_GetDescItem(input_desc, entry,
				     SQLDESC_DATA_OFFSET,
				     &dataOffset, 0, 0, 0, 0);
      if (retcode != SUCCESS)
	return retcode;
      
      inputAttrs_[entry-1].fsDatatype_ = datatype;
      inputAttrs_[entry-1].length_ = length;
      inputAttrs_[entry-1].nullFlag_ = null_flag;
      inputAttrs_[entry-1].indOffset_ = nullIndOffset;
      inputAttrs_[entry-1].varOffset_ = dataOffset;
    }

  if (inputBuf)
    {
      if ((*inputBuf == NULL) &&
	  (inputDatalen_ > 0))
	*inputBuf = new (heap_) char[inputDatalen_];
      
      Lng32 curpos = 0;
      for (entry=1; entry <= num_input_entries; entry++)
	{
	  retcode = SQL_EXEC_GetDescItem(input_desc, entry,
					 SQLDESC_NULL_IND_OFFSET,
					 &nullIndOffset, 0, 0, 0, 0);
	  if (retcode != SUCCESS)
	    return retcode;

	  retcode = SQL_EXEC_GetDescItem(input_desc, entry,
					 SQLDESC_DATA_OFFSET,
					 &dataOffset, 0, 0, 0, 0);
	  if (retcode != SUCCESS)
	    return retcode;

	  if (nullIndOffset >= 0)
	    {
	      retcode = SQL_EXEC_SetDescItem(input_desc, entry,
					     SQLDESC_IND_PTR,
					     (Long)&(*inputBuf)[nullIndOffset],0);
	      if (retcode != SUCCESS)
		return retcode;
	    }
	  
	  retcode = SQL_EXEC_SetDescItem(input_desc, entry,
					 SQLDESC_VAR_PTR,
					 (Long)&(*inputBuf)[dataOffset],0);
	  if (retcode != SUCCESS)
	    return retcode;
	}
    }

  return 0;
}

Lng32 ExeCliInterface::setupExplainData(SQLMODULE_ID * module,
                                        SQLSTMT_ID * stmt)
{
  Lng32 retcode = 0;

  if (explainData_)
    NADELETEBASIC(explainData_, getHeap());

  explainData_ = NULL;
  explainDataLen_ = 0;

  // get explain fragment.
  explainDataLen_ = 50000; // start with 50K bytes
  Int32 retExplainLen = 0;
  explainData_ = new(getHeap()) char[explainDataLen_+1];
  retcode = SQL_EXEC_GetExplainData(stmt,
                                    explainData_, explainDataLen_+1, 
                                    &retExplainLen
                                    );
  if (retcode == -CLI_GENCODE_BUFFER_TOO_SMALL)
    {
      NADELETEBASIC(explainData_, getHeap());

      explainDataLen_ = retExplainLen;
      explainData_ = new(getHeap()) char[explainDataLen_ + 1];

      retcode = SQL_EXEC_GetExplainData(stmt,
                                        explainData_, explainDataLen_+1, 
                                        &retExplainLen
                                        );
    }
  
  if (retcode != SUCCESS)
    {
      NADELETEBASIC(explainData_, getHeap());
      explainData_ = NULL;
      explainDataLen_ = 0;

      return retcode;
    }

  explainDataLen_ = retExplainLen;
  
  return retcode;
}

Lng32 ExeCliInterface::setupExplainData()
{
  return setupExplainData(module_, stmt_);
}


Lng32 ExeCliInterface::exec(char * inputBuf, Lng32 inputBufLen)
{
  Lng32 retcode = 0;

  if (! stmt_)
    {
      return -CLI_STMT_NOT_EXISTS;
    }

  // set parserflags to indicate that this is an internal query from exeutil
  NABoolean flagWasSetHere = FALSE;
  if (currContext_)
    {
      if (((currContext_->getSqlParserFlags() & 0x20000) == 0) &&
	  (NOT notExeUtilInternalQuery())) // this is an exeutil internal query. This is the default.
	{
	  flagWasSetHere = TRUE;
	  currContext_->setSqlParserFlags(0x20000); // INTERNAL_QUERY_FROM EXEUTIL
	}
    }

  if ((inputBuf) && (inputBuf_) && (inputDatalen_ > 0) && (inputBufLen > 0))
    memcpy(inputBuf_, inputBuf, MINOF(inputDatalen_, inputBufLen));

  retcode = SQL_EXEC_Exec(stmt_, input_desc_, 0);

  // reset internal exeutil query parserflags if it was set in this method.
   if ((currContext_) && (flagWasSetHere))
     currContext_->resetSqlParserFlags(0x20000); // INTERNAL_QUERY_FROM EXEUTIL

  if (retcode != SUCCESS)
    return retcode;
 
  return retcode;
}

Lng32 ExeCliInterface::fetch()
{
  Lng32 retcode = 0;

  retcode = SQL_EXEC_Fetch(stmt_, output_desc_, 0);
  if (retcode != SUCCESS)
    return retcode;
 
  return retcode;
}

//if indicator pointer is NULL, do not retrieve the indicator
//the datatype SQLTYPECODE... is added (the others did not work)
Lng32 ExeCliInterface::getPtrAndLen(short entry, char* &ptr, Lng32 &len, short**ind)
{
  Long data_addr;
  Lng32 datatype = 0;
  Lng32 retcode;
  Long ind_addr;

  retcode = SQL_EXEC_GetDescItem(output_desc_, entry,
				 SQLDESC_VAR_PTR,
				 &data_addr, 0, 0, 0, 0);
  if (retcode != SUCCESS)
    return retcode;
  
  retcode = SQL_EXEC_GetDescItem(output_desc_, entry,
		  		 SQLDESC_IND_PTR ,
			  	 &ind_addr, 0, 0, 0, 0);
  if (retcode != SUCCESS)
    return retcode;
  
  if (ind != NULL)
    *ind = (short*)ind_addr;
  
  retcode = SQL_EXEC_GetDescItem(output_desc_, entry,
				 SQLDESC_TYPE,
				 &datatype, 0, 0, 0, 0);
  if (retcode != SUCCESS)
    return retcode;
  
  retcode = SQL_EXEC_GetDescItem(output_desc_, entry,
				 SQLDESC_OCTET_LENGTH,
				 &len, 0, 0, 0, 0);
  if (retcode != SUCCESS)
    return retcode;

  short *nullIndPtr = (short *)ind_addr;
  if (nullIndPtr && *nullIndPtr < 0)  
    {
      // without this test, when "showddl component sql_operations"
      // ran some child query which returned a nullable column
      // with a SQL NULL value, junk from data_addr was interpreted
      // as a length and the caller of this method tried to allocate
      // too many bytes.
      len = 0;
    }
  else 
  if (datatype == REC_BYTE_V_ASCII ||
      datatype == REC_BYTE_V_ASCII_LONG ||
      datatype == REC_BYTE_V_DOUBLE ||
      datatype == SQLTYPECODE_VARCHAR_WITH_LENGTH ||
      datatype == SQLTYPECODE_VARCHAR_LONG ||
      datatype == SQLTYPECODE_BLOB ||
      datatype == SQLTYPECODE_CLOB
      )
    {

      // Depending on value of len, first 2 or 4 bytes of data indicate
      // the actual length -- adjust data and length
      if (len & 0xFFFF8000)
	{
	  Lng32 VClen;
	  str_cpy_all((char*)&VClen, (char*)data_addr, sizeof(Lng32));
	  data_addr += sizeof(Lng32);
	  len = VClen;
	}
      else
	{
	  short VClen;
	  str_cpy_all((char*)&VClen, (char*)data_addr, sizeof(short));
	  data_addr += sizeof(short);
	  len = VClen;
	}
    }

  ptr = (char*)data_addr;

  return 0;
}

Lng32 ExeCliInterface::getHeadingAndLen(short entry, char* heading, Lng32 &len)
{
  Lng32 retcode;

  len = 0;
  retcode = SQL_EXEC_GetDescItem(output_desc_, entry,
				 SQLDESC_HEADING,
				 0, heading,
				 ComMAX_1_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES, &len, 0);
  if (retcode != SUCCESS)
    return retcode;
  
  if (len == 0)
    {
      retcode = SQL_EXEC_GetDescItem(output_desc_, entry,
				     SQLDESC_NAME,
				     0, heading,
				     ComMAX_1_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES/*CAT_MAX_HEADING_LEN*/, &len, 0);
      if (retcode != SUCCESS)
	return retcode;
    }

  return 0;
}

Lng32 ExeCliInterface::getNumEntries(Lng32 &numInput, Lng32 &numOutput)
{
  Lng32 retcode = 0;

  retcode = SQL_EXEC_GetDescEntryCount(input_desc_, &numInput);
  if (retcode != SUCCESS)
    return retcode;

  retcode = SQL_EXEC_GetDescEntryCount(output_desc_, &numOutput);
  if (retcode != SUCCESS)
    return retcode;

  return retcode;
}


Lng32 ExeCliInterface::getAttributes(short entry, NABoolean forInput,
				    Lng32 &fsDatatype, Lng32 &length,
				    Lng32 *indOffset, Lng32 *varOffset)
{
  Lng32 retcode = 0;

  if (forInput)
    {
      fsDatatype = inputAttrs_[entry-1].fsDatatype_;
      length = inputAttrs_[entry-1].length_;
      if (indOffset)
	*indOffset = inputAttrs_[entry-1].indOffset_;
      if (varOffset)
	*varOffset = inputAttrs_[entry-1].varOffset_;
    }
  else
    {
      fsDatatype = outputAttrs_[entry-1].fsDatatype_;
      length = outputAttrs_[entry-1].length_;
      if (indOffset)
	*indOffset = outputAttrs_[entry-1].indOffset_;
      if (varOffset)
	*varOffset = outputAttrs_[entry-1].varOffset_;
    }

  return retcode;
}

Lng32 ExeCliInterface::getDataOffsets(short entry, Lng32 forInput,
				    Lng32 *indOffset, Lng32 *varOffset)
{
  Lng32 temp;
  if (forInput)
    {
      if (inputAttrs_ && inputAttrs_[entry-1].varOffset_ && inputAttrs_[entry-1].indOffset_)
	{
	  *varOffset = inputAttrs_[entry-1].varOffset_;
	  *indOffset = inputAttrs_[entry-1].indOffset_;
	}
      else
	{
	  return getAttributes(entry, forInput, temp, temp,
			       indOffset, varOffset);
	}
    }
  else
    {
      return getAttributes(entry, forInput, temp, temp,
			   indOffset, varOffset);
    }
  return 0;
}

Lng32 ExeCliInterface::getStmtAttr(char * stmtName, Lng32 attrName, 
				   Lng32 * numeric_value, char * string_value)
{
  Lng32 retcode = 0;
  
  SQLMODULE_ID module;
  init_SQLMODULE_ID(&module);
  
  char stmtNameBuf[400];
  SQLSTMT_ID stmt;
  init_SQLSTMT_ID(&stmt, SQLCLI_CURRENT_VERSION, stmt_name, &module);
  stmt.identifier = stmtNameBuf;
  strcpy((char*)stmt.identifier, stmtName);
  stmt.identifier_len = (Lng32)strlen(stmtName);
  
  retcode = SQL_EXEC_GetStmtAttr(&stmt, attrName, numeric_value, string_value,
				  0, NULL);
  
  return retcode;
}

Lng32 ExeCliInterface::close()
{
  Lng32 retcode = 0;

  if (stmt_)
    {
      retcode = SQL_EXEC_CloseStmt(stmt_);
      if (retcode != SUCCESS)
	return retcode;
    }

  return retcode;
}


Lng32 ExeCliInterface::executeImmediatePrepare(const char * stmtStr,
					       char * outputBuf,
					       Lng32 * outputBufLen,
					       Int64 * rowsAffected,
					       NABoolean monitorThis,
					       char * stmtName
					      )
{
  Lng32 retcode = 0;
  if (outputBufLen)
    *outputBufLen = 0;

  retcode = allocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_,
		       stmtName);
  if (retcode != SUCCESS)
    return retcode;

  retcode = prepare(stmtStr, module_, stmt_, sql_src_, 
		    input_desc_, output_desc_, &outputBuf,NULL,&inputBuf_,
		    NULL,NULL,NULL,NULL,NULL,monitorThis);
  if (retcode < 0)
    {
      deallocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_);
      return retcode;
    }
  
  return 0;
}

Lng32 ExeCliInterface::executeImmediatePrepare2(const char * stmtStr,
					     char *uniqueStmtId,
                                             Lng32 *uniqueStmtIdLen,
                                             SQL_QUERY_COST_INFO *query_cost_info,
                                             SQL_QUERY_COMPILER_STATS_INFO *comp_stats_info,
                                             char * outputBuf,
					     Lng32 * outputBufLen,
					     Int64 * rowsAffected,
					     NABoolean monitorThis
					     )
{
  Lng32 retcode = 0;

  if (outputBufLen)
    *outputBufLen = 0;

  retcode = allocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_);
  if (retcode != SUCCESS)
    return retcode;

  retcode = prepare(stmtStr, module_, stmt_, sql_src_, 
		    input_desc_, output_desc_, &outputBuf, NULL, NULL, NULL,
                    uniqueStmtId, uniqueStmtIdLen, query_cost_info, comp_stats_info,monitorThis);
  if (retcode < 0)
    {
      deallocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_);
      return retcode;
    }
  
  return 0;
}

Lng32 ExeCliInterface::executeImmediateExec(const char * stmtStr,
					   char * outputBuf,
					   Lng32 * outputBufLen,
					   NABoolean nullTerminate,
					   Int64 * rowsAffected,
                                           ComDiagsArea **diagsArea)
{
  Lng32 retcode = 0;
  Lng32 diagsCount = 0;

  retcode = exec();
  if (retcode < 0)
    {
      deallocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_);
      goto ExecReturn;
    }

  retcode = fetch();
  if (retcode < 0)
    {
      deallocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_);
      goto ExecReturn;
    }

  if ((outputBuf) &&
      (outputBufLen))
    {
      *outputBufLen = 0;
      if (retcode != 100)
	{
	  char * ptr;
	  Lng32 len;
	  getPtrAndLen(1, ptr, len);         
          str_cpy_all(outputBuf, ptr, len);
	  
	  if (nullTerminate)
	    outputBuf[len] = 0;
	  *outputBufLen = len;
	}
    }

  Lng32 rc;
  if (retcode >= 0)
  {
    if (rowsAffected)
    {
      Int64 tmpRowsAffected = 0;
      rc = SQL_EXEC_GetDiagnosticsStmtInfo2(NULL, SQLDIAG_ROW_COUNT,
        &tmpRowsAffected, NULL,
        0, NULL);

      if (rc == EXE_NUMERIC_OVERFLOW) 
      {
        GetRowsAffected(rowsAffected);
      }
      else
        *rowsAffected = tmpRowsAffected;
    }
    rc = SQL_EXEC_GetDiagnosticsStmtInfo2(NULL, SQLDIAG_NUMBER,
                       &diagsCount, NULL, 0, NULL);
    // No need to passback the warnings of SQL_NO_DATA (100)
    if (retcode == 100)
       diagsCount--; 
  }
ExecReturn:
  if (retcode < 0 ||  diagsCount > 0) 
  {   
     if (diagsArea != NULL) 
     {
         if (*diagsArea == NULL)
            *diagsArea = ComDiagsArea::allocate(heap_); 
         rc = SQL_EXEC_MergeDiagnostics_Internal(**diagsArea);
     }
     // if diagsArea is not passed in, retain the diagnostics info
     // in ContextCli for it to be retrieved later 
     // But, deallocate the statement
     else
     {
        rc = close();
        deallocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_);
        return retcode;
     }
  }
  rc = close();
  deallocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_);
  clearGlobalDiags();
  return retcode;
}
// When the globalDiags is not null, errors and warnings are
// passed to the caller. If *globalsDiags points to NULL,
// allocate ComDiagsArea and pass back the error or warnings
// to the caller.
// 
// If *globalDiags points to ComDiagsArea already, pass back
// the diagnostics conditions back to the caller after executing
// the stmtStr along with new errors or warnings.
Lng32 ExeCliInterface::executeImmediate(const char * stmtStr,
				       char * outputBuf,
				       Lng32 * outputBufLen,
				       NABoolean nullTerminate,
				       Int64 * rowsAffected,
				       NABoolean monitorThis,
				       ComDiagsArea **globalDiags)
{
  Lng32 retcode = 0;

  ComDiagsArea * tempDiags = NULL;
  if (globalDiags != NULL && *globalDiags != NULL && (*globalDiags)->getNumber() > 0)
  {
     tempDiags = ComDiagsArea::allocate(heap_);
     tempDiags->mergeAfter(**globalDiags);
  }

  clearGlobalDiags();
  outputBuf_ = NULL;
  inputBuf_ = NULL;
  retcode = executeImmediatePrepare(stmtStr, 
				    (nullTerminate ? outputBuf_ : outputBuf),
				    outputBufLen,
				    rowsAffected,monitorThis);
  if (retcode < 0) 
     goto ExecuteImmediateReturn;
  retcode = executeImmediateExec(stmtStr, 
				 outputBuf, outputBufLen,
				 nullTerminate,
				 rowsAffected,
                                 globalDiags);
ExecuteImmediateReturn:
  if ((globalDiags))
    {
      // Allocate the diagnostics area if needed
      // and populate the diagnostics conditions
      if (*globalDiags == NULL && retcode != 0 && retcode != 100) {
         *globalDiags = ComDiagsArea::allocate(getHeap());
         SQL_EXEC_MergeDiagnostics_Internal(**globalDiags);
      }
      //  populate the diagnostics conditons passed in
      if (tempDiags)
         (*globalDiags)->mergeAfter(*tempDiags);
    }

  if (tempDiags)
      tempDiags->deAllocate();
  return retcode;
}

short ExeCliInterface::fetchRowsPrologue(const char * sqlStrBuf, 
					 NABoolean noExec,
					 NABoolean monitorThis,
					 char * stmtName)
{
  Lng32 retcode;

  clearGlobalDiags();

  retcode = allocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_,
		       stmtName);
  if (retcode < 0)
    {
      //ex_assert(0, "Error in fetchRows");
      return (short)retcode;
    }

  outputBuf_ = NULL;
  inputBuf_ = NULL;
  retcode = prepare(sqlStrBuf, module_, stmt_, sql_src_,
		    input_desc_, output_desc_, &outputBuf_, NULL,
		    &inputBuf_, NULL,NULL,NULL,NULL,NULL,monitorThis);
  if (retcode < 0)
    {
      //ex_assert(0, "Error in fetchRows");
      return (short)retcode;
    }

  if (NOT noExec)
    {
      retcode = exec();
      if (retcode < 0)
	{
	  //ex_assert(0, "Error in fetchRows");
	  return (short)retcode;
	}
    }

  return 0;
}

short ExeCliInterface::fetchRowsEpilogue(const char * sqlStrBuf,
					 NABoolean noClose)
{
  if (NOT noClose)
    close();

  deallocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_);

  if (NOT noClose)
    SQL_EXEC_ClearDiagnostics(NULL);

  return 0;
}

short ExeCliInterface::initializeInfoList(Queue* &infoList,
					  NABoolean infoListIsOutputInfo)
{
  if (infoList)
    {
      infoList->position();
      while (NOT infoList->atEnd())
	{
	  if (infoListIsOutputInfo)
	    {
	      OutputInfo * r = (OutputInfo*)infoList->getCurr();
	      r->dealloc(getHeap());
	    }
	  else
	    {
	      char * c = (char*)infoList->getCurr();
	      NADELETEBASIC(c, getHeap());
	    }

	  infoList->advance();
	}
      NADELETE(infoList, Queue, getHeap());
    }
  
  infoList = new(getHeap()) Queue(getHeap());

  return 0;
}

short ExeCliInterface::fetchAllRows(Queue * &infoList, 
				    const char * query,
				    Lng32 inNumOutputEntries,
				    NABoolean varcharFormat,
				    NABoolean monitorThis,
				    NABoolean initInfoList)
{
  short rc = 0;

  Lng32 numOutputEntries = inNumOutputEntries;

  if (initInfoList)
    {
      rc = initializeInfoList(infoList, TRUE);
      if (rc < 0)
	{
	  return rc;
	}
    }

  rc = fetchRowsPrologue(query,FALSE,monitorThis);
  if (rc < 0)
    {
      return rc;
    }

  NABoolean rowsFound = FALSE;
  while ((rc >= 0) && 
	 (rc != 100))
    {
      rc = (short)fetch();
      if (rc < 0)
	{
	  fetchRowsEpilogue(0, TRUE);

	  return rc;
	}

      if (rc == 100)
	continue;

      rowsFound = TRUE;
      if (numOutputEntries == -1)
      {
	char * ob = new(getHeap()) char[outputDatalen()];
	str_cpy_all(ob, outputBuf(), 
		    outputDatalen());
	
	infoList->insert(ob);
      }
      else
      {
	if (numOutputEntries == 0)
	  numOutputEntries = numOutputEntries_;

	OutputInfo * oi = new(getHeap()) OutputInfo(numOutputEntries);
	
	for (Int32 j = 0; j < numOutputEntries; j++)
	{
	  char * ptr, *r;
	  Lng32   len;
          Lng32   type;
          short nulind=0;
          short *indaddr=&nulind;
          short **ind=&indaddr;
          getAttributes(j+1, FALSE, type, len, NULL, NULL);
	  getPtrAndLen(j+1, ptr, len, ind);
          NABoolean  nullableCol = TRUE, isNullVal = FALSE;
          if(*ind == NULL) // It is not a nullable value
            isNullVal = FALSE; 
          else
          {
            if( ((char*)*ind)[0] == -1 ) // NULL value
              isNullVal = TRUE;
          }
  
          if(isNullVal) 
          {
            oi->insert(j, NULL, 0, type);
          }
          else
          {
	    NABoolean nullTerminate = 
	    DFS2REC::is8bitCharacter(outputAttrs_[j].fsDatatype_);

	    r = new(getHeap()) char
	      [(varcharFormat ? SQL_VARCHAR_HDR_SIZE : 0) 
	       + len + (nullTerminate ? 1 : 0)];
	    if (varcharFormat)
	    {
	      *(short*)r = (short)len;
	      str_cpy_all(&r[SQL_VARCHAR_HDR_SIZE], ptr, len);

	      if (nullTerminate)
	        r[SQL_VARCHAR_HDR_SIZE + len] = 0;
	    }
	    else
	    {
	      str_cpy_all(r, ptr, len);
	      if (nullTerminate)
	        r[len] = 0;
	    }
	    oi->insert(j, r, len, type);
           }
	}
	
	infoList->insert(oi);
      }
    } // while

  rc = fetchRowsEpilogue(0);
  if (rc < 0)
    {
      return rc;
    }
  
  if (NOT rowsFound)
    rc = 100;

  return rc;
}

short ExeCliInterface::clearExecFetchClose(char * inputBuf,
					   Lng32 inputBufLen,

					   // ptr to buf where output values will be copied to. 
					   // Caller need to allocate this.
					   char * outputBuf, 
					   Lng32 * outputBufLen)
{
  Lng32 retcode = 0;

  SQL_EXEC_ClearDiagnostics(NULL);

  retcode = exec(inputBuf, inputBufLen);
  if (retcode < 0)
    {
      return (short)retcode;
    }

  retcode = fetch();
  if (retcode < 0)
    {
      return (short)retcode;
    }

  if ((outputBuf) &&
      (outputBufLen))
    {
      *outputBufLen = 0;
      if (retcode != 100)
	{
	  char * currPtr = outputBuf;
	  for (Int32 j = 0; j < numOutputEntries_; j++)
	    {
	      char * ptr;
	      Lng32   len;
	      getPtrAndLen(j+1, ptr, len);
	      
	      str_cpy_all(currPtr, ptr, len);
	      currPtr += len;

	      *outputBufLen += len;
	    }
	}
    }
  close(); 
  if (retcode == 100)
     fetchRowsEpilogue(NULL, TRUE); 
  return (short)retcode;
}

short ExeCliInterface::clearExecFetchCloseOpt(char * inputBuf,
					      Lng32 inputBufLen,
					      
					      // ptr to buf where output values will be copied to. 
					      // Caller need to allocate this.
					      char * outputBuf, 
					      Lng32 * outputBufLen,
                                              Int64 * rowsAffected)
{
  Lng32 retcode = 0;

  if (inputBuf)
    {
      if (inputDatalen_ < inputBufLen)
        {
          // input data will not fit in inputBuf_.
          // return error.
          return -EXE_STRING_OVERFLOW;
        }

      str_cpy_all(inputBuf_, inputBuf, inputBufLen);
    }

  if (rowsAffected)
    *rowsAffected = 0;

  retcode = SQL_EXEC_ClearExecFetchClose(
					 stmt_, 
					 (numInputEntries_ > 0 ? input_desc_ : NULL),
					 (numOutputEntries_ > 0 ? output_desc_ : NULL),
					 0, 0, 0);
  
  if ((retcode == 0) ||
      ((retcode >= 0) && (retcode != 100)))
    {
      if ((numOutputEntries_ > 0) &&
          (outputBuf) &&
          (outputBufLen))
        {
          *outputBufLen = 0;
          
          char * currPtr = outputBuf;
          for (Int32 j = 0; j < numOutputEntries_; j++)
            {
              char * ptr;
              Lng32   len;
              getPtrAndLen(j+1, ptr, len);
              
              str_cpy_all(currPtr, ptr, len);
              currPtr += len;
              
              *outputBufLen += len;
            }
          
          if (rowsAffected)
            {
              *rowsAffected = 1;
            }
        } // values being returned
      else if (rowsAffected)
        {
          Lng32 tmpRowsAffected = 0;
          retcode = SQL_EXEC_GetDiagnosticsStmtInfo2(NULL, SQLDIAG_ROW_COUNT,
                                                     &tmpRowsAffected, NULL,
                                                     0, NULL);
          
          if(retcode == EXE_NUMERIC_OVERFLOW) // rowsAffected > LONG_MAX
            {
              GetRowsAffected(rowsAffected);
            }
          else
            *rowsAffected = (Int64)tmpRowsAffected;
        } // rowsAffected
    }

  return (short)retcode;
}

Lng32 ExeCliInterface::executeImmediateCEFC(const char * stmtStr,
                                            char * inputBuf,
                                            Lng32 inputBufLen,
                                            char * outputBuf,
                                            Lng32 * outputBufLen,
                                            Int64 * rowsAffected
                                            )
{
  Lng32 retcode = 0;


  clearGlobalDiags();

  outputBuf_ = NULL;
  inputBuf_ = NULL;
  retcode = executeImmediatePrepare(stmtStr, 
				    outputBuf,
				    outputBufLen,
				    rowsAffected);
  if (retcode < 0)
    goto ExecuteImmediateCEFCReturn;
  
  retcode = clearExecFetchCloseOpt(inputBuf, inputBufLen, NULL, NULL, rowsAffected);

ExecuteImmediateCEFCReturn:
  return retcode;
}

Lng32 ExeCliInterface::cwrsAllocStuff(SQLMODULE_ID * &module,
					SQLSTMT_ID * &stmt,
					SQLDESC_ID * &sql_src,
					SQLDESC_ID * &input_desc,
					SQLDESC_ID * &output_desc,
					SQLDESC_ID * &rs_input_maxsize_desc,
					const char * stmtName
  )
{
  Lng32 retcode = 0;

  retcode = cwrsDeallocStuff(module,
			       stmt,
			       sql_src,
			       input_desc,
			       output_desc,
			       rs_input_maxsize_desc);
  if (retcode < 0)
    {
      return (short)retcode;
    }

  retcode = allocStuff(module,
		       stmt,
		       sql_src,
		       input_desc,
		       output_desc);
  if (retcode < 0)
    {
      return (short)retcode;
    }

  // Allocate a descriptor to set input array maximum size
  rs_input_maxsize_desc = new(heap_) SQLSTMT_ID;
  init_SQLDESC_ID(rs_input_maxsize_desc, SQLCLI_CURRENT_VERSION, desc_handle, module);

  retcode = SQL_EXEC_AllocDesc(rs_input_maxsize_desc, 1);
  if (retcode < 0)
    return retcode;

  retcode = SQL_EXEC_SetDescItem(rs_input_maxsize_desc, 1, SQLDESC_TYPE,
				 SQLTYPECODE_INTEGER, NULL);
  if (retcode < 0)
    return retcode;

  retcode = SQL_EXEC_SetDescItem( rs_input_maxsize_desc,
				  1,  // entry #1, attr value.
				  SQLDESC_VAR_PTR, // what to set - host var addr
				  (long) &rsMaxsize_,  // Notice that output from CLI
				                // will be read from host var
                        			// rowset_size.
				  NULL);

  retcode = SQL_EXEC_SetStmtAttr(stmt,
                                 SQL_ATTR_INPUT_ARRAY_MAXSIZE,
                                 rsMaxsize_,
				 NULL);

  return retcode;
}
  
Lng32 ExeCliInterface::cwrsDeallocStuff(
  SQLMODULE_ID * &module,
  SQLSTMT_ID * &stmt,
  SQLDESC_ID * &sql_src,
  SQLDESC_ID * &input_desc,
  SQLDESC_ID * &output_desc,
  SQLDESC_ID * &rs_input_maxsize_desc)
{
  deallocStuff(module, stmt, sql_src, input_desc, output_desc);

  if (rs_input_maxsize_desc)
    {
      SQL_EXEC_DeallocDesc(rs_input_maxsize_desc);
      NADELETEBASIC(rs_input_maxsize_desc, heap_);
      rs_input_maxsize_desc = NULL;
    }

  return 0;
}
  
Lng32 ExeCliInterface::cwrsPrepare(const char * stmtStr,
				   Lng32 rs_maxsize, NABoolean monitorThis)
{
  Lng32 retcode = 0;

  rsMaxsize_ = rs_maxsize;
  retcode = cwrsAllocStuff(module_, stmt_, sql_src_, 
			     input_desc_, output_desc_,
                             rs_input_maxsize_desc_);
  if (retcode != SUCCESS)
    return retcode;

  retcode = prepare(stmtStr, module_, stmt_, sql_src_, 
		    input_desc_, output_desc_, NULL,NULL,NULL,NULL,
		    NULL,NULL,NULL,NULL,monitorThis);
  if (retcode < 0)
    {
      cwrsDeallocStuff(module_, stmt_, sql_src_, 
			 input_desc_, output_desc_,
			 rs_input_maxsize_desc_);
      return retcode;
    }
  
  numQuadFields_ = numInputEntries_;// + 1;
  quadFields_ = (SQLCLI_QUAD_FIELDS*)
    new (heap_) char[sizeof(SQLCLI_QUAD_FIELDS) * numQuadFields_];
  
  rsInputBuffer_ = new(heap_) char[rsMaxsize_ * inputDatalen_];

  Lng32 fsDatatype;
  Lng32 length;
  Lng32 indOffset = 0;
  Lng32 varOffset = 0;

  quadFields_[0].var_layout = 0;
  quadFields_[0].var_ptr = (void *)&currRSrow_;
  quadFields_[0].ind_layout = 0;
  quadFields_[0].ind_ptr = NULL; 

  Lng32 currOffset = 0;
  for (Lng32 entry = 2; entry <= numInputEntries_; entry++)
    {
      getAttributes(entry, TRUE,
		    fsDatatype, length,
		    &indOffset, &varOffset);
 
      quadFields_[entry-1].var_layout = length;
      quadFields_[entry-1].var_ptr = (void*)&rsInputBuffer_[currOffset];
      quadFields_[entry-1].ind_layout = 0;
      quadFields_[entry-1].ind_ptr = NULL;
      
      currOffset += length * rsMaxsize_;
    }

  currRSrow_ = 0;

  return 0;
}

Lng32 ExeCliInterface::cwrsExec(
  char * inputRow,
  Int32 inputRowLen,
  Int64 * rowsAffected)
{
  Lng32 retcode = 0;

  Int32    rowset_status[1];    // Has no functionality currently. 
                                //However it is part of RowsetSetDesc API

  if ((inputRow) && (currRSrow_ < rsMaxsize_))
    {
      Lng32 fsDatatype;
      Lng32 length;
      Lng32 indOffset = 0;
      Lng32 varOffset = 0;
      
      for (Lng32 entry = 2; entry <= numInputEntries_; entry++)
        {
	  getAttributes(entry, TRUE,
			fsDatatype, length,
			&indOffset, &varOffset);
	  
	  str_cpy_all((char*)((long)(quadFields_[entry-1].var_ptr) + 
			      currRSrow_*length),
		      &inputRow[varOffset], length);
	}

      currRSrow_++;
      return 0;
    }

  if ((inputRow == NULL) && (currRSrow_ == 0))
    return 0;

  retcode = SQL_EXEC_SETROWSETDESCPOINTERS(input_desc_,
                                           currRSrow_,
                                           rowset_status,
                                           1,
                                           numQuadFields_,
                                           quadFields_);
  if (retcode < 0)
    return retcode;

  retcode = exec();
  if (retcode < 0)
    return retcode;

  retcode = fetch();
  if (retcode < 0)
    return retcode;

  if (retcode >= 0)
  {
    if (rowsAffected)
    {
      Lng32 tmpRowsAffected = 0;
      retcode = SQL_EXEC_GetDiagnosticsStmtInfo2(NULL, SQLDIAG_ROW_COUNT,
        &tmpRowsAffected, NULL,
        0, NULL);

      if(retcode == EXE_NUMERIC_OVERFLOW) // rowsAffected > LONG_MAX
      {
        GetRowsAffected(rowsAffected);
      }
      else
        *rowsAffected = (Int64)tmpRowsAffected;

      retcode = 0;
    }
  }

  retcode = close();

  currRSrow_ = 0;

  // current input row has not been moved to the rowset buffer.
  // move the input row to the rowset buffer
  return cwrsExec(inputRow, inputRowLen, rowsAffected);
}

Lng32 ExeCliInterface::cwrsClose(Int64 * rowsAffected)
{
  Lng32 retcode = 0;

  if (rowsAffected)
    *rowsAffected = 0;

  retcode = cwrsExec(NULL, 0, rowsAffected);

  Lng32 retcode2 = cwrsDeallocStuff(module_, stmt_, sql_src_, 
                                    input_desc_, output_desc_,
                                    rs_input_maxsize_desc_);
  return retcode;
}

Lng32 ExeCliInterface::rwrsPrepare(const char * stmtStr, Lng32 rs_maxsize,NABoolean monitorThis)
{
  Lng32 retcode = 0;

  rsMaxsize_ = rs_maxsize;
  retcode = allocStuff(module_, stmt_, sql_src_, 
		       input_desc_, output_desc_);
  if (retcode != SUCCESS)
    return retcode;

  /*
  retcode = SQL_EXEC_SetStmtAttr(stmt_,
                                 SQL_ATTR_INPUT_ARRAY_MAXSIZE,
                                 rsMaxsize_,
				 NULL);
  if (retcode != SUCCESS)
    return retcode;
  */

  retcode = prepare(stmtStr, module_, stmt_, sql_src_, 
		    input_desc_, output_desc_, NULL,NULL,NULL,NULL,NULL,
		    NULL,NULL,NULL,monitorThis);
  if (retcode < 0)
    {
      deallocStuff(module_, stmt_, sql_src_, 
		   input_desc_, output_desc_);
      return retcode;
    }
  
  rsInputBuffer_ = new(heap_) char[rsMaxsize_ * inputDatalen_];

  retcode = SQL_EXEC_SetDescItem(input_desc_,0,SQLDESC_ROWSET_TYPE, 3, 0);
  
  retcode = SQL_EXEC_SetDescItem(input_desc_,0,SQLDESC_ROWWISE_ROWSET_PTR, 
				 (long)rsInputBuffer_, 0);

  retcode = SQL_EXEC_SetDescItem(input_desc_,0,SQLDESC_ROWWISE_ROWSET_ROW_LEN, 
				 inputDatalen_, 0);

  currRSrow_ = 0;

  return 0;
}

Lng32 ExeCliInterface::rwrsExec(
  char * inputRow,
  Int32 inputRowLen,
  Int64 * rowsAffected)
{
  Lng32 retcode = 0;

  clearGlobalDiags();

  if (rowsAffected)
    *rowsAffected = 0;

  if ((inputRow) && (currRSrow_ < rsMaxsize_))
    {
      str_cpy_all(&rsInputBuffer_[currRSrow_ * inputDatalen_], 
		  inputRow, inputRowLen);
      currRSrow_++;
      return 0;
    }

  if ((inputRow == NULL) && (currRSrow_ == 0))
    return 0;

  retcode = SQL_EXEC_SetDescItem(input_desc_, 0, SQLDESC_ROWWISE_ROWSET_SIZE, 
				 currRSrow_, 0);

  retcode = exec();
  if (retcode < 0)
    return retcode;

  retcode = fetch();
  if (retcode < 0)
    return retcode;

  Lng32 cliRetcode = -1;
  if (retcode >= 0)
  {
    cliRetcode = retcode;
    if (rowsAffected)
    {
      Lng32 tmpRowsAffected = 0;
      retcode = SQL_EXEC_GetDiagnosticsStmtInfo2(NULL, SQLDIAG_ROW_COUNT,
        &tmpRowsAffected, NULL,
        0, NULL);

      if(retcode == EXE_NUMERIC_OVERFLOW) // rowsAffected > LONG_MAX
      {
        GetRowsAffected(rowsAffected);
      }
      else
        *rowsAffected = (Int64)tmpRowsAffected;

      retcode = 0;
    }
  }

  currRSrow_ = 0;

  return retcode;
}

Lng32 ExeCliInterface::rwrsClose()
{
  Lng32 retcode = 0;

  retcode = rwrsExec(NULL, 0, NULL);

  close();

  deallocStuff(module_, stmt_, sql_src_, 
	       input_desc_, output_desc_);

  return retcode;
}

short ExeCliInterface::prepareAndExecRowsPrologue(const char * sqlInitialStrBuf,
                                                  char * sqlSecondaryStrBuf,
                                                  Queue* initialOutputVarPtrList,
                                                  Queue* secondaryOutputVarPtrList,
                                                  Int64   &rowsAffected,
						  NABoolean monitorThis)
{
  Lng32 retcode = 0;
  
  SQL_EXEC_ClearDiagnostics(NULL);
  retcode = allocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_);
  if (retcode < 0)
    return (short)retcode;

  // Prepare
  outputBuf_ = NULL;
  inputBuf_ = NULL;
  retcode = prepare(sqlInitialStrBuf, module_, stmt_, sql_src_,
		    input_desc_, output_desc_, &outputBuf_,
                    initialOutputVarPtrList, NULL,NULL,NULL,NULL,
		    NULL,NULL,monitorThis);
  if (retcode < 0)
    return (short)retcode;
  
  retcode = allocStuff(moduleWithCK_, stmtWithCK_, sql_src_withCK_,
                      input_desc_withCK_, output_desc_withCK_);
  if (retcode < 0)
    return (short)retcode;
  
  // Prepare
  outputBuf_withCK_ = NULL;
  retcode = prepare(sqlSecondaryStrBuf, moduleWithCK_, stmtWithCK_, sql_src_withCK_,
		    input_desc_withCK_, output_desc_withCK_, &outputBuf_withCK_,
		    secondaryOutputVarPtrList,NULL,NULL,NULL,NULL,
		    NULL,NULL,monitorThis);
  if (retcode < 0)
    return (short)retcode;
  
  // Ensure the input entries have the correct character set type
  retcode = setCharsetTypes();
  if (retcode < 0)
    return (short)retcode;
   
  retcode = SQL_EXEC_Exec(stmt_, input_desc_, 0);
  if (retcode < 0)
    return (short)retcode;
  
  Lng32 cliRetcode = -1;
  retcode = SQL_EXEC_Fetch(stmt_, output_desc_, 0);
  if (retcode < 0)
    return (short)retcode;
  
  if (retcode >=  0) // we continue for warnings (retcode > 0)
                     // and NO errors or warnings (retcode == 0)
  {
    cliRetcode = retcode; // save the retcode from cli fetch.
    setOutputPtrsAsInputPtrs(initialOutputVarPtrList, 0);

    Int64 tmpRowsAffected = 0;
    retcode = SQL_EXEC_GetDiagnosticsStmtInfo2(NULL, SQLDIAG_ROW_COUNT,
      &tmpRowsAffected, NULL,
      0, NULL);

    if(retcode == EXE_NUMERIC_OVERFLOW) // rowsAffected > LONG_MAX
    {
      GetRowsAffected(&rowsAffected);
    }
    else
      rowsAffected = tmpRowsAffected;
  }
  
  SQL_EXEC_ClearDiagnostics(NULL);
  
  retcode = SQL_EXEC_CloseStmt(stmt_);
  if (retcode < 0)
    return (short)retcode;
  
  // return the return code from the cli fetch if it succeded.
  if (cliRetcode != -1) 
    return (short) cliRetcode;
  else
    return (short) retcode;
}

short ExeCliInterface::execContinuingRows(Queue * continuingOutputVarPtrList,
                                          Int64   &rowsAffected)
{
  Lng32 retcode = 0;

  SQL_EXEC_ClearDiagnostics(NULL);
 
  retcode = SQL_EXEC_Exec(stmtWithCK_, input_desc_withCK_, 0);
  if (retcode < 0)
      return (short)retcode;

  Lng32 cliRetcode = -1;
  retcode = SQL_EXEC_Fetch(stmtWithCK_, output_desc_withCK_, 0);
  if (retcode < 0)
      return (short)retcode;

  if (retcode >= 0)
  {
    cliRetcode = retcode; // save the retcode from cli fetch.
    setOutputPtrsAsInputPtrs(continuingOutputVarPtrList, 0);

    Int64 tmpRowsAffected = 0;
    retcode = SQL_EXEC_GetDiagnosticsStmtInfo2(NULL, SQLDIAG_ROW_COUNT,
      &tmpRowsAffected, NULL,
      0, NULL);

    if(retcode == EXE_NUMERIC_OVERFLOW) // rowsAffected > LONG_MAX
    {
      GetRowsAffected(&rowsAffected);
    }
    else
      rowsAffected = tmpRowsAffected;
  }

  retcode = SQL_EXEC_CloseStmt(stmtWithCK_);
  if (retcode < 0)
      return (short)retcode;

  // return the return code from the cli fetch if it succeded.
  if (cliRetcode != -1) 
    return (short) cliRetcode;
  else
    return (short) retcode;
}

Lng32 ExeCliInterface::setCharsetTypes()
{
  Lng32 retcode = 0;
  Lng32 num_input_entries = 0;

  // Obtain the number of entries
  retcode = SQL_EXEC_GetDescEntryCount(input_desc_withCK_, &num_input_entries);

  if (retcode < 0)
    return (short)retcode;

  Lng32 data_charset = 0;

  for (Lng32 i = 1; i <= num_input_entries; i++)
  {
  
    retcode = SQL_EXEC_GetDescItem(output_desc_withCK_,
                                   i,
     			           SQLDESC_CHAR_SET,
				   &data_charset, 0, 0, 0, 0);
    if (retcode < 0)
      return (short)retcode;

    if (data_charset != SQLCHARSETCODE_UNKNOWN)  
      {
         retcode = SQL_EXEC_SetDescItem(input_desc_withCK_,
                                        i,
     			                SQLDESC_CHAR_SET,
				        data_charset, 0);
         if (retcode < 0)
	   return (short)retcode;
       }
   }

   return (short)retcode;
}

void ExeCliInterface::setOutputPtrsAsInputPtrs(Queue* outputVarPtrList,
                                                SQLDESC_ID * target_inputDesc)
{
    // Process the queue
    Int32 j = 1;
    outputVarPtrList->position();

    while (NOT outputVarPtrList->atEnd())
      {
        char * entry = (char*)outputVarPtrList->getCurr();
        SQL_EXEC_SetDescItem(input_desc_withCK_, j++,
                             SQLDESC_VAR_PTR, 
                             (Long)entry, 0);

        outputVarPtrList->advance();
      }

    return;
}

Lng32 ExeCliInterface::prepareAndExecRowsEpilogue()
{
  Lng32 retcode = 0;

  retcode = close();

  deallocStuff(module_, stmt_, sql_src_, input_desc_, output_desc_);

  if (stmtWithCK_)
    {
      retcode = SQL_EXEC_CloseStmt(stmtWithCK_);
    }

  deallocStuff(moduleWithCK_, stmtWithCK_,
               sql_src_withCK_, input_desc_withCK_, output_desc_withCK_);

  SQL_EXEC_ClearDiagnostics(NULL);

  return 0;
}

Lng32 ExeCliInterface::beginWork()
{
  return executeImmediate("begin work;");
}

Lng32 ExeCliInterface::commitWork()
{
  return executeImmediate("commit work waited;");
}

Lng32 ExeCliInterface::rollbackWork()
{
  return executeImmediate("rollback work;");
}

Lng32 ExeCliInterface::autoCommit(NABoolean v)
{
  if (v)
    return executeImmediate("set transaction autocommit ON;");
  else
    return executeImmediate("set transaction autocommit OFF;");
}

Lng32 ExeCliInterface::beginXn()
{
  return SQL_EXEC_Xact(SQLTRANS_BEGIN, 0);
}

Lng32 ExeCliInterface::commitXn()
{
  return SQL_EXEC_Xact(SQLTRANS_COMMIT, 0);
}

Lng32 ExeCliInterface::rollbackXn()
{
  return SQL_EXEC_Xact(SQLTRANS_ROLLBACK, 0);
}

Lng32 ExeCliInterface::statusXn()
{
  return SQL_EXEC_Xact(SQLTRANS_STATUS, NULL);
}

Lng32 ExeCliInterface::suspendXn()
{
  return SQL_EXEC_Xact(SQLTRANS_SUSPEND, 0);
}

Lng32 ExeCliInterface::resumeXn()
{
  return SQL_EXEC_Xact(SQLTRANS_RESUME, 0);
}

Lng32 ExeCliInterface::createContext(char * contextHandle)
{
  Lng32 rc = 0;
  rc = SQL_EXEC_CreateContext((SQLCTX_HANDLE*)contextHandle, NULL, FALSE);
  return rc;
}

Lng32 ExeCliInterface::switchContext(char * contextHandle)
{
  Lng32 rc = 0;
  rc = SQL_EXEC_SwitchContext(*(SQLCTX_HANDLE*)contextHandle, NULL);
  return rc;
}

Lng32 ExeCliInterface::currentContext(char * contextHandle)
{
  Lng32 rc = 0;
  rc = SQL_EXEC_CurrentContext((SQLCTX_HANDLE*)contextHandle);
  return rc;
}

Lng32 ExeCliInterface::deleteContext(char* contextHandle) // in buf contains context handle
{
  return SQL_EXEC_DeleteContext(*(SQLCTX_HANDLE*)contextHandle);
}

Lng32 ExeCliInterface::retrieveSQLDiagnostics(ComDiagsArea *toDiags)
{
  Lng32 retcode;
  ex_assert(toDiags != NULL, "ComDiagsArea is null");
  retcode = SQL_EXEC_MergeDiagnostics_Internal(*toDiags);
  SQL_EXEC_ClearDiagnostics(NULL);
  return retcode;
}


ComDiagsArea *ExeCliInterface::allocAndRetrieveSQLDiagnostics(ComDiagsArea *&toDiags)
{
  Lng32 retcode;
  NABoolean daAllocated = FALSE; 
  if (toDiags == NULL) { 
      toDiags = ComDiagsArea::allocate(heap_);
      daAllocated = TRUE;
  }

  retcode = SQL_EXEC_MergeDiagnostics_Internal(*toDiags);
  SQL_EXEC_ClearDiagnostics(NULL);
 
  if (retcode == 0)
     return toDiags;
  else {
     if (daAllocated)
        toDiags->decrRefCount();
     return NULL;
  }
}

Lng32 ExeCliInterface::GetRowsAffected(Int64 *rowsAffected)
{
	SQLDESC_ID *rowCountDesc = NULL;
	SQLMODULE_ID * module = NULL;

	Lng32 retcode = SUCCESS;
	NABoolean sqlWarning = FALSE;

	SQLDIAG_STMT_INFO_ITEM_ID sqlItem = SQLDIAG_ROW_COUNT;
	rowCountDesc = new(heap_) SQLDESC_ID;
	rowCountDesc->version = SQLCLI_CURRENT_VERSION;
	rowCountDesc->name_mode = desc_handle;
	module = new(heap_) SQLMODULE_ID;
	rowCountDesc->module = module;
	module->module_name = 0;
	module->charset = "ISO88591";
	module->module_name_len = 0;
	module->version = SQLCLI_CURRENT_VERSION;
	rowCountDesc->identifier = 0;
	rowCountDesc->handle = 0;
  
	// get number of rows affected
  
	retcode = SQL_EXEC_AllocDesc (rowCountDesc, 1);
 	retcode = SQL_EXEC_SetDescItem(rowCountDesc, 1,
					 SQLDESC_TYPE_FS, REC_BIN64_SIGNED, 0);
	retcode = SQL_EXEC_SetDescItem(rowCountDesc, 1,
					 SQLDESC_VAR_PTR, (Long)rowsAffected, 0);

	Lng32 *temp;
	temp = (Lng32 *) &sqlItem;
  
	retcode = SQL_EXEC_GetDiagnosticsStmtInfo(temp, rowCountDesc);

  // free up resources
	SQL_EXEC_DeallocDesc(rowCountDesc);

	return SUCCESS;

} // GetRowsAffected()

Lng32 ExeCliInterface::holdAndSetCQD(const char * defaultName, const char * defaultValue, ComDiagsArea *globalDiags)
{
  Lng32 cliRC;
  
  char buf[400];
  
  strcpy(buf, "control query default ");
  strcat(buf, defaultName);
  strcat(buf, " hold;");

  // hold the current value for defaultName
  cliRC = executeImmediate(buf, NULL, NULL, TRUE, NULL, 0,&globalDiags);
  if (cliRC < 0)
    {
      return cliRC;
    }

  // now set the new value for defaultName
  strcpy(buf, "control query default ");
  strcat(buf, defaultName);
  strcat(buf, " '");
  strcat(buf, defaultValue);
  strcat(buf, "';");
  cliRC = executeImmediate(buf, NULL, NULL, TRUE, NULL, 0,&globalDiags);
  if (cliRC < 0)
    {
      return cliRC;
    }

  return 0;
}


Lng32 ExeCliInterface::restoreCQD(const char * defaultName, ComDiagsArea *globalDiags)
{
  Lng32 cliRC;

  char buf[400];
  
  // remove this cqd from the cqd array
  strcpy(buf, "control query default ");
  strcat(buf, defaultName);
  strcat(buf, " reset;");
  cliRC = executeImmediate(buf, NULL, NULL, TRUE, NULL, 0,&globalDiags);
  if (cliRC < 0)
    {
      return cliRC;
    }

  // restore the saved cqd default value
  strcpy(buf, "control query default ");
  strcat(buf, defaultName);
  strcat(buf, " restore;");
  cliRC = executeImmediate(buf, NULL, NULL, TRUE, NULL, 0,&globalDiags);
  if (cliRC < 0)
    {
      return cliRC;
    }

  return 0;
}

Lng32 ExeCliInterface::getCQDval(const char * defaultName, 
				 char * val,
				 ComDiagsArea *globalDiags)

{
  Lng32 cliRC;

  char buf[400];
  
  strcpy(buf, "cqd showcontrol_show_all 'ON';");
  cliRC = executeImmediate(buf);
  if (cliRC < 0)
    {
      return cliRC;
    }

  char valBuf[4000];
  Lng32 valBufLen = 0;
  strcpy(buf, "showcontrol default ");
  strcat(buf, defaultName);
  strcat(buf, ", match full, no header;");

  cliRC = executeImmediate(buf, valBuf, &valBufLen);
  if (cliRC < 0)
    {
      strcpy(buf, "cqd showcontrol_show_all 'OFF';");
      executeImmediate(buf);

      return cliRC;
    }

  strcpy(val, valBuf);

  strcpy(buf, "cqd showcontrol_show_all 'OFF';");
  cliRC = executeImmediate(buf);

  return 0;
}

Lng32 ExeCliInterface::setCQS(const char * shape, ComDiagsArea *globalDiags)
{
  Lng32 cliRC;

  cliRC = executeImmediate(shape, NULL, NULL, TRUE, NULL, 0,&globalDiags);
  if (cliRC < 0)
    {
      return cliRC;
    }

  return 0;
}
  

Lng32 ExeCliInterface::resetCQS(ComDiagsArea * globalDiags)
{
  Lng32 cliRC;

  char buf[400];
  
  strcpy(buf, "control query shape cut ");
  cliRC = executeImmediate(buf, NULL, NULL, TRUE, NULL, 0,&globalDiags);
  if (cliRC < 0)
    {
      return cliRC;
    }

  return 0;
}
  
  
// methods for routine invocation

Lng32 ExeCliInterface::getRoutine(
     /* IN */     const char   *serializedInvocationInfo,
     /* IN */     Int32         invocationInfoLen,
     /* IN */     const char   *serializedPlanInfo,
     /* IN */     Int32         planInfoLen,
     /* IN */     Int32         language,
     /* IN */     Int32         paramStyle,
     /* IN */     const char   *externalName,
     /* IN */     const char   *containerName,
     /* IN */     const char   *externalPath,
     /* IN */     const char   *librarySqlName,
     /* OUT */    Int32        *handle,
     /* IN/OUT */ ComDiagsArea *diags)
{
  Lng32 retcode = 0;

  SQL_EXEC_ClearDiagnostics(NULL);

  retcode = SQL_EXEC_GetRoutine(
       serializedInvocationInfo,
       invocationInfoLen,
       serializedPlanInfo,
       planInfoLen,
       language,
       paramStyle,
       externalName,
       containerName,
       externalPath,
       librarySqlName,
       handle);

  if (retcode != 0 && diags)
    {
      SQL_EXEC_MergeDiagnostics_Internal(*diags);
      SQL_EXEC_ClearDiagnostics(NULL);
    }

  return retcode;
}

Lng32 ExeCliInterface::invokeRoutine(
     /* IN */     Int32         handle,
     /* IN */     Int32         phaseEnumAsInt,
     /* IN */     const char   *serializedInvocationInfo,
     /* IN */     Int32         invocationInfoLen,
     /* OUT */    Int32        *invocationInfoLenOut,
     /* IN */     const char   *serializedPlanInfo,
     /* IN */     Int32         planInfoLen,
     /* IN */     Int32         planNum,
     /* OUT */    Int32        *planInfoLenOut,
     /* IN */     char         *inputRow,
     /* IN */     Int32         inputRowLen,
     /* OUT */    char         *outputRow,
     /* IN */     Int32         outputRowLen,
     /* IN/OUT */ ComDiagsArea *diags)
{
  Lng32 retcode = 0;

  SQL_EXEC_ClearDiagnostics(NULL);

  retcode = SQL_EXEC_InvokeRoutine(
       handle,
       phaseEnumAsInt,
       serializedInvocationInfo,
       invocationInfoLen,
       invocationInfoLenOut,
       serializedPlanInfo,
       planInfoLen,
       planNum,
       planInfoLenOut,
       inputRow,
       inputRowLen,
       outputRow,
       outputRowLen);

  if (retcode != 0 && diags)
    {
      SQL_EXEC_MergeDiagnostics_Internal(*diags);
      SQL_EXEC_ClearDiagnostics(NULL);
    }

  return retcode;
}

Lng32 ExeCliInterface::getRoutineInvocationInfo(
     /* IN */     Int32         handle,
     /* IN/OUT */ char         *serializedInvocationInfo,
     /* IN */     Int32         invocationInfoMaxLen,
     /* OUT */    Int32        *invocationInfoLenOut,
     /* IN/OUT */ char         *serializedPlanInfo,
     /* IN */     Int32         planInfoMaxLen,
     /* IN */     Int32         planNum,
     /* OUT */    Int32        *planInfoLenOut,
     /* IN/OUT */ ComDiagsArea *diags)
{
  Lng32 retcode = 0;

  SQL_EXEC_ClearDiagnostics(NULL);

  retcode = SQL_EXEC_GetRoutineInvocationInfo(
       handle,
       serializedInvocationInfo,
       invocationInfoMaxLen,
       invocationInfoLenOut,
       serializedPlanInfo,
       planInfoMaxLen,
       planNum,
       planInfoLenOut);

  if (retcode != 0 && diags)
    {
      SQL_EXEC_MergeDiagnostics_Internal(*diags);
      SQL_EXEC_ClearDiagnostics(NULL);
    }

  return retcode;
}

Lng32 ExeCliInterface::putRoutine(
     /* IN */     Int32         handle,
     /* IN/OUT */ ComDiagsArea *diags)
{
  Lng32 retcode = 0;

  SQL_EXEC_ClearDiagnostics(NULL);

  retcode = SQL_EXEC_PutRoutine(
       handle);

  if (retcode != 0 && diags)
    {
      SQL_EXEC_MergeDiagnostics_Internal(*diags);
      SQL_EXEC_ClearDiagnostics(NULL);
    }

  return retcode;
}