/**********************************************************************
// @@@ 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:         <file>
 * Description:  
 *
 *
 * Created:      7/10/95
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */

#include "Platform.h"


#include <stdio.h>
#include <stdlib.h>

#include "exp_stdh.h"
#include "exp_clause_derived.h"
#include "exp_math_func.h"
#include "exp_function.h"
#include "ExpBitMuxFunction.h"
#include "ExpSequenceFunction.h"
#include "ExpLOB.h"
#include "wstr.h"

#define GenAssert(p, msg) if (!(p)) { NAAssert(msg, __FILE__ , __LINE__ ); };


///////////////////////////////////////////////////////////
// class ex_clause
///////////////////////////////////////////////////////////
void ex_clause::copyOperands(ex_clause* clause, Space* space)
{
  NABoolean showplan = (clause->getOperand() ?
                          clause->getOperand(0)->showplan() :
                          FALSE);

  Int32 numOperands = ((showplan) ? (2 * clause->getNumOperands()) :
                                   clause->getNumOperands());

  op_ = (AttributesPtr *)(space->allocateAlignedSpace(numOperands *
					sizeof(AttributesPtr)));

  for (Int32 i=0; i < numOperands; i++) {
    Attributes* attrOld = clause->getOperand(i);
    Attributes* attrNew = NULL;
    
    if (attrOld != NULL) {
      Int32 size = attrOld->getClassSize();
      attrNew = (Attributes*) new(space) char[size];
      memcpy((char*)attrNew, (char*)attrOld, size);
    }

    op_[i] = attrNew;
  }

  switch(clause->getType()) {
    case ex_clause::INOUT_TYPE:
    {
      char* temp;
      Lng32 len;
      ex_inout_clause* inout = (ex_inout_clause*)this;

      // Copy strings associated with this class.  The strings being with a
      // a length count of size long, followed by the string itself.  Also,
      // remember that new() will automatically allocated an aligned space, so
      // nothing additional needs to be done here.

      if (inout->getHeading()) {
        len = sizeof(Lng32) + *((Lng32*)inout->getHeading());
        temp = new(space) char[len];
        memcpy(temp, inout->getHeading(), len);
        inout->setHeading(temp);
      }

      if (inout->getName()) {
        len = sizeof(Lng32) + *((Lng32*)inout->getName());
        temp = new(space) char[len];
        memcpy(temp, inout->getName(), len);
        inout->setName(temp);
      }

      if (inout->getTableName()) {
        len = sizeof(Lng32) + *((Lng32*)inout->getTableName());
        temp = new(space) char[len];
        memcpy(temp, inout->getTableName(), len);
        inout->setTableName(temp);
      }

      if (inout->getSchemaName()) {
        len = sizeof(Lng32) + *((Lng32*)inout->getSchemaName());
        temp = new(space) char[len];
        memcpy(temp, inout->getSchemaName(), len);
        inout->setSchemaName(temp);
      }

      if (inout->getCatalogName()) {
        len = sizeof(Lng32) + *((Lng32*)inout->getCatalogName());
        temp = new(space) char[len];
        memcpy(temp, inout->getCatalogName(), len);
        inout->setCatalogName(temp);
      }

      break;
    }

    case ex_clause::FUNCTION_TYPE:
      if (clause->getClassID() == ex_clause::FUNC_RAISE_ERROR_ID) {
        ExpRaiseErrorFunction* func = (ExpRaiseErrorFunction*)this;
        const char* cName = func->getConstraintName();
        const char* tName = func->getTableName();

        // Set contraint name
        if (cName) {
          Int32 len = strlen(cName);
          char* temp = space->allocateAndCopyToAlignedSpace(cName, len, 0);
          func->setConstraintName(temp);
        }

        // Set table name
        if (tName) {
          Int32 len = strlen(tName);
          char* temp = space->allocateAndCopyToAlignedSpace(tName, len, 0);
          func->setTableName(temp);
        }
      }

      break;
  }
}


ex_clause::ex_clause(clause_type type, 
		     OperatorTypeEnum oper_type,
		     short num_operands, 
		     Attributes ** op,
		     Space * space) 
  : NAVersionedObject(type), nextClause_(NULL), op_(NULL)
{
  clauseType_  = type;
  operType_    = oper_type;
  numOperands_ = num_operands;
  pciLink_     = NULL;
  nextClause_  = (ExClausePtr)NULL;
  flags_       = 0;
  //  instruction_   = -1;
  instrArrayIndex_ = -1;

  str_pad(fillers_, sizeof(fillers_), '\0');

  // Further qualify these types...
  //
  if ((type == ex_clause::FUNCTION_TYPE) ||
      (type == ex_clause::LIKE_TYPE) ||
      (type == ex_clause::MATH_FUNCTION_TYPE) ||
      (type == ex_clause::AGGREGATE_TYPE))
    {
      switch (oper_type)
	{
	case ITM_LIKE: 
	  setClassID(LIKE_CLAUSE_CHAR_ID);
	  break;
	case ITM_LIKE_DOUBLEBYTE: 
	  setClassID(LIKE_CLAUSE_DOUBLEBYTE_ID);
	  break;
        case ITM_REGEXP:
          setClassID(REGEXP_CLAUSE_CHAR_ID);
          break;
	case ITM_ASCII: 
	case ITM_CODE_VALUE: 
	case ITM_UNICODE_CODE_VALUE: 
	case ITM_NCHAR_MP_CODE_VALUE: 
	  setClassID(FUNC_ASCII_ID);
	  break;
	case ITM_CHAR:
	case ITM_NCHAR_MP_CHAR:
	case ITM_UNICODE_CHAR:
	  setClassID(FUNC_CHAR_ID);
	  break;
	case ITM_CHAR_LENGTH:
	  setClassID(FUNC_CHAR_LEN_ID);
	  break;
	case ITM_CHAR_LENGTH_DOUBLEBYTE:
	  setClassID(FUNC_CHAR_LEN_DOUBLEBYTE_ID);
	  break;
	case ITM_CONVERTFROMHEX:
	case ITM_CONVERTTOHEX:
	  setClassID(FUNC_CVT_HEX_ID);
	  break;
	case ITM_OCTET_LENGTH:
	  setClassID(FUNC_OCT_LEN_ID);
	  break;
	case ITM_POSITION:
	  setClassID(FUNC_POSITION_ID);
	  break;
	case ITM_POSITION_DOUBLEBYTE:
	  setClassID(FUNC_POSITION_DOUBLEBYTE_ID);
	  break;
	case ITM_SPLIT_PART:
	  setClassID(FUNC_SPLIT_PART_ID);
	  break;
	case ITM_CONCAT:
	  setClassID(FUNC_CONCAT_ID);
	  break;
	case ITM_REPEAT:
	  setClassID(FUNC_REPEAT_ID);
	  break;
	case ITM_REPLACE:
	  setClassID(FUNC_REPLACE_ID);
	  break;
	case ITM_SUBSTR:
	  setClassID(FUNC_SUBSTR_ID);
	  break;
	case ITM_SUBSTR_DOUBLEBYTE:
	  setClassID(FUNC_SUBSTR_DOUBLEBYTE_ID);
	  break;
	case ITM_TRIM:
	  setClassID(FUNC_TRIM_ID);
	  break;
	case ITM_TRANSLATE:
	  setClassID(FUNC_TRANSLATE_ID);
	  break;
	case ITM_TRIM_DOUBLEBYTE:
	  setClassID(FUNC_TRIM_DOUBLEBYTE_ID);
	  break;
	case ITM_LOWER:
	  setClassID(FUNC_LOWER_ID);
	  break;
	case ITM_UPPER:
	  setClassID(FUNC_UPPER_ID);
	  break;
	case ITM_UPPER_UNICODE:
	  setClassID(FUNC_UPPER_UNICODE_ID);
	  break;
	case ITM_LOWER_UNICODE:
	  setClassID(FUNC_LOWER_UNICODE_ID);
	  break;
	case ITM_UNIX_TIMESTAMP:
	  setClassID(FUNC_UNIX_TIMESTAMP_ID);
	  break;
	case ITM_SLEEP:
	  setClassID(FUNC_SLEEP_ID);
	  break;
	case ITM_CURRENT_TIMESTAMP:
	  setClassID(FUNC_CURRENT_TIMESTAMP_ID);
	  break;
	case ITM_CURRENT_TIMESTAMP_RUNNING:
	  setClassID(FUNC_CURRENT_TIMESTAMP_ID);
	  break;
	case ITM_COMP_ENCODE:
	case ITM_COMP_DECODE:
	  setClassID(FUNC_ENCODE_ID);
	  break;
	case ITM_EXPLODE_VARCHAR:
	  setClassID(FUNC_EXPLODE_VARCHAR_ID);
	  break;
	case ITM_HASH:
	  setClassID(FUNC_HASH_ID);
	  break;
	case ITM_HIVE_HASH:
	  setClassID(FUNC_HIVEHASH_ID);
	  break;
	case ITM_HASHCOMB:
	  setClassID(FUNC_HASHCOMB_ID);
	  break;
	case ITM_HIVE_HASHCOMB:
	  setClassID(FUNC_HIVEHASHCOMB_ID);
	  break;
	case ITM_HDPHASH:
	  setClassID(FUNC_HDPHASH_ID);
	  break;
	case ITM_HDPHASHCOMB:
	  setClassID(FUNC_HDPHASHCOMB_ID);
	  break;
	case ITM_BITMUX:
	  setClassID(FUNC_BITMUX_ID);
	  break;
	case ITM_REPLACE_NULL:
	  setClassID(FUNC_REPLACE_NULL_ID);
	  break;
	case ITM_MOD:
	  setClassID(FUNC_MOD_ID);
	  break;
	case ITM_MASK_SET:
	case ITM_MASK_CLEAR:
	  setClassID(FUNC_MASK_ID);
	  break;
	case ITM_SHIFT_RIGHT:
	case ITM_SHIFT_LEFT:
	  setClassID(FUNC_SHIFT_ID);
	  break;
	case ITM_ABS:
	  setClassID(FUNC_ABS_ID);
	  break;
	case ITM_RETURN_TRUE:
	case ITM_RETURN_FALSE:
	case ITM_RETURN_NULL:
	  setClassID(FUNC_BOOL_ID);
	  break;
	case ITM_CONVERTTIMESTAMP:
	  setClassID(FUNC_CONVERTTIMESTAMP_ID);
	  break;
	case ITM_DATEFORMAT:
	  setClassID(FUNC_DATEFORMAT_ID);
	  break;
	case ITM_DAYOFWEEK:
	  setClassID(FUNC_DAYOFWEEK_ID);
	  break;
	case ITM_EXTRACT:
	case ITM_EXTRACT_ODBC:
	  setClassID(FUNC_EXTRACT_ID);
	  break;
	case ITM_JULIANTIMESTAMP:
	  setClassID(FUNC_JULIANTIMESTAMP_ID);
	  break;
	case ITM_EXEC_COUNT:
	  setClassID(FUNC_EXEC_COUNT_ID);
	  break;
	case ITM_CURR_TRANSID:
	  setClassID(FUNC_CURR_TRANSID_ID);
	  break;
        case ITM_SHA1:
          setClassID(FUNC_SHA1_ID);
          break;
        case ITM_SHA2_224:
        case ITM_SHA2_256:
        case ITM_SHA2_384:
        case ITM_SHA2_512:
          setClassID(FUNC_SHA2_ID);
          break;
        case ITM_MD5:
          setClassID(FUNC_MD5_ID);
          break; 
        case ITM_CRC32:
          setClassID(FUNC_CRC32_ID);
          break; 
	case ITM_ISIPV4:
	case ITM_ISIPV6:
	  setClassID(FUNC_ISIP_ID);
	  break;
        case ITM_INET_ATON:
          setClassID(FUNC_INETATON_ID);
          break;
        case ITM_INET_NTOA:
          setClassID(FUNC_INETNTOA_ID);
          break;
	case ITM_USER:
	case ITM_USERID:
	case ITM_AUTHTYPE:
	case ITM_AUTHNAME:
	  setClassID(FUNC_USER_ID);
	  break;
	case ITM_CURRENT_USER:
	case ITM_SESSION_USER:
	  setClassID(FUNC_ANSI_USER_ID);
	  break;
	case ITM_VARIANCE:
	  setClassID(FUNC_VARIANCE_ID);
	  break;
	case ITM_STDDEV:
	  setClassID(FUNC_STDDEV_ID);
	  break;
	case ITM_RAISE_ERROR:
	  setClassID(FUNC_RAISE_ERROR_ID);
	  break;
	case ITM_RANDOMNUM:
	  setClassID(FUNC_RANDOMNUM_ID);
	  break;
	case ITM_RAND_SELECTION:
	  setClassID(FUNC_RAND_SELECTION_ID);
	  break;
	case ITM_PROGDISTRIB:
	  setClassID(FUNC_PROGDISTRIB_ID);
	  break;
	case ITM_PROGDISTRIBKEY:
	  setClassID(FUNC_PROGDISTKEY_ID);
	  break;
	case ITM_PAGROUP:
	  setClassID(FUNC_PAGROUP_ID);
	  break;
	case ITM_HASH2_DISTRIB:
	  setClassID(FUNC_HASH2_DISTRIB_ID);
	  break;
	case ITM_UNPACKCOL:
	  setClassID(FUNC_UNPACKCOL_ID);
	  break;
	case ITM_PACK_FUNC:
	  setClassID(FUNC_PACK_ID);
	  break;
	case ITM_ROWSETARRAY_SCAN:
	  setClassID(FUNC_ROWSETARRAY_SCAN_ID);
	  break;
	case ITM_ROWSETARRAY_ROWID:
	  setClassID(FUNC_ROWSETARRAY_ROW_ID);
	  break;
	case ITM_ROWSETARRAY_INTO:
	  setClassID(FUNC_ROWSETARRAY_INTO_ID);
	  break;
	case ITM_RANGE_LOOKUP:
	  setClassID(FUNC_RANGE_LOOKUP_ID);
	  break;
	case ITM_OFFSET:
	  setClassID(FUNC_OFFSET_ID);
	  break;
	case ITM_DEGREES:
	case ITM_PI:
	case ITM_RADIANS:
	case ITM_ROUND:
	case ITM_SCALE_TRUNC:
	case ITM_ACOS:
	case ITM_ASIN:
	case ITM_ATAN:
	case ITM_ATAN2:
	case ITM_CEIL:
	case ITM_COS:
	case ITM_COSH:
	case ITM_EXP:
	case ITM_FLOOR:
	case ITM_LOG:
	case ITM_LOG10:
	case ITM_LOG2:
	case ITM_SIN:
	case ITM_SINH:
	case ITM_SQRT:
	case ITM_TAN:
	case ITM_TANH:
	case ITM_EXPONENT:
	case ITM_POWER:
	  setClassID(FUNC_MATH_ID);
	  break;
	case ITM_BITAND:
	case ITM_BITOR:
	case ITM_BITXOR:
	case ITM_BITNOT:
	case ITM_BITEXTRACT:
	case ITM_CONVERTTOBITS:
	  setClassID(FUNC_BIT_OPER_ID);
	  break;
	case ITM_ONE_ROW:
	  setClassID(AGGR_ONE_ROW_ID);
	  break;
	case ITM_ANY_TRUE_MAX:
	  setClassID(AGGR_ANY_TRUE_MAX_ID);
	  break;
	case ITM_AGGR_MIN_MAX:
	  setClassID(AGGR_MIN_MAX_ID);
	  break;
	case ITM_AGGR_GROUPING_FUNC:
	  setClassID(AGGR_GROUPING_ID);
	  break;
	case ITM_CURRENTEPOCH:
	case ITM_VSBBROWTYPE:
	case ITM_VSBBROWCOUNT:
	  setClassID(FUNC_GENERICUPDATEOUTPUT_ID);
	  break;
	case ITM_INTERNALTIMESTAMP:
	  setClassID(FUNC_INTERNALTIMESTAMP_ID);
	  break;
	case ITM_UNIQUE_EXECUTE_ID:
	  setClassID(FUNC_UNIQUE_EXECUTE_ID_ID);
	  break;
	case ITM_GET_TRIGGERS_STATUS:
	  setClassID(FUNC_GET_TRIGGERS_STATUS_ID);
	  break;
	case ITM_GET_BIT_VALUE_AT:
	  setClassID(FUNC_GET_BIT_VALUE_AT_ID);
	  break;
	case ITM_IS_BITWISE_AND_TRUE:
	  setClassID(FUNC_IS_BITWISE_AND_TRUE);
	  break;
	case ITM_NULLIFZERO:
	  setClassID(FUNC_NULLIFZERO);
	  break;
	case ITM_NVL:
	  setClassID(FUNC_NVL);
	  break;
        case ITM_JSONOBJECTFIELDTEXT:
	  setClassID(FUNC_JSON_ID);
	  break;
	case ITM_QUERYID_EXTRACT:
	  setClassID(FUNC_QUERYID_EXTRACT);
	  break;
	case ITM_UNIQUE_ID:
	case ITM_UNIQUE_SHORT_ID:
	  setClassID(FUNC_UNIQUE_ID);
	  break;
	case ITM_ROWNUM:
	  setClassID(FUNC_ROWNUM);
	  break;
	case ITM_HBASE_COLUMN_LOOKUP:
	  setClassID(FUNC_HBASE_COLUMN_LOOKUP);
	  break;
	case ITM_HBASE_COLUMNS_DISPLAY:
	  setClassID(FUNC_HBASE_COLUMNS_DISPLAY);
	  break;
	case ITM_HBASE_COLUMN_CREATE:
	  setClassID(FUNC_HBASE_COLUMN_CREATE);
	  break;
	case ITM_TOKENSTR:
	  setClassID(FUNC_TOKENSTR_ID);
	  break;
	case ITM_REVERSE:
	  setClassID(FUNC_REVERSE_ID);
	  break;
	case ITM_CAST_TYPE:
	  setClassID(FUNC_CAST_TYPE);
	  break;
	case ITM_SEQUENCE_VALUE:
	  setClassID(FUNC_SEQUENCE_VALUE);
	  break;
	case ITM_PIVOT_GROUP:
	  setClassID(FUNC_PIVOT_GROUP);
	  break;
	case ITM_HEADER:
	  setClassID(FUNC_HEADER);
	  break;
	case ITM_HBASE_TIMESTAMP:
	  setClassID(FUNC_HBASE_TIMESTAMP);
	  break;
	case ITM_HBASE_VERSION:
	  setClassID(FUNC_HBASE_VERSION);
	  break;
	case ITM_SOUNDEX:
	  setClassID(FUNC_SOUNDEX_ID);
	  break;
        case ITM_AES_ENCRYPT:
          setClassID(FUNC_AES_ENCRYPT);
          break;
        case ITM_AES_DECRYPT:
          setClassID(FUNC_AES_DECRYPT);
          break;
	default:
	  GenAssert(0, "ex_clause: Unknown Class ID.");
	  break;
	}
    }
  else if (type == ex_clause::LOB_TYPE)
    {
      switch (oper_type)
	{
	case ITM_LOBINSERT:
	  setClassID(LOB_INSERT);
	  break;
	case ITM_LOBSELECT:
	  setClassID(LOB_SELECT);
	  break;
	case ITM_LOBDELETE:
	  setClassID(LOB_DELETE);
	  break;
	case ITM_LOBUPDATE:
	  setClassID(LOB_UPDATE);
	  break;
	case ITM_LOBCONVERT:
	  setClassID(LOB_CONVERT);
	  break;
	case ITM_LOBCONVERTHANDLE:
	  setClassID(LOB_CONVERTHANDLE);
	  break;
	case ITM_SUBSTR:
	  setClassID(LOB_FUNC_SUBSTR);
	  break;
	default:
	  GenAssert(0, "ex_clause: Unknown Class ID.");
	  break;
	}
    }

  clauseNum_ = 0;
  numberBranchTargets_ = 0;

  /* Make sure that all operands have valid values for atp, atp_index
     and offset.                                                      */
  if (op) {

    short numOperands = (op[0]->showplan() ? num_operands*2 : num_operands);

    if (space)
      
      op_ = (AttributesPtr *)(space->allocateAlignedSpace(numOperands *
							sizeof(AttributesPtr)));
	
    else
      //      op_ = (AttributesPtr *)(new char[numOperands * sizeof(AttributesPtr)]);
      GenAssert(0, "Internal Error: must pass the space pointer.");

      
    Lng32 i = 0;
    Attributes *attr = NULL;
    for (i=0; i<num_operands;i++) {
      if (! op[i])
        continue;

      if ((op[i]->getAtp() < 0) ||
	  (op[i]->getAtpIndex() < 0) ||
	  (op[i]->getTupleFormat() == ExpTupleDesc::UNINITIALIZED_FORMAT))
	GenAssert(0, "Internal Error: Operand attributes are not valid.");

      if (space)
	attr = op[i]->newCopy(space);
      else
	//	op_[i] = op[i]->newCopy();
	GenAssert(0, "Internal Error: must pass the space pointer.");
  
      attr->setAtp(op[i]->getAtp());
      attr->setAtpIndex(op[i]->getAtpIndex());
      attr->setOffset(op[i]->getOffset());
      attr->setRelOffset(op[i]->getRelOffset());
      attr->setVoaOffset(op[i]->getVoaOffset());
      attr->setNullBitIndex(op[i]->getNullBitIndex());
      attr->setNextFieldIndex(op[i]->getNextFieldIndex());
      attr->setTupleFormat(op[i]->getTupleFormat());
      attr->setDefaultFieldNum(op[i]->getDefaultFieldNum());

      if (attr->getNullFlag()) {
	if(i == 0) flags_ |= ANY_OUTPUT_NULLABLE;
	else flags_ |= ANY_INPUT_NULLABLE;
      }
      op_[i] = attr;
    }

    if (op_[0]->showplan())
      {
	for (i = num_operands; i < numOperands; i++)
	  {
	    if (space)
	      op_[i] = op[i]->newCopy(space);
	    else
	      op_[i] = op[i]->newCopy();
	  }
      }
  }
  else
    op_ = 0;
};


ex_clause::~ex_clause()
{
}

// -----------------------------------------------------------------------
// This method returns the virtual function table pointer for an object
// with the given class ID; used by NAVersionedObject::driveUnpack().
// -----------------------------------------------------------------------
char *ex_clause::findVTblPtr(short classID)
{
  char *vtblPtr;
  switch (classID)
    {
    case ex_clause::COMP_TYPE:
      GetVTblPtr(vtblPtr, ex_comp_clause);
      break;
    case ex_clause::CONV_TYPE:
      GetVTblPtr(vtblPtr, ex_conv_clause);
      break;
    case ex_clause::UN_LOGIC_TYPE:
      GetVTblPtr(vtblPtr, ex_unlogic_clause);
      break;
    case ex_clause::ARITH_TYPE:
      GetVTblPtr(vtblPtr, ex_arith_clause);
      break;
    case ex_clause::ARITH_SUM_TYPE:
      GetVTblPtr(vtblPtr, ex_arith_sum_clause);
      break;
    case ex_clause::ARITH_COUNT_TYPE:
      GetVTblPtr(vtblPtr, ex_arith_count_clause);
      break;
    case ex_clause::LIKE_CLAUSE_CHAR_ID:
      GetVTblPtr(vtblPtr, ex_like_clause_char);
      break;
    case ex_clause::LIKE_CLAUSE_DOUBLEBYTE_ID:
      GetVTblPtr(vtblPtr, ex_like_clause_doublebyte);
      break;
    case ex_clause::REGEXP_CLAUSE_CHAR_ID:
            GetVTblPtr(vtblPtr, ExRegexpClauseChar);
      break;
    case ex_clause::FUNC_ASCII_ID:
      GetVTblPtr(vtblPtr, ExFunctionAscii);
      break;
    case ex_clause::FUNC_CHAR_ID:
      GetVTblPtr(vtblPtr, ExFunctionChar);
      break;
    case ex_clause::FUNC_CHAR_LEN_ID:
      GetVTblPtr(vtblPtr, ex_function_char_length);
      break;
    case ex_clause::FUNC_CHAR_LEN_DOUBLEBYTE_ID:
      GetVTblPtr(vtblPtr, ex_function_char_length_doublebyte);
      break;
    case ex_clause::FUNC_CVT_HEX_ID:
      GetVTblPtr(vtblPtr, ExFunctionConvertHex);
      break;
    case ex_clause::FUNC_OCT_LEN_ID:
      GetVTblPtr(vtblPtr, ex_function_oct_length);
      break;
    case ex_clause::FUNC_POSITION_ID:
      GetVTblPtr(vtblPtr, ex_function_position);
      break;
    case ex_clause::FUNC_POSITION_DOUBLEBYTE_ID:
      GetVTblPtr(vtblPtr, ex_function_position_doublebyte);
      break;
    case ex_clause::FUNC_SPLIT_PART_ID:
      GetVTblPtr(vtblPtr, ex_function_split_part);
      break;
    case ex_clause::FUNC_CONCAT_ID:
      GetVTblPtr(vtblPtr, ex_function_concat);
      break;
    case ex_clause::FUNC_REPEAT_ID:
      GetVTblPtr(vtblPtr, ExFunctionRepeat);
      break;
    case ex_clause::FUNC_REPLACE_ID:
      GetVTblPtr(vtblPtr, ExFunctionReplace);
      break;
    case ex_clause::FUNC_SUBSTR_ID:
      GetVTblPtr(vtblPtr, ex_function_substring);
      break;
    // 12/23/97: added for unicode
    case ex_clause::FUNC_SUBSTR_DOUBLEBYTE_ID:
      GetVTblPtr(vtblPtr, ex_function_substring_doublebyte);
      break;
    case ex_clause::FUNC_TRIM_ID:
      GetVTblPtr(vtblPtr, ex_function_trim_char);
      break;
    case ex_clause::FUNC_TRANSLATE_ID:
      GetVTblPtr(vtblPtr, ex_function_translate);
      break;
    // 12/29/97: added for unicode
    case ex_clause::FUNC_TRIM_DOUBLEBYTE_ID:
      GetVTblPtr(vtblPtr, ex_function_trim_doublebyte);
      break;
    case ex_clause::FUNC_LOWER_ID:
      GetVTblPtr(vtblPtr, ex_function_lower);
      break;
    case ex_clause::FUNC_UPPER_ID:
      GetVTblPtr(vtblPtr, ex_function_upper);
      break;
    // 12/17/97: added for unicode UPPER()
    case ex_clause::FUNC_UPPER_UNICODE_ID:
      GetVTblPtr(vtblPtr, ex_function_upper_unicode);
      break;
    // 12/17/97: added for unicode LOWER()
    case ex_clause::FUNC_LOWER_UNICODE_ID:
      GetVTblPtr(vtblPtr, ex_function_lower_unicode);
      break;
    case ex_clause::FUNC_SLEEP_ID:
      GetVTblPtr(vtblPtr, ex_function_sleep);
      break;
    case ex_clause::FUNC_UNIX_TIMESTAMP_ID:
      GetVTblPtr(vtblPtr, ex_function_unixtime);
      break;
    case ex_clause::FUNC_CURRENT_TIMESTAMP_ID:
      GetVTblPtr(vtblPtr, ex_function_current);
      break;
    case ex_clause::FUNC_INTERNALTIMESTAMP_ID:
      GetVTblPtr(vtblPtr, ExFunctionInternalTimestamp);
      break;
    case ex_clause::FUNC_GENERICUPDATEOUTPUT_ID:
      GetVTblPtr(vtblPtr, ExFunctionGenericUpdateOutput);
      break;
    case ex_clause::FUNC_UNIQUE_EXECUTE_ID_ID:
      GetVTblPtr(vtblPtr, ex_function_unique_execute_id);
      break;
    case ex_clause::FUNC_GET_TRIGGERS_STATUS_ID:
      GetVTblPtr(vtblPtr, ex_function_get_triggers_status);
      break;
    case ex_clause::FUNC_GET_BIT_VALUE_AT_ID:
      GetVTblPtr(vtblPtr, ex_function_get_bit_value_at);
      break;
    case ex_clause::FUNC_IS_BITWISE_AND_TRUE:
      GetVTblPtr(vtblPtr, ex_function_is_bitwise_and_true);
      break;
    case ex_clause::FUNC_ENCODE_ID:
      GetVTblPtr(vtblPtr, ex_function_encode);
      break;
    case ex_clause::FUNC_EXPLODE_VARCHAR_ID:
      GetVTblPtr(vtblPtr, ex_function_explode_varchar);
      break;
    case ex_clause::FUNC_HASH_ID:
      GetVTblPtr(vtblPtr, ex_function_hash);
      break;
    case ex_clause::FUNC_HASHCOMB_ID:
      GetVTblPtr(vtblPtr, ExHashComb);
      break;
    case ex_clause::FUNC_HDPHASH_ID:
      GetVTblPtr(vtblPtr, ExHDPHash);
      break;
    case ex_clause::FUNC_HDPHASHCOMB_ID:
      GetVTblPtr(vtblPtr, ExHDPHashComb);
      break;
    case ex_clause::FUNC_BITMUX_ID:
      GetVTblPtr(vtblPtr, ExpBitMuxFunction);
      break;
    case ex_clause::FUNC_REPLACE_NULL_ID:
      GetVTblPtr(vtblPtr, ex_function_replace_null);
      break;
    case ex_clause::FUNC_MOD_ID:
      GetVTblPtr(vtblPtr, ex_function_mod);
      break;
    case ex_clause::FUNC_MASK_ID:
      GetVTblPtr(vtblPtr, ex_function_mask);
      break;
    case ex_clause::FUNC_SHIFT_ID:
      GetVTblPtr(vtblPtr, ExFunctionShift);
      break;
    case ex_clause::FUNC_ABS_ID:
      GetVTblPtr(vtblPtr, ex_function_abs);
      break;
    case ex_clause::FUNC_BOOL_ID:
      GetVTblPtr(vtblPtr, ex_function_bool);
      break;
    case ex_clause::FUNC_CONVERTTIMESTAMP_ID:
      GetVTblPtr(vtblPtr, ex_function_converttimestamp);
      break;
    case ex_clause::FUNC_DATEFORMAT_ID:
      GetVTblPtr(vtblPtr, ex_function_dateformat);
      break;
    case ex_clause::FUNC_DAYOFWEEK_ID:
      GetVTblPtr(vtblPtr, ex_function_dayofweek);
      break;
    case ex_clause::FUNC_EXTRACT_ID:
      GetVTblPtr(vtblPtr, ex_function_extract);
      break;
    case ex_clause::FUNC_JULIANTIMESTAMP_ID:
      GetVTblPtr(vtblPtr, ex_function_juliantimestamp);
      break;
    case ex_clause::FUNC_EXEC_COUNT_ID:
      GetVTblPtr(vtblPtr, ex_function_exec_count);
      break;
    case ex_clause::FUNC_CURR_TRANSID_ID:
      GetVTblPtr(vtblPtr, ex_function_curr_transid);
      break;
    case ex_clause::FUNC_USER_ID:
      GetVTblPtr(vtblPtr, ex_function_user);
      break;
    case ex_clause::FUNC_ANSI_USER_ID:
      GetVTblPtr(vtblPtr, ex_function_ansi_user);
      break;
    case ex_clause::FUNC_VARIANCE_ID:
      GetVTblPtr(vtblPtr, ExFunctionSVariance);
      break;
    case ex_clause::FUNC_STDDEV_ID:
      GetVTblPtr(vtblPtr, ExFunctionSStddev);
      break;
    case ex_clause::FUNC_RAISE_ERROR_ID:
      GetVTblPtr(vtblPtr, ExpRaiseErrorFunction);
      break;
    case ex_clause::FUNC_RANDOMNUM_ID:
      GetVTblPtr(vtblPtr, ExFunctionRandomNum);
      break;
    case ex_clause::FUNC_RAND_SELECTION_ID:
      GetVTblPtr(vtblPtr, ExFunctionRandomSelection);
      break;
    case ex_clause::FUNC_PROGDISTRIB_ID:
      GetVTblPtr(vtblPtr, ExProgDistrib);
      break;
    case ex_clause::FUNC_PROGDISTKEY_ID:
      GetVTblPtr(vtblPtr, ExProgDistribKey);
      break;
    case ex_clause::FUNC_PAGROUP_ID:
      GetVTblPtr(vtblPtr, ExPAGroup);
      break;
    case ex_clause::FUNC_HASH2_DISTRIB_ID:
      GetVTblPtr(vtblPtr, ExHash2Distrib);
      break;
    case ex_clause::FUNC_HEADER:
      GetVTblPtr(vtblPtr, ExHeaderClause);
      break;
    case ex_clause::FUNC_UNPACKCOL_ID:
      GetVTblPtr(vtblPtr, ExUnPackCol);
      break;
    case ex_clause::FUNC_PACK_ID:
      GetVTblPtr(vtblPtr, ExFunctionPack);
      break;
    case ex_clause::FUNC_RANGE_LOOKUP_ID:
      GetVTblPtr(vtblPtr, ExFunctionRangeLookup);
      break;
    case ex_clause::FUNC_OFFSET_ID:
      GetVTblPtr(vtblPtr, ExpSequenceFunction);
      break;
    case ex_clause::FUNCTION_TYPE:
      GetVTblPtr(vtblPtr, ex_function_clause);
      break;
    case ex_clause::FUNC_MATH_ID:
      GetVTblPtr(vtblPtr, ExFunctionMath);
      break;
    case ex_clause::FUNC_BIT_OPER_ID:
      GetVTblPtr(vtblPtr, ExFunctionBitOper);
      break;
    case ex_clause::BOOL_RESULT_TYPE:
      GetVTblPtr(vtblPtr, bool_result_clause);
      break;
    case ex_clause::BOOL_TYPE:
      GetVTblPtr(vtblPtr, ex_bool_clause);
      break;
    case ex_clause::BRANCH_TYPE:
      GetVTblPtr(vtblPtr, ex_branch_clause);
      break;
    case ex_clause::INOUT_TYPE:
      GetVTblPtr(vtblPtr, ex_inout_clause);
      break;
    case ex_clause::NOOP_TYPE:
      GetVTblPtr(vtblPtr, ex_noop_clause);
      break;
    case ex_clause::AGGR_ONE_ROW_ID:
      GetVTblPtr(vtblPtr, ex_aggr_one_row_clause);
      break;
    case ex_clause::AGGR_ANY_TRUE_MAX_ID:
      GetVTblPtr(vtblPtr, ex_aggr_any_true_max_clause);
      break;
    case ex_clause::AGGR_MIN_MAX_ID:
      GetVTblPtr(vtblPtr, ex_aggr_min_max_clause);
      break;
    case ex_clause::AGGR_GROUPING_ID:
      GetVTblPtr(vtblPtr, ExFunctionGrouping);
      break;
    case ex_clause::AGGREGATE_TYPE:
      GetVTblPtr(vtblPtr, ex_aggregate_clause);
      break;
    case ex_clause::FUNC_ROWSETARRAY_SCAN_ID:
      GetVTblPtr(vtblPtr, ExRowsetArrayScan)
      break;
    case ex_clause::FUNC_ROWSETARRAY_ROW_ID:
      GetVTblPtr(vtblPtr, ExRowsetArrayRowid);
      break;
    case ex_clause::FUNC_ROWSETARRAY_INTO_ID:
      GetVTblPtr(vtblPtr, ExRowsetArrayInto);
      break;
    case ex_clause::FUNC_NULLIFZERO:
      GetVTblPtr(vtblPtr, ex_function_nullifzero);
      break;
    case ex_clause::FUNC_NVL:
      GetVTblPtr(vtblPtr, ex_function_nvl);
      break;
    case ex_clause::FUNC_JSON_ID:
      GetVTblPtr(vtblPtr, ex_function_json_object_field_text);
      break;
    case ex_clause::FUNC_QUERYID_EXTRACT:
      GetVTblPtr(vtblPtr, ex_function_queryid_extract);
      break;
    case ex_clause::FUNC_TOKENSTR_ID:
      GetVTblPtr(vtblPtr, ExFunctionTokenStr);
      break;
    case ex_clause::FUNC_REVERSE_ID:
      GetVTblPtr(vtblPtr, ExFunctionReverseStr);
      break;
    case ex_clause::LOB_INSERT:
      GetVTblPtr(vtblPtr, ExpLOBinsert);
      break;
    case ex_clause::LOB_SELECT:
      GetVTblPtr(vtblPtr, ExpLOBselect);
      break;
    case ex_clause::LOB_DELETE:
      GetVTblPtr(vtblPtr, ExpLOBdelete);
      break;
    case ex_clause::LOB_UPDATE:
      GetVTblPtr(vtblPtr, ExpLOBupdate);
      break;
    case ex_clause::LOB_CONVERT:
      GetVTblPtr(vtblPtr, ExpLOBconvert);
      break;
    case ex_clause::LOB_CONVERTHANDLE:
      GetVTblPtr(vtblPtr, ExpLOBconvertHandle);
      break;
    case ex_clause::LOB_FUNC_SUBSTR:
      GetVTblPtr(vtblPtr, ExpLOBfuncSubstring);
      break;
    case ex_clause::FUNC_HIVEHASH_ID:
      GetVTblPtr(vtblPtr, ex_function_hivehash);
      break;
    case ex_clause::FUNC_HIVEHASHCOMB_ID:
      GetVTblPtr(vtblPtr, ExHiveHashComb);
      break;
    case ex_clause::FUNC_UNIQUE_ID:
      GetVTblPtr(vtblPtr, ExFunctionUniqueId);
      break;
    case ex_clause::FUNC_ROWNUM:
      GetVTblPtr(vtblPtr, ExFunctionRowNum);
      break;
    case ex_clause::FUNC_HBASE_COLUMN_LOOKUP:
      GetVTblPtr(vtblPtr, ExFunctionHbaseColumnLookup);
      break;
    case ex_clause::FUNC_HBASE_COLUMNS_DISPLAY:
      GetVTblPtr(vtblPtr, ExFunctionHbaseColumnsDisplay);
      break;
    case ex_clause::FUNC_HBASE_COLUMN_CREATE:
      GetVTblPtr(vtblPtr, ExFunctionHbaseColumnCreate);
      break;
    case ex_clause::FUNC_CAST_TYPE:
      GetVTblPtr(vtblPtr, ExFunctionCastType);
      break;
    case ex_clause::FUNC_SEQUENCE_VALUE:
      GetVTblPtr(vtblPtr, ExFunctionSequenceValue);
      break;
    case ex_clause::FUNC_PIVOT_GROUP:
      GetVTblPtr(vtblPtr, ex_pivot_group_clause);
      break;
    case ex_clause::FUNC_HBASE_TIMESTAMP:
      GetVTblPtr(vtblPtr, ExFunctionHbaseTimestamp);
      break;
    case ex_clause::FUNC_HBASE_VERSION:
      GetVTblPtr(vtblPtr, ExFunctionHbaseVersion);
      break;
    case ex_clause::FUNC_SHA1_ID:
      GetVTblPtr(vtblPtr, ExFunctionSha);
      break;
    case ex_clause::FUNC_SHA2_ID:
      GetVTblPtr(vtblPtr, ExFunctionSha2);
      break;
    case ex_clause::FUNC_MD5_ID:
      GetVTblPtr(vtblPtr, ExFunctionMd5);
      break;
    case ex_clause::FUNC_CRC32_ID:
      GetVTblPtr(vtblPtr, ExFunctionCrc32);
      break;
    case ex_clause::FUNC_ISIP_ID:
      GetVTblPtr(vtblPtr, ExFunctionIsIP);
      break;
    case ex_clause::FUNC_INETATON_ID:
      GetVTblPtr(vtblPtr, ExFunctionInetAton);
      break;
    case ex_clause::FUNC_INETNTOA_ID:
      GetVTblPtr(vtblPtr, ExFunctionInetNtoa);
      break;
    case ex_clause::FUNC_SOUNDEX_ID:
      GetVTblPtr(vtblPtr, ExFunctionSoundex);
      break;
    case ex_clause::FUNC_AES_ENCRYPT:
      GetVTblPtr(vtblPtr, ExFunctionAESEncrypt);
      break;
    case ex_clause::FUNC_AES_DECRYPT:
      GetVTblPtr(vtblPtr, ExFunctionAESDecrypt);
      break;
     default:
      GetVTblPtr(vtblPtr, ex_clause);
      break;
    }
  return vtblPtr;
}


ex_expr::exp_return_type ex_clause::processNulls(char *null_data[],
						 CollHeap *heap,
						 ComDiagsArea **diagsArea)
{
  
  for (short i = 1; i < getNumOperands(); i++)
    {
      // if value is missing, then it is a null value.
      // Move it to result and return. 
      if ((getOperand(i)->getNullFlag()) &&    // nullable
	  (! null_data[i]))                    // missing value 
	{
	  // This test is only needed in derived ex_conv_clause::processNulls;
	  // (! get_operand(0)->getNullFlag()) should be impossible here.
	  //
	  // if (! get_operand(0)->getNullFlag()) // target not nullable
	  //   {
	  //     // Attempt to put NULL into a column with a
	  //     // NOT NULL NONDROPPABLE constraint.
	  //     // ## Need to supply name of constraint and name of table here.
	  //     ExRaiseSqlError(heap, diagsArea, EXE_TABLE_CHECK_CONSTRAINT);
	  //     return ex_expr::EXPR_ERROR;
	  //   }

	  // move null value to result.
          ExpTupleDesc::setNullValue( null_data[0],
                                      getOperand(0)->getNullBitIndex(),
                                      getOperand(0)->getTupleFormat() );
	  return ex_expr::EXPR_NULL;
	}
    }
  
  // move 0 to the null bytes of result
  if (getOperand(0)->getNullFlag())
    {
      ExpTupleDesc::clearNullValue( null_data[0],
                                    getOperand(0)->getNullBitIndex(),
                                    getOperand(0)->getTupleFormat() );
    }
  
  return ex_expr::EXPR_OK;
}

Long ex_clause::packClause(void * space, Lng32 /*size*/)
{
  if (op_) {
    if (op_[0]->showplan()) {
      for (Lng32 i=numOperands_; i < 2 * numOperands_; i++)
        op_[i].pack(space);
    }
    for (Lng32 i=0; i < numOperands_; i++) 
      op_[i].pack(space);
  }
  op_.packShallow(space);
  return NAVersionedObject::pack(space);
}

Long ex_clause::pack(void * space)
{
  return packClause(space, sizeof(ex_clause));
}

Lng32 ex_clause::unpackClause(void *base, void * reallocator)
{
  if (op_) {
    if (op_.unpackShallow(base)) return -1;
    for (Lng32 i=0; i < numOperands_; i++) {
      if (op_[i].unpack(base, reallocator)) return -1;
    }
    if (op_[0]->showplan()) {
	  for (Lng32 i=numOperands_; i < 2 * numOperands_; i++) {
        if (op_[i].unpack(base, reallocator)) return -1;
      }
    }
  }
  return NAVersionedObject::unpack(base, reallocator);
}

Lng32 ex_clause::unpack(void *base, void * reallocator)
{
  return unpackClause(base, reallocator);
}

const char * getOperTypeEnumAsString(Int16 /*OperatorTypeEnum*/ ote)
{
  switch (ote)
    {
    // Note, this list is arranged in the same order as the types
    // appear in common/OperTypeEnum.h, please keep the same order
    // when adding new types
    case ITM_AND: return "ITM_AND";
    case ITM_OR: return "ITM_OR";

    // unary logic operators
    case ITM_NOT: return "ITM_NOT";
    case ITM_IS_TRUE: return "ITM_IS_TRUE";
    case ITM_IS_FALSE: return "ITM_IS_FALSE";
    case ITM_IS_NULL: return "ITM_IS_NULL";
    case ITM_IS_NOT_NULL: return "ITM_IS_NOT_NULL";
    case ITM_IS_UNKNOWN: return "ITM_IS_UNKNOWN";
    case ITM_IS_NOT_UNKNOWN: return "ITM_IS_NOT_UNKNOWN";

    // binary comparison operators
    case ITM_EQUAL: return "ITM_EQUAL";
    case ITM_NOT_EQUAL: return "ITM_NOT_EQUAL";
    case ITM_LESS: return "ITM_LESS";
    case ITM_LESS_EQ: return "ITM_LESS_EQ";
    case ITM_GREATER: return "ITM_GREATER";
    case ITM_GREATER_EQ: return "ITM_GREATER_EQ";

    // unary arithmetic operators
    case ITM_NEGATE: return "ITM_NEGATE";
    case ITM_INVERSE: return "ITM_INVERSE";
    // binary arithmetic operators
    case ITM_PLUS: return "ITM_PLUS";
    case ITM_MINUS: return "ITM_MINUS";
    case ITM_TIMES: return "ITM_TIMES";
    case ITM_DIVIDE: return "ITM_DIVIDE";
    case ITM_EXPONENT: return "ITM_EXPONENT";

    // aggregate functions
    case ITM_AVG: return "ITM_AVG";
    case ITM_MAX: return "ITM_MAX";
    case ITM_MIN: return "ITM_MIN";
    case ITM_MAX_ORDERED: return "ITM_MAX_ORDERED";
    case ITM_MIN_ORDERED: return "ITM_MIN_ORDERED";
    case ITM_SUM: return "ITM_SUM";
    case ITM_COUNT: return "ITM_COUNT";
    case ITM_COUNT_NONULL: return "ITM_COUNT_NONULL";
    case ITM_STDDEV: return "ITM_STDDEV";
    case ITM_VARIANCE: return "ITM_VARIANCE";
    case ITM_BASECOL: return "ITM_BASECOL";

    case ITM_ONE_ROW: return "ITM_ONE_ROW";
    case ITM_ONEROW: return "ITM_ONEROW";
    case ITM_ONE_TRUE: return "ITM_ONE_TRUE";
    case ITM_ANY_TRUE: return "ITM_ANY_TRUE";
    case ITM_ANY_TRUE_MAX: return "ITM_ANY_TRUE_MAX";
    case ITM_MAX_INCL_NULL: return "ITM_MAX_INCL_NULL";

    case ITM_PIVOT_GROUP: return "ITM_PIVOT_GROUP";

    case ITM_AGGR_MIN_MAX: return "ITM_AGGR_MIN_MAX";
    case ITM_AGGR_GROUPING_FUNC: return "ITM_AGGR_GROUPING_FUNC";

    // custom functions
    case ITM_USER_DEF_FUNCTION: return "ITM_USER_DEF_FUNCTION";
    case ITM_BETWEEN: return "ITM_BETWEEN";
    case ITM_LIKE: return "ITM_LIKE";
    case ITM_REGEXP: return "ITM_REGEXP";
    case ITM_UNIX_TIMESTAMP: return "ITM_UNIX_TIMESTAMP";
    case ITM_SLEEP: return "ITM_SLEEP";
    case ITM_CURRENT_TIMESTAMP: return "ITM_CURRENT_TIMESTAMP";
    case ITM_CURRENT_USER: return "ITM_CURRENT_USER";
    case ITM_SESSION_USER: return "ITM_SESSION_USER";
    case ITM_USER: return "ITM_USER";
    case ITM_AUTHNAME: return "ITM_AUTHNAME";
    case ITM_AUTHTYPE: return "ITM_AUTHTYPE";

    case ITM_BOOL_RESULT: return "ITM_BOOL_RESULT";
    case ITM_NO_OP: return "ITM_NO_OP";

    case ITM_CASE: return "ITM_CASE";
    case ITM_IF_THEN_ELSE: return "ITM_IF_THEN_ELSE";
    case ITM_RETURN_TRUE: return "ITM_RETURN_TRUE";
    case ITM_RETURN_FALSE: return "ITM_RETURN_FALSE";
    case ITM_RETURN_NULL: return "ITM_RETURN_NULL";
    case ITM_COMP_ENCODE: return "ITM_COMP_ENCODE";
    case ITM_COMP_DECODE: return "ITM_COMP_DECODE";
    case ITM_HASH: return "ITM_HASH";
    case ITM_REPLACE_NULL: return "ITM_REPLACE_NULL";
    case ITM_PACK_FUNC: return "ITM_PACK_FUNC";
    case ITM_BITMUX: return "ITM_BITMUX";
    case ITM_OVERLAPS: return "ITM_OVERLAPS";
    case ITM_RAISE_ERROR: return "ITM_RAISE_ERROR";

    case ITM_USERID: return "ITM_USERID";

    // sequence functions
    case ITM_DIFF1            : return "ITM_DIFF1";
    case ITM_DIFF2            : return "ITM_DIFF2";
    case ITM_LAST_NOT_NULL    : return "ITM_LAST_NOT_NULL";
    case ITM_MOVING_COUNT     : return "ITM_MOVING_COUNT";
    case ITM_MOVING_SUM       : return "ITM_MOVING_SUM";
    case ITM_MOVING_AVG       : return "ITM_MOVING_AVG";
    case ITM_MOVING_MAX       : return "ITM_MOVING_MAX";
    case ITM_MOVING_MIN       : return "ITM_MOVING_MIN";
    case ITM_MOVING_SDEV      : return "ITM_MOVING_SDEV";
    case ITM_MOVING_VARIANCE  : return "ITM_MOVING_VARIANCE";
    case ITM_OFFSET           : return "ITM_OFFSET";
    case ITM_RUNNING_COUNT    : return "ITM_RUNNING_COUNT";
    case ITM_ROWS_SINCE       : return "ITM_ROWS_SINCE";
    case ITM_RUNNING_SUM      : return "ITM_RUNNING_SUM";
    case ITM_RUNNING_AVG      : return "ITM_RUNNING_AVG";
    case ITM_RUNNING_MAX      : return "ITM_RUNNING_MAX";
    case ITM_RUNNING_MIN      : return "ITM_RUNNING_MIN";
    case ITM_RUNNING_SDEV     : return "ITM_RUNNING_SDEV";
    case ITM_RUNNING_VARIANCE : return "ITM_RUNNING_VARIANCE";
    case ITM_THIS             : return "ITM_THIS";
    case ITM_NOT_THIS         : return "ITM_NOT_THIS";

    // flow control
    case ITM_DO_WHILE         : return "ITM_DO_WHILE";
    case ITM_BLOCK            : return "ITM_BLOCK";
    case ITM_WHILE            : return "ITM_WHILE";

    // scalar min/max

    case ITM_SCALAR_MIN       : return "ITM_SCALAR_MIN";
    case ITM_SCALAR_MAX       : return "ITM_SCALAR_MAX";

    case ITM_CURRENT_TIMESTAMP_RUNNING: return "ITM_CURRENT_TIMESTAMP_RUNNING";

    // numeric functions
    case ITM_ABS: return "ITM_ABS";
    case ITM_CEIL: return "ITM_CEIL";
    case ITM_COS: return "ITM_COS";
    case ITM_COSH: return "ITM_COSH";
    case ITM_FLOOR: return "ITM_FLOOR";
    case ITM_LOG: return "ITM_LOG";
    case ITM_LOG10: return "ITM_LOG10";
    case ITM_LOG2: return "ITM_LOG2";
    case ITM_MOD: return "ITM_MOD";
    case ITM_POWER: return "ITM_POWER";
    case ITM_ROUND: return "ITM_ROUND";
    case ITM_SIGN: return "ITM_SIGN";
    case ITM_SIN: return "ITM_SIN";
    case ITM_SINH: return "ITM_SINH";
    case ITM_SQRT: return "ITM_SQRT";
    case ITM_TAN: return "ITM_TAN";
    case ITM_TANH: return "ITM_TANH";
    case ITM_ROUND_ROBIN: return "ITM_ROUND_ROBIN";
    case ITM_ACOS: return "ITM_ACOS";
    case ITM_ASIN: return "ITM_ASIN";
    case ITM_ATAN: return "ITM_ATAN";
    case ITM_ATAN2: return "ITM_ATAN2";
    case ITM_DEGREES: return "ITM_DEGREES";
    case ITM_EXP: return "ITM_EXP";
    case ITM_PI: return "ITM_PI";
    case ITM_RADIANS: return "ITM_RADIANS";
    case ITM_SCALE_TRUNC: return "ITM_SCALE_TRUNC";
    case ITM_MASK_CLEAR: return "ITM_MASK_CLEAR";
    case ITM_MASK_SET: return "ITM_MASK_SET";
    case ITM_SHIFT_RIGHT: return "ITM_SHIFT_RIGHT";
    case ITM_SHIFT_LEFT: return "ITM_SHIFT_LEFT";
    case ITM_BITAND: return "ITM_BITAND";
    case ITM_BITOR: return "ITM_BITOR";
    case ITM_BITXOR: return "ITM_BITXOR";
    case ITM_BITNOT: return "ITM_BITNOT";
    case ITM_BITEXTRACT: return "ITM_BITEXTRACT";

    // string functions
    case ITM_TRUNC: return "ITM_TRUNC";
    case ITM_ASCII: return "ITM_ASCII";
    case ITM_CODE_VALUE: return "ITM_CODE_VALUE";
    case ITM_POSITION: return "ITM_POSITION";
    case ITM_CHAR_LENGTH: return "ITM_CHAR_LENGTH";
    case ITM_INSERT_STR: return "ITM_INSERT_STR";
    case ITM_OCTET_LENGTH: return "ITM_OCTET_LENGTH";
    case ITM_LOWER: return "ITM_LOWER";
    case ITM_LPAD: return "ITM_LPAD";
    case ITM_LTRIM: return "ITM_LTRIM";
    case ITM_REPLACE: return "ITM_REPLACE";
    case ITM_RPAD: return "ITM_RPAD";
    case ITM_RTRIM: return "ITM_RTRIM";
    case ITM_SOUNDEX: return "ITM_SOUNDEX";
    case ITM_SUBSTR: return "ITM_SUBSTR";
    case ITM_TRIM: return "ITM_TRIM";
    case ITM_UPPER: return "ITM_UPPER";
    case ITM_CHAR: return "ITM_CHAR";
    case ITM_CONCAT: return "ITM_CONCAT";
    case ITM_UNPACKCOL: return "ITM_UNPACKCOL";
    case ITM_EXPLODE_VARCHAR: return "ITM_EXPLODE_VARCHAR";
    case ITM_REPEAT: return "ITM_REPEAT";
    case ITM_RIGHT: return "ITM_RIGHT";
    case ITM_CONVERTTOBITS: return "ITM_CONVERTTOBITS";
    case ITM_CONVERTTOHEX: return "ITM_CONVERTTOHEX";
    case ITM_CONVERTFROMHEX: return "ITM_CONVERTFROMHEX";
    case ITM_TOKENSTR: return "ITM_TOKENSTR";
    case ITM_REVERSE: return "ITM_REVERSE";

    // UNICODE/DOUBLEBYTE charsets built-in functions
    case ITM_SUBSTR_DOUBLEBYTE: return "ITM_SUBSTR_DOUBLEBYTE";
    case ITM_TRIM_DOUBLEBYTE: return "ITM_TRIM_DOUBLEBYTE";
    case ITM_CHAR_LENGTH_DOUBLEBYTE: return "ITM_CHAR_LENGTH_DOUBLEBYTE";
    case ITM_POSITION_DOUBLEBYTE: return "ITM_POSITION_DOUBLEBYTE";
    case ITM_LIKE_DOUBLEBYTE: return "ITM_LIKE_DOUBLEBYTE";
    case ITM_UPPER_UNICODE: return "ITM_UPPER_UNICODE";
    case ITM_LOWER_UNICODE: return "ITM_LOWER_UNICODE";
    case ITM_REPEAT_UNICODE: return "ITM_REPEAT_UNICODE";
    case ITM_REPLACE_UNICODE: return "ITM_REPLACE_UNICODE";
    case ITM_UNICODE_CODE_VALUE: return "ITM_UNICODE_CODE_VALUE";
    case ITM_NCHAR_MP_CODE_VALUE: return "ITM_NCHAR_MP_CODE_VALUE";
    // translate function
    case ITM_TRANSLATE: return "ITM_TRANSLATE";

    case ITM_UNICODE_CHAR: return "ITM_UNICODE_CHAR";
    case ITM_NCHAR_MP_CHAR: return "ITM_NCHAR_MP_CHAR";

    // RowSet expression functions
    case ITM_ROWSETARRAY_SCAN: return "ITM_ROWSETARRAY_SCAN";
    case ITM_ROWSETARRAY_ROWID: return "ITM_ROWSETARRAY_ROWID";
    case ITM_ROWSETARRAY_INTO : return "ITM_ROWSETARRAY_INTO";

    case ITM_LEFT: return "ITM_LEFT";
    case ITM_SPACE: return "ITM_SPACE";
    case ITM_ODBC_LENGTH: return "ITM_ODBC_LENGTH";

    // datetime functions
    case ITM_CONVERTTIMESTAMP: return "ITM_CONVERTTIMESTAMP";
    case ITM_DATEFORMAT: return "ITM_DATEFORMAT";
    case ITM_DAYOFWEEK: return "ITM_DAYOFWEEK";
    case ITM_EXTRACT: return "ITM_EXTRACT";
    case ITM_INITCAP: return "ITM_INITCAP";
    case ITM_JULIANTIMESTAMP: return "ITM_JULIANTIMESTAMP";
    case ITM_EXTRACT_ODBC: return "ITM_EXTRACT_ODBC";
    case ITM_DAYNAME: return "ITM_DAYNAME";
    case ITM_MONTHNAME: return "ITM_MONTHNAME";
    case ITM_QUARTER: return "ITM_QUARTER";
    case ITM_WEEK: return "ITM_WEEK";
    case ITM_DAYOFYEAR: return "ITM_DAYOFYEAR";
    case ITM_FIRSTDAYOFYEAR: return "ITM_FIRSTDAYOFYEAR";
    case ITM_INTERNALTIMESTAMP: return "ITM_INTERNALTIMESTAMP";
    // misc. functions
    case ITM_NARROW: return "ITM_NARROW";
    case ITM_INTERVAL: return "ITM_INTERVAL";
    case ITM_INSTANTIATE_NULL: return "ITM_INSTANTIATE_NULL";
    case ITM_INCREMENT: return "ITM_INCREMENT";
    case ITM_DECREMENT: return "ITM_DECREMENT";
    case ITM_GREATER_OR_GE: return "ITM_GREATER_OR_GE";
    case ITM_LESS_OR_LE: return "ITM_LESS_OR_LE";
    case ITM_RANGE_LOOKUP: return "ITM_RANGE_LOOKUP";
    case ITM_DECODE: return "ITM_DECODE";
    case ITM_HDPHASHCOMB: return "ITM_HDPHASHCOMB";
    case ITM_RANDOMNUM: return "ITM_RANDOMNUM";
    case ITM_PROGDISTRIB: return "ITM_PROGDISTRIB";
    case ITM_HASHCOMB: return "ITM_HASHCOMB";
    case ITM_HDPHASH: return "ITM_HDPHASH";
    case ITM_EXEC_COUNT: return "ITM_EXEC_COUNT";
    case ITM_CURR_TRANSID: return "ITM_CURR_TRANSID";
    case ITM_NOTCOVERED: return "ITM_NOTCOVERED";
    case ITM_BALANCE: return "ITM_BALANCE";
    case ITM_RAND_SELECTION: return "ITM_RAND_SELECTION";
    case ITM_PROGDISTRIBKEY: return "ITM_PROGDISTRIBKEY";
    case ITM_PAGROUP: return "ITM_PAGROUP";
    case ITM_HASH2_DISTRIB: return "ITM_HASH2_DISTRIB";

    case ITM_HEADER: return "ITM_HEADER";

    case ITM_LOBINSERT: return "ITM_LOBINSERT";
    case ITM_LOBSELECT: return "ITM_LOBSELECT";
    case ITM_LOBDELETE: return "ITM_LOBDELETE";
    case ITM_LOBUPDATE: return "ITM_LOBUPDATE";
    case ITM_LOBCONVERT: return "ITM_LOBCONVERT";
    case ITM_LOBCONVERTHANDLE: return "ITM_LOBCONVERTHANDLE";

    case ITM_UNIQUE_EXECUTE_ID: return "ITM_UNIQUE_EXECUTE_ID";
    case ITM_GET_TRIGGERS_STATUS: return "ITM_GET_TRIGGERS_STATUS";
    case ITM_GET_BIT_VALUE_AT: return "ITM_GET_BIT_VALUE_AT";
    case ITM_CURRENTEPOCH: return "ITM_CURRENTEPOCH";
    case ITM_VSBBROWTYPE: return "ITM_VSBBROWTYPE";
    case ITM_VSBBROWCOUNT: return "ITM_VSBBROWCOUNT";
    case ITM_IS_BITWISE_AND_TRUE: return "ITM_IS_BITWISE_AND_TRUE";

    case ITM_NULLIFZERO: return "ITM_NULLIFZERO";
    case ITM_NVL: return "ITM_NVL";

    case ITM_JSONOBJECTFIELDTEXT: return "ITM_JSONOBJECTFIELDTEXT";

    // subqueries
    case ITM_ROW_SUBQUERY: return "ITM_ROW_SUBQUERY";
    case ITM_IN_SUBQUERY: return "ITM_IN_SUBQUERY";
    case ITM_IN: return "ITM_IN";
    case ITM_EXISTS: return "ITM_EXISTS";
    case ITM_NOT_EXISTS: return "ITM_NOT_EXISTS";
    case ITM_EQUAL_ALL: return "ITM_EQUAL_ALL";
    case ITM_EQUAL_ANY: return "ITM_EQUAL_ANY";
    case ITM_NOT_EQUAL_ALL: return "ITM_NOT_EQUAL_ALL";
    case ITM_NOT_EQUAL_ANY: return "ITM_NOT_EQUAL_ANY";
    case ITM_LESS_ALL: return "ITM_LESS_ALL";
    case ITM_LESS_ANY: return "ITM_LESS_ANY";
    case ITM_GREATER_ALL: return "ITM_GREATER_ALL";
    case ITM_GREATER_ANY: return "ITM_GREATER_ANY";
    case ITM_LESS_EQ_ALL: return "ITM_LESS_EQ_ALL";
    case ITM_LESS_EQ_ANY: return "ITM_LESS_EQ_ANY";
    case ITM_GREATER_EQ_ALL: return "ITM_GREATER_EQ_ALL";
    case ITM_GREATER_EQ_ANY: return "ITM_GREATER_EQ_ANY";

    case ITM_WILDCARD_EQ_NE: return "ITM_WILDCARD_EQ_NE";

    // renaming, conversion, assignment
    case ITM_RENAME_COL: return "ITM_RENAME_COL";
    case ITM_CONVERT: return "ITM_CONVERT";
    case ITM_CAST: return "ITM_CAST";
    case ITM_ASSIGN: return "ITM_ASSIGN";

    // convert an NA-type to an item expression
    case ITM_NATYPE: return "ITM_NATYPE";

    // do a cast but adjust target length based
    // on operand (used by ODBC)
    case ITM_CAST_CONVERT: return "ITM_CAST_CONVERT";

    case ITM_CAST_TYPE: return "ITM_CAST_TYPE";

    // for OperatorType::match() of ItemExpr::origOpType()
    case ITM_ANY_AGGREGATE: return "ITM_ANY_AGGREGATE";

    // to match Cast, Cast_Convert, Instantiate_Null, Narrow
    case ITM_ANY_CAST: return "ITM_ANY_CAST";

    // item expressions describing constraints
    case ITM_CHECK_CONSTRAINT: return "ITM_CHECK_CONSTRAINT";
    case ITM_CARD_CONSTRAINT: return "ITM_CARD_CONSTRAINT";
    case ITM_UNIQUE_CONSTRAINT: return "ITM_UNIQUE_CONSTRAINT";
    case ITM_REF_CONSTRAINT: return "ITM_REF_CONSTRAINT";
    case ITM_UNIQUE_OPT_CONSTRAINT: return "ITM_UNIQUE_OPT_CONSTRAINT";
    case ITM_FUNC_DEPEND_CONSTRAINT: return "ITM_FUNC_DEPEND_CONSTRAINT";

    // list of item expressions
    case ITM_ITEM_LIST: return "ITM_ITEM_LIST";

    // leaf nodes of item expressions
    case ITM_CONSTANT: return "ITM_CONSTANT";
    case ITM_REFERENCE: return "ITM_REFERENCE";
    case ITM_BASECOLUMN: return "ITM_BASECOLUMN";
    case ITM_INDEXCOLUMN: return "ITM_INDEXCOLUMN";
    case ITM_HOSTVAR: return "ITM_HOSTVAR";
    case ITM_DYN_PARAM: return "ITM_DYN_PARAM";
    case ITM_SEL_INDEX: return "ITM_SEL_INDEX";
    case ITM_VALUEIDREF: return "ITM_VALUEIDREF";
    case ITM_VALUEIDUNION: return "ITM_VALUEIDUNION";
    case ITM_VEG: return "ITM_VEG";
    case ITM_VEG_PREDICATE: return "ITM_VEG_PREDICATE";
    case ITM_VEG_REFERENCE: return "ITM_VEG_REFERENCE";
    case ITM_DEFAULT_SPECIFICATION: return "ITM_DEFAULT_SPECIFICATION";
    case ITM_SAMPLE_VALUE: return "ITM_SAMPLE_VALUE";
    case ITM_CACHE_PARAM: return "ITM_CACHE_PARAM";

    // Item expressions for transactions
    case ITM_SET_TRANS_ISOLATION_LEVEL: return "ITM_SET_TRANS_ISOLATION_LEVEL";
    case ITM_SET_TRANS_ACCESS_MODE: return "ITM_SET_TRANS_ACCESS_MODE";
    case ITM_SET_TRANS_DIAGS: return "ITM_SET_TRANS_DIAGS";
    case ITM_SET_TRANS_ROLLBACK_MODE: return "ITM_SET_TRANS_ROLLBACK_MODE";
    case ITM_SET_TRANS_AUTOABORT_INTERVAL: return "ITM_SET_TRANS_AUTOABORT_INTERVAL";
    case ITM_SET_TRANS_MULTI_COMMIT: return "ITM_SET_TRANS_MULTI_COMMIT";

    case ITM_LAST_ITEM_OP: return "ITM_LAST_ITEM_OP";
    case ITM_UNIQUE_ID: return "ITM_UNIQUE_ID";
    case ITM_UNIQUE_SHORT_ID: return "ITM_UNIQUE_SHORT_ID";
    case ITM_ROWNUM: return "ITM_ROWNUM";
    case ITM_HBASE_COLUMN_LOOKUP: return "ITM_HBASE_COLUMN_LOOKUP";
    case ITM_HBASE_COLUMNS_DISPLAY: return "ITM_HBASE_COLUMNS_DISPLAY";
    case ITM_HBASE_COLUMN_CREATE: return "ITM_HBASE_COLUMN_CREATE";
    case ITM_HBASE_TIMESTAMP: return "ITM_HBASE_TIMESTAMP";
    case ITM_HBASE_VERSION: return "ITM_HBASE_VERSION";

    case ITM_SEQUENCE_VALUE: return "ITM_SEQUENCE_VALUE";

    // Note, this list is arranged in the same order as the types
    // appear in common/OperTypeEnum.h, please keep the same order
    // when adding new types
    default: 
      {
	cout << "OperatorType must be added to getOperTypeEnumAsString()"
	     << ote << endl;
	return "Add To getOperTypeEnumAsString()";
      }
    }
}

char * exClauseGetText(OperatorTypeEnum ote)
{
  char * itmText = (char *)getOperTypeEnumAsString(ote);
  
  // strip the ITM_ prefix
  if ((str_len(itmText) > 4) && (str_cmp(itmText, "ITM_", 4) == 0))
    return &itmText[4];
  else
    return itmText;
} // exClausegetText()

void ex_clause::displayContents(Space * space, const char * displayStr,
				Int32 clauseNum, char * constsArea)
{
  return displayContents(space, displayStr, clauseNum, constsArea, 0);
}

void ex_clause::displayContents(Space * space, const char * displayStr,
				Int32 clauseNum, char * constsArea, 
                                UInt32 clauseFlags,
                                Int16 instruction,
                                const char * instrText)
{
  char buf[100];
  if (displayStr)
    {
      str_sprintf(buf, "  Clause #%d: %s", clauseNum, displayStr); 
      space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
    }

  str_sprintf(buf, "    OperatorTypeEnum = %s(%d), NumOperands = %d",
	  getOperTypeEnumAsString(operType_), operType_, numOperands_);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  str_sprintf(buf, "    ex_clause::flags_ = %x ",flags_ );
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  if (displayStr)
    {
      str_sprintf(buf, "    %s::flags_ = %x ", displayStr, clauseFlags);
      space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
    }

  if (noPCodeAvailable())
    {
      str_sprintf(buf, "    PCODE  = not supported ");
      space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
    }
  else
    {
      str_sprintf(buf, "    PCODE  = supported ");
      space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
    }

  if (instruction >= 0)
    {
      if (instrText)
        str_sprintf(buf, "    instruction: %s(%d), instrArrayIndex_: %d", 
                    instrText, instruction, instrArrayIndex_);
      else
        str_sprintf(buf, "    instruction: UNKNOWN(%d), instrArrayIndex_: %d", 
                    instruction, instrArrayIndex_);
      space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
    }
  
  if (numOperands_ == 0)
    return;

  if (numOperands_ > 0)
  {
   NABoolean showplan = getOperand(0)->showplan();

   for (Int32 i = 0; i < numOperands_; i++)
   {
   getOperand(i)->displayContents(space, i,
                                   constsArea,
                                   (showplan 
                                   ? getOperand(i+numOperands_) 
                                   : NULL));
   str_sprintf(buf, "\n");
   space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
  }
 }
}

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

// Derived clauses
/////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
// class ex_arith_clause
///////////////////////////////////////////////////////////
ex_arith_clause::ex_arith_clause(OperatorTypeEnum oper_type,
				 Attributes ** attr,
				 Space * space,
				 short arithRoundingMode,
				 NABoolean divToDownscale) 
     : ex_clause (ex_clause::ARITH_TYPE, oper_type, 
                  (oper_type == ITM_NEGATE ? 2 : 3), attr, space),
       flags_(0)
{
  setAugmentedAssignOperation(TRUE);
  arithRoundingMode_ = (char)arithRoundingMode;


  if (divToDownscale)
    setDivToDownscale(TRUE);

  if (attr)
    setInstruction();
}


ExRegexpClauseChar::ExRegexpClauseChar(OperatorTypeEnum oper_type, 
			    short num_operands,
			    Attributes ** attr,
			    Space * space)
: ExRegexpClauseBase(oper_type, num_operands,attr,space)
{
}

ex_arith_clause::ex_arith_clause(clause_type type,
                                 OperatorTypeEnum oper_type,
                                 Attributes ** attr,
                                 Space * space)
                                 : ex_clause(type, oper_type, 3, attr, space),
				   arithRoundingMode_(0),
				   flags_(0)
 
{
  setAugmentedAssignOperation(TRUE);
  setInstruction(); 
}

ex_arith_sum_clause::ex_arith_sum_clause(OperatorTypeEnum oper_type,
					 Attributes ** attr,
					 Space * space)
           : ex_arith_clause (ex_clause::ARITH_SUM_TYPE, oper_type, attr, 
			      space)
{
}

ex_arith_count_clause::ex_arith_count_clause(OperatorTypeEnum oper_type,
					     Attributes ** attr,
					     Space * space)
           : ex_arith_clause (ex_clause::ARITH_COUNT_TYPE, oper_type, attr, 
			      space)
{
}

///////////////////////////////////////////////////////////
// class ex_comp_clause
///////////////////////////////////////////////////////////
ex_comp_clause::ex_comp_clause(OperatorTypeEnum oper_type,
			       Attributes ** attr,
			       Space * space,
			       ULng32 flags)
     : ex_clause (ex_clause::COMP_TYPE, oper_type, 3, attr, space),
       flags_(0),
       rollupColumnNum_(-1)
{
  if(flags) 
    setSpecialNulls();
  setInstruction();
}
 
///////////////////////////////////////////////////////////
// class ex_conv_clause
///////////////////////////////////////////////////////////
ex_conv_clause::ex_conv_clause(OperatorTypeEnum oper_type,
			       Attributes ** attr,
			       Space * space,
			       short num_operands, NABoolean checkTruncErr,
                               NABoolean reverseDataErrorConversionFlag,
                               NABoolean noStringTruncWarnings,
                               NABoolean convertToNullWhenErrorFlag)
     : ex_clause (ex_clause::CONV_TYPE, oper_type, num_operands, attr, space),
       lastVOAoffset_(0),
       lastVcIndicatorLength_(0),
       lastNullIndicatorLength_(0),
       computedLength_(0),
       alignment_(0),
       flags_(0)
{
  if (oper_type == ITM_NARROW)
    // Narrow reports conversion errors via a variable instead of a
    // SQL diagnostic -- so in this case we want to handle NULLs ourselves 
    setProcessNulls();   
  if (checkTruncErr)
    setCheckTruncationFlag();

  if (reverseDataErrorConversionFlag)
    flags_ |= REVERSE_DATA_ERROR_CONVERSION_FLAG;

  if (noStringTruncWarnings)
    setNoTruncationWarningsFlag();
  
  if (convertToNullWhenErrorFlag)
    flags_ |= CONV_TO_NULL_WHEN_ERROR;

  setInstruction(); 
}

///////////////////////////////////////////////////////////
// class ex_inout_clause
///////////////////////////////////////////////////////////
ex_inout_clause::ex_inout_clause(OperatorTypeEnum oper_type, 
				 Attributes ** attr, Space * space)
     : ex_clause (ex_clause::INOUT_TYPE, oper_type, 1, attr, space)
{
  name = 0;
  heading_ = 0;
  //  convHVClause_ = 0;
  flags_ = 0;
}

///////////////////////////////////////////////////////////
// class bool_result_clause
///////////////////////////////////////////////////////////
bool_result_clause::bool_result_clause(OperatorTypeEnum oper_type, 
				       Attributes ** attr,
				       Space * space)
     : ex_clause (ex_clause::BOOL_RESULT_TYPE, oper_type, 1, attr, space)
{
}

///////////////////////////////////////////////////////////
// class ex_branch_clause
///////////////////////////////////////////////////////////
ex_branch_clause::ex_branch_clause(OperatorTypeEnum oper_type,
				   Attributes ** attr, Space * space)
     : ex_clause (ex_clause::BRANCH_TYPE, oper_type, 2, attr, space),
       saved_next_clause(NULL),
       branch_clause(NULL)
{
}

ex_branch_clause::ex_branch_clause(OperatorTypeEnum oper_type,
				   Space * space)
     : ex_clause (ex_clause::BRANCH_TYPE, oper_type, 0, NULL, space),
       saved_next_clause(NULL),
       branch_clause(NULL)
{
}

///////////////////////////////////////////////////////////
// class ex_bool_clause
///////////////////////////////////////////////////////////
ex_bool_clause::ex_bool_clause(OperatorTypeEnum oper_type,
			       Attributes ** attr,
			       Space * space)
     : ex_clause (ex_clause::BOOL_TYPE, oper_type, 3, attr, space)
{
}

///////////////////////////////////////////////////////////
// class ex_unlogic_clause
///////////////////////////////////////////////////////////
ex_unlogic_clause::ex_unlogic_clause(OperatorTypeEnum oper_type, 
				     Attributes ** attr,
				     Space * space)
     : ex_clause (ex_clause::UN_LOGIC_TYPE, oper_type, 2, attr, space)
{
}

///////////////////////////////////////////////////////////
// class ex_aggregate_clause
///////////////////////////////////////////////////////////
ex_aggregate_clause::ex_aggregate_clause(OperatorTypeEnum oper_type,
					 short num_operands,
					 Attributes ** attr,
					 Space * space)
: ex_clause (ex_clause::AGGREGATE_TYPE, oper_type, num_operands, attr, space)
{
}

///////////////////////////////////////////////////////////
// class ex_noop_clause
///////////////////////////////////////////////////////////
ex_noop_clause::ex_noop_clause()
     : ex_clause (ex_clause::NOOP_TYPE, ITM_CONVERT, 0, 0, 0)
{
}

/////////////////////////////////////////////////////////
// class ex_function_clause
/////////////////////////////////////////////////////////
ex_function_clause::ex_function_clause(OperatorTypeEnum oper_type,
				       short num_operands,
				       Attributes ** attr,
				       Space * space)
     : ex_clause (ex_clause::FUNCTION_TYPE, oper_type, num_operands, attr,
		  space),
       origFunctionOperType_(oper_type)
{
  setDerivedFunction(FALSE);
}
  
/////////////////////////////////////////////////////////
// class ex_like_clause_char
/////////////////////////////////////////////////////////
ex_like_clause_char::ex_like_clause_char(OperatorTypeEnum oper_type,
                               short num_operands,
                               Attributes ** attr,
                               Space * space)
: ex_like_clause_base (oper_type, num_operands, attr, space)
{
}

ex_like_clause_doublebyte::ex_like_clause_doublebyte(OperatorTypeEnum oper_type,
                               short num_operands,
                               Attributes ** attr,
                               Space * space)
: ex_like_clause_base (oper_type, num_operands, attr, space)
{
}

/////////////////////////////////////////////////////////////
// Methods to display Contents
/////////////////////////////////////////////////////////////
void ex_aggr_one_row_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_aggr_one_row_clause", clauseNum, constsArea);
}

void ex_aggr_any_true_max_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_aggr_any_true_max_clause", clauseNum, constsArea);
}
void ex_aggr_min_max_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_aggr_min_max_clause", clauseNum, constsArea);
}

void ex_pivot_group_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_pivot_group_clause", clauseNum, constsArea);
}

void ExFunctionGrouping::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ExFunctionGrouping", clauseNum, constsArea);

  char buf[100];
  str_sprintf(buf, "    rollupGroupIndex_ = %d\n",
              rollupGroupIndex_);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
}

void ex_arith_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  setInstruction();

  char buf[100];
  str_sprintf(buf, "  Clause #%d: ex_arith_clause", clauseNum);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  if (arithRoundingMode_ != 0)
    {
      str_sprintf(buf, "    arithRoundingMode_ = %d, divToScale = %d",
		  (short)arithRoundingMode_, (getDivToDownscale() ? 1 : 0));
      space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
    }

  ex_clause::displayContents(space, (const char *)NULL, clauseNum, constsArea, 0,
                             ex_arith_clause::getInstruction(getInstrArrayIndex()),
                             ex_arith_clause::getInstructionStr(getInstrArrayIndex()));
}

void ex_arith_sum_clause::displayContents(Space * space, 
					  const char * /*displayStr*/, 
					  Int32 clauseNum, char * constsArea)
{
  setInstruction();
  ex_clause::displayContents(space, "ex_arith_sum_clause", clauseNum, constsArea);
}

void ex_arith_count_clause::displayContents(Space * space, 
					    const char * /*displayStr*/, 
					    Int32 clauseNum, char * constsArea)
{
  setInstruction();
  ex_clause::displayContents(space, "ex_arith_count_clause", clauseNum, constsArea);
}

void ex_bool_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_bool_clause", clauseNum, constsArea);
}

void bool_result_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "bool_result_clause", clauseNum, constsArea);
}

void ex_branch_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  char buf[100];
  str_sprintf(buf, "  Clause #%d: ex_branch_clause", clauseNum);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  str_sprintf(buf, "    OperatorTypeEnum = %s(%d), NumOperands = %d",
          getOperTypeEnumAsString(getOperType()), getOperType(),
                                  getNumOperands());
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  str_sprintf(buf, "    flags_ = %x ", getAllFlags());
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  if (noPCodeAvailable())
    {
      str_sprintf(buf, "    PCODE  = not supported ");
      space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
    }
  else
    {
      str_sprintf(buf, "    PCODE  = supported ");
      space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
    }
  str_sprintf(buf, "    branch to = #%d ",branch_clause->clauseNum());
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  if (getNumOperands() == 0)
    return;

  if (getNumOperands() > 0)
  {
   NABoolean showplan = getOperand(0)->showplan();

   for (Int32 i = 0; i < getNumOperands(); i++)
   {
   getOperand(i)->displayContents(space, i,
                                   constsArea,
                                   (showplan
                                   ? getOperand(i+getNumOperands())
                                   : NULL));
   str_sprintf(buf, "\n");
   space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
   }
  }
}

void ex_comp_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  setInstruction();

  char buf[100];
  str_sprintf(buf, "  Clause #%d: ex_comp_clause", clauseNum);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  str_sprintf(buf, "    ex_comp_clause::rollupColumnNum_ = %d", rollupColumnNum_);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  str_sprintf(buf, "    ex_comp_clause::flags_ = %x", flags_);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  ex_clause::displayContents(space, (const char *)NULL, clauseNum, constsArea, 
                             0,
                             ex_comp_clause::getInstruction(getInstrArrayIndex()),                             
                             ex_comp_clause::getInstructionStr(getInstrArrayIndex()));

}

void ex_conv_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  setInstruction();
  ex_clause::displayContents(space, "ex_conv_clause", clauseNum, constsArea, 
                             flags_,
                             ex_conv_clause::getInstruction(getInstrArrayIndex()),
                             ex_conv_clause::getInstructionStr(getInstrArrayIndex()));
}

void ex_function_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_function_clause", clauseNum, constsArea);
}
void ex_function_abs::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_function_abs", clauseNum, constsArea);
}

void ExFunctionMath::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ExFunctionMath", clauseNum, constsArea);
}

void ExFunctionBitOper::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ExFunctionBitOper", clauseNum, constsArea);
}
void ex_inout_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_inout_clause", clauseNum, constsArea);
  //  cout << "Name  = " << getName() << endl;
}

void ex_noop_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_noop_clause", clauseNum, constsArea);
}

void ex_unlogic_clause::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_unlogic_clause", clauseNum, constsArea);
}

void ex_like_clause_char::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_like_clause_char", clauseNum, constsArea);
}

void ExRegexpClauseChar::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ExRegexpClauseChar", clauseNum, constsArea);
}

void ex_like_clause_doublebyte::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  ex_clause::displayContents(space, "ex_like_clause_doublebyte", clauseNum, constsArea);
}

void ExFunctionHbaseTimestamp::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  char buf[100];
  str_sprintf(buf, "  Clause #%d: ExFunctionHbaseTimestamp", clauseNum);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  str_sprintf(buf, "    colIndex_ = %d", colIndex_);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  ex_clause::displayContents(space, (const char *)NULL, clauseNum, constsArea);
}

void ExFunctionHbaseVersion::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  char buf[100];
  str_sprintf(buf, "  Clause #%d: ExFunctionHbaseVersion", clauseNum);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  str_sprintf(buf, "    colIndex_ = %d", colIndex_);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  ex_clause::displayContents(space, (const char *)NULL, clauseNum, constsArea);
}

void ex_function_dateformat::displayContents(Space * space, const char * /*displayStr*/, Int32 clauseNum, char * constsArea)
{
  char buf[100];
  str_sprintf(buf, "  Clause #%d: ex_function_dateformat", clauseNum);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  str_sprintf(buf, "    dateformat_ = %d", dateformat_);
  space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));

  ex_clause::displayContents(space, (const char *)NULL, clauseNum, constsArea);
}

// Function to compare two strings. 
Int32 charStringCompareWithPad(char* in_s1, Int32 length1, 
                                          char* in_s2, Int32 length2, 
                                          char space)
{
  unsigned char * s1 = (unsigned char *)in_s1;
  unsigned char * s2 = (unsigned char *)in_s2;

   Lng32 compare_len;
   Int32 compare_code;
   
   if (length1 > length2)
     compare_len = length2;
   else
     compare_len = length1;

   compare_code = str_cmp(in_s1, in_s2, compare_len);
   
   if ((compare_code == 0) && (length1 != length2))
     {
       if (length1 > length2)
         {
   	Int32 j = compare_len;
   	
   	while ((j < length1) && (compare_code == 0))
   	  {
   	    if (s1[j] < space )
   	      compare_code = -1;
   	    else
   	      if (s1[j] > space )
   		compare_code = 1;
   	    j++;
   	  }
         }
       else
         {
   	Int32 j = compare_len;
   	
   	while ((j < length2) && (compare_code == 0))
   	  {
   	    if (s2[j] < space )
   	      compare_code = 1;
   	    else
   	      if (s2[j] > space )
   		compare_code = -1;
   	    j++;
   	  }
         }
    }
     //return 0,1,-1 values, not the positive, 0, negative
     if (compare_code > 0)
       compare_code = 1;
     if (compare_code < 0)
       compare_code = -1;
    return compare_code;
}

Int32 wcharStringCompareWithPad(NAWchar* s1, Int32 length1, 
                                           NAWchar* s2, Int32 length2, 
                                           NAWchar space)
{
  Lng32 compare_len;
  Int32 compare_code;
	
  if (length1 > length2)
    compare_len = length2;
  else
    compare_len = length1;

  compare_code = wc_str_cmp(s1, s2, compare_len);
	
  if ((compare_code == 0) && (length1 != length2))
    {
      if (length1 > length2)
        {
          Int32 j = compare_len;
 	
          while ((j < length1) && (compare_code == 0))
            {
	      if (s1[j] < space )
	        compare_code = -1;
	      else
	        if (s1[j] > space )
	  	  compare_code = 1;
	      j++;
	    }
        }
	else
	{
	  Int32 j = compare_len;
		
	  while ((j < length2) && (compare_code == 0))
	    {
	      if (s2[j] < space )
	        compare_code = 1;
	      else
	        if (s2[j] > space )
	    	  compare_code = -1;
	      j++;
	    }
        }
    }
    //return 0,1,-1 values, not the positive, 0, negative
     if (compare_code > 0)
       compare_code = 1;
     if (compare_code < 0)
       compare_code = -1;
    return compare_code;
}