/**********************************************************************
// @@@ 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:         GenExpGenerator.cpp
 * Description:  Methods for class ExpGenerator
 *
 * Created:      6/28/95
 * Language:     C++
 *
 *
 *****************************************************************************
 */


#define   SQLPARSERGLOBALS_FLAGS
#define   SQLPARSERGLOBALS_NADEFAULTS
#include "SqlParserGlobalsCmn.h"
#include "SqlParserGlobals.h"	// Parser Flags

#include <ctype.h>
#include <math.h>
#include "CmpContext.h"
#include "CmpStatement.h"
#include "CmpMain.h"
#include "CmpSeabaseDDL.h"

#include "GenExpGenerator.h"
#include "str.h"
#include "Sqlcomp.h"
#include "exp_clause_derived.h"
#include "exp_attrs.h"
#include "exp_function.h"
#include "exp_datetime.h"
#include "exp_bignum.h"
#include "DatetimeType.h"
#include "NumericType.h"
#include "IntervalType.h"
#include "CharType.h"
#include "charinfo.h"
#include "SQLCLIdev.h"
#include "BindWA.h"

#include "ExpCriDesc.h"
#include "ExpAtp.h"
#include "exp_attrs.h"
#include "exp_tuple_desc.h"
#include "exp_dp2_expr.h"
#include "ComQueue.h"

#include "ControlDB.h"

#include "ComSmallDefs.h"
#include "sqlcli.h"
#include "OptimizerSimulator.h"
#include "ItmFlowControlFunction.h"
#include "ExpPCodeOptimizations.h"
#include "ItemFunc.h"

#define   NEW_LEAN_EXPR

static short mapMode(ComColumnDirection direction);

static short mapMode(ComColumnDirection direction)
{
  switch(direction)
  {
  case COM_UNKNOWN_DIRECTION:

	return PARAMETER_MODE_UNDEFINED;

  case COM_INPUT_COLUMN:

	return PARAMETER_MODE_IN;

  case COM_OUTPUT_COLUMN:

	return PARAMETER_MODE_OUT;

  case COM_INOUT_COLUMN:

	return PARAMETER_MODE_INOUT;

  default:

	BriefAssertion(0, "Unrecognized ComColumnDirection");

	return 0; // not reached
  }
}

// End


ExpGenerator::ExpGenerator(Generator * generator_)
{
  generator = generator_;

  // $$$ is this the correct heap???
  cache_ = new(generator->wHeap()) ExpGeneratorCache(generator_);

  temps_length = 0;  // Initialize various member variables
  mapTable_ = 0;
  clause_list = 0;
  constant_list = 0;
  persistentList_ = 0;
  flags_ = 0;
  rowsSinceCounter_ = NULL;

  setHandleIndirectVC( TRUE );

  // default value for Pcode mode
  DefaultToken pcodeOptLevel = CmpCommon::getDefault(PCODE_OPT_LEVEL);

  switch (pcodeOptLevel)
    {
    case DF_OFF:
      // don't use any PCODE features at all
      pCodeMode_ = ex_expr::PCODE_NONE;
      break;

    case DF_MINIMUM:
      // use PCODE to call the regular expression evaluator
      pCodeMode_ =
	ex_expr::PCODE_ON | ex_expr::PCODE_EVAL;
      break;

    case DF_MEDIUM:
      // use PCODE for those clauses that can be translated to PCODE
      pCodeMode_ = ex_expr::PCODE_ON;
      break;

    case DF_HIGH:
      // use PCODE where possible and optimize it
      pCodeMode_ = ex_expr::PCODE_ON | ex_expr::PCODE_OPTIMIZE;
      break;

    case DF_MAXIMUM:
    case DF_ON:
    case DF_SYSTEM:
    default:
      // use PCODE where possible and run LLO (low-level) advanced optimizations
      pCodeMode_ = ex_expr::PCODE_ON | ex_expr::PCODE_OPTIMIZE |
                   ex_expr::PCODE_LLO;
      break;
    }
  static Int32 pcodeEnvSet = 0;
  static Int32 pcodeEnv = 1;  // if non-zero, pcode is enabled as before.
  if (pcodeEnvSet == 0)
    {
      char * pcodeEnvStr = getenv("64BIT_PCODE");
      if (pcodeEnvStr != NULL)
        pcodeEnv = atoi(pcodeEnvStr);

      pcodeEnvSet = 1;
    }
  if (pcodeEnv == 0)
    pCodeMode_ = ex_expr::PCODE_NONE;

  addPCodeMode( ex_expr::PCODE_SPECIAL_FIELDS );

  // May be used during key encoding expression generation if there are
  // added fields present.
  savedPCodeMode_ = -1;
};

ExpGenerator::~ExpGenerator()
  {
  delete cache_;
  }


///////////////////////////////////////////////////////////////////////////
// The following is a static function used by aggregate node when generating
// aggregate expression of type ITM_ONE_ROW
///////////////////////////////////////////////////////////////////////////
void createCastNodesatLeaves(ItemExpr *exp, Generator *generator)
{
  // expecting input of the kind: a,b,c,d....
  for (short i=0; i<exp->getArity(); i++)
  {
    if (exp->child(i)->getOperatorType() != ITM_ITEM_LIST)
    {
      ValueId val_id;
      ItemExpr *newExpr;
      val_id = exp->child(i)->castToItemExpr()->getValueId();
      newExpr = new(generator->wHeap()) Cast(exp->child(i), &(val_id.getType()));
      newExpr = newExpr->bindNode(generator->getBindWA());
      exp->child(i) = newExpr;
    }
    else
      createCastNodesatLeaves(exp->child(i), generator);
  }

} // createCastNodesatLeaves()

///////////////////////////////////////////////////////////
// returns a ConstValue node with min or max value
// The max value could either be the null max value or
// the non-null max value, based on the input min_max.
//////////////////////////////////////////////////////////
ItemExpr * ExpGenerator::getMinMaxValue(const NAType &type,
					short min_max /*0=min, -1=max, -2=max-without-null*/)
{
  NABoolean includeNulls = (min_max > -2);
  NABoolean getMin = (min_max == 0);

  return new(CmpCommon::statementHeap())
    ConstValue(&type,getMin,includeNulls);
}

/////////////////////////////////////////////////////////////////
// Make an equivalent Attributes object (or derived class)
// from an NAType.
/////////////////////////////////////////////////////////////////
Attributes * ExpGenerator::convertNATypeToAttributes
(const NAType &naType_x, CollHeap* wHeap)
{
  // ----------------------------------------------------------------
  // Each NAType corresponds to an object derived from class
  // "Attributes" used by expression generator to evaluate
  // operations on it.
  // All 'simple' types return SimpleType.
  // All 'complex' types return the class specific to them. These
  // classes contain methods used to perform operations on this type.
  // ----------------------------------------------------------------

  Attributes   *result = NULL;
  const NAType *naType = &naType_x;

  Int32 rsSize = 0;
  if (naType->getTypeQualifier() == NA_ROWSET_TYPE)
    {
      rsSize = ((SQLRowset *)naType)->getNumElements();
      naType = ((const SQLRowset *)naType)->getElementType();
    }

  if (naType->isSimpleType())
    {
      SimpleType * attr;

      switch (naType->getTypeQualifier()) {
      case NA_DATETIME_TYPE:
        attr = new(wHeap) ExpDatetime;
        break;
      default:
        attr = new(wHeap) SimpleType;
        break;
      }

      attr->setRowsetSize(rsSize);
      result = attr;
      attr->setNullFlag(naType->supportsSQLnull());
      attr->setNullIndicatorLength((short) naType->getSQLnullHdrSize());
      attr->setVCIndicatorLength((short) naType->getVarLenHdrSize());
      attr->setDatatype(naType->getFSDatatype());
      attr->setLength(naType->getNominalSize());
      attr->setDataAlignmentSize(naType->getDataAlignment());
      if (naType_x.getTypeQualifier() == NA_ROWSET_TYPE) {
	if (((SQLRowset *)(&naType_x))->useTotalSize()) {
	  // This indicates us to use the whole array size
 	  attr->setLength(sizeof(Lng32) + (attr->getRowsetSize() * naType->getTotalSize()));
	  result->setUseTotalRowsetSize();
	  ((SQLRowset *)(&naType_x))->useTotalSize() = FALSE;
	}
      }

      attr->setIsoMapping((CharInfo::CharSet)SqlParser_ISO_MAPPING);

      if (naType->getTypeQualifier() == NA_CHARACTER_TYPE) 
	{
	  const CharType *charType = (CharType *)naType;

	  if (charType->isUpshifted())
	    attr->setUpshift(1);

	  if (charType->isCaseinsensitive())
	    attr->setCaseinsensitive(1);

	  CharInfo::CharSet cs = charType->getCharSet();
	  if ( cs == CharInfo::UCS2       ||
               cs == CharInfo::KANJI_MP   ||
               cs == CharInfo::KSC5601_MP )
	    attr->setWidechar(1);

          attr->setPrecision(charType->getPrecisionOrMaxNumChars());
	  attr->setCharSet(charType->getCharSet());
	  attr->setCollation(charType->getCollation());
	}
      else if (naType->getTypeQualifier() == NA_NUMERIC_TYPE)
        {
          const NumericType *numericType = (const NumericType *) naType;

          if (numericType->binaryPrecision() && numericType->isExact() &&
              (numericType->getFSDatatype() != REC_BPINT_UNSIGNED))
            attr->setPrecision(0);
          else
            attr->setPrecision(numericType->getPrecision());

          attr->setScale((short) numericType->getScale());
        }
      else if (naType->getTypeQualifier() == NA_DATETIME_TYPE)
        {
          const DatetimeType *datetimeType = (const DatetimeType *) naType;

          // Map the datetime type (start and end fields) to the
          // corresponding REC_DATETIME_CODE.  Note that in order to
          // support the non-standard SQL/MP datetime types, the
          // REC_DATETIME_CODE enumeration has been extended to
          // contain a value for each legal (including non-standard)
          // combination of start and end fields.  This means that the
          // correspondence between the values of the SQLDATETIME_CODE
          // and REC_DATETIME_CODE enumerations holds only for the
          // standard datetime types.  The method getRecDateTimeCode()
          // maps the datetime types based on the start and end
          // fields.
          //
          // This method has been modified as part of the MP Datetime
          // Compatibility project.
          //
          attr->setPrecision(datetimeType->getRecDateTimeCode());
          if (attr->getPrecision() == REC_DTCODE_FRACTION)
          {
            attr->setPrecision(REC_DTCODE_SECOND);
          }
          attr->setScale(datetimeType->getFractionPrecision());
        }
      else if (naType->getTypeQualifier() == NA_INTERVAL_TYPE)
        {
          const IntervalType *intervalType = (const IntervalType *) naType;
          attr->setPrecision(intervalType->getLeadingPrecision());
          attr->setScale(intervalType->getFractionPrecision());
          if (attr->getDatatype() == REC_INT_FRACTION)
          {
           attr->setDatatype(REC_INT_SECOND);
          }
        }
      
      else if (naType->getTypeQualifier() == NA_LOB_TYPE)
        {
          
	  SQLlob *lobType = (SQLlob *) naType;
          attr->setCharSet(lobType->getCharSet());
	}
      
      else
        {
          attr->setPrecision(0);
          attr->setScale(0);
        }
    }
  else
    {
      if (naType->getSimpleTypeName() == "BIG NUM")
        {
          const NumericType *numericType = (const NumericType *) naType;

          BigNum * attr = new(wHeap)
            BigNum(numericType->getNominalSize(),
                   numericType->getPrecision(),
                   (short)numericType->getScale(),
                   numericType->isUnsigned());

	  attr->setRowsetSize(rsSize);
          result = attr;

          attr->setNullFlag(naType->supportsSQLnull());
          attr->setNullIndicatorLength((short) naType->getSQLnullHdrSize());
          attr->setVCIndicatorLength((short) naType->getVarLenHdrSize());
          attr->setDatatype(numericType->getFSDatatype());
          attr->setComplexDatatype(numericType->getFSDatatype());
          attr->setDataAlignmentSize(naType->getDataAlignment());
	  if (naType_x.getTypeQualifier() == NA_ROWSET_TYPE) {
	    if (((SQLRowset *)(&naType_x))->useTotalSize()) {
	      // This indicates us to use the whole array size
	      attr->setLength(sizeof(Lng32) + (attr->getRowsetSize() * naType->getTotalSize()));
	      result->setUseTotalRowsetSize();
	      ((SQLRowset *)(&naType_x))->useTotalSize() = FALSE;
	    }
	  }
        }

      else
        {
          GenAssert(0,"Don't know how to convert complex type to Attributes");
        }
    }

  return result;
}

Attributes::DefaultClass ExpGenerator::getDefaultClass(const NAColumn * col)
{
  Attributes::DefaultClass dc;

  switch (col->getDefaultClass())
  {
    case COM_CURRENT_DEFAULT:
      dc = Attributes::DEFAULT_CURRENT; break;
    case COM_CURRENT_UT_DEFAULT:
      dc = Attributes::DEFAULT_CURRENT_UT; break;
    case COM_UUID_DEFAULT:
      dc = Attributes::DEFAULT_UUID; break;
    case COM_FUNCTION_DEFINED_DEFAULT:
      dc = Attributes::DEFAULT_FUNCTION; break;
    case COM_NO_DEFAULT:
    case COM_ALWAYS_COMPUTE_COMPUTED_COLUMN_DEFAULT:
    case COM_ALWAYS_DEFAULT_COMPUTED_COLUMN_DEFAULT:
      dc = Attributes::NO_DEFAULT; break;
    case COM_NULL_DEFAULT:
      dc = Attributes::DEFAULT_NULL; break;
    case COM_USER_DEFINED_DEFAULT:
      dc = Attributes::DEFAULT_USER; break;
    case COM_USER_FUNCTION_DEFAULT:
      dc = Attributes::DEFAULT_USER_FUNCTION; break;
    case COM_IDENTITY_GENERATED_BY_DEFAULT:
    case COM_IDENTITY_GENERATED_ALWAYS:
      dc = Attributes::DEFAULT_IDENTITY; break;
    default:
      dc = Attributes::INVALID_DEFAULT; break;
  }

  return dc;
}

short ExpGenerator::addDefaultValue(NAColumn * col, Attributes * attr,
				    ComDiagsArea  * diagsArea,
				    COM_VERSION   objectSchemaVersion)
{
  Attributes::DefaultClass dc;
  char		*defaultValue = NULL;
  ComDiagsArea	* da;
  short		fsDataType;
  short		extraFltLen = 0;
  NAString      terminalName;

  dc = getDefaultClass(col);
  if (dc == Attributes::INVALID_DEFAULT)
    {
      // invalid default value
      da = (diagsArea ? diagsArea : CmpCommon::diags());
      *da << DgSqlCode(-7001)
	  << DgString0(col->getDefaultValue() ? col->getDefaultValue() : " ")
	  << DgString1(col->getFullColRefNameAsAnsiString());
      return -1;
    }

  NAString *castStr;

  if ((col) && 
      (col->isAddedColumn()))
    {
      attr->setAddedCol();
    }

  fsDataType = attr->getDatatype();
  NABoolean isUpshifted = FALSE;
  switch (dc)
  {
    case Attributes::DEFAULT_CURRENT:
      // This value is for the old rows before the alter table with add column
      // For new rows compiler will produce a node with CURRENT exp
      castStr = new(wHeap()) NAString("CAST(TIMESTAMP '0001-01-01:12:00:00.000000' AS ", wHeap());
      break;
    case Attributes::DEFAULT_CURRENT_UT:
      // This value is for the old rows before the alter table with add column
      // For new rows compiler will produce a node with CURRENT exp
      castStr = new(wHeap()) NAString("CAST( 0 AS ", wHeap());
      break;
    case Attributes::DEFAULT_NULL:
      if (attr->getNullFlag())
      {
	  defaultValue =
	    new(generator->getSpace())char[attr->getDefaultValueStorageLength()];
	  // move null value
	  str_pad(defaultValue, ExpTupleDesc::NULL_INDICATOR_LENGTH, '\377');
      }
      // else treat them as if it is no default
      attr->setDefaultValue(dc, defaultValue);
      return 0;
    case Attributes::DEFAULT_USER_FUNCTION:
     {
      const NAType* colType = col->getType();
         castStr = new(wHeap()) NAString("CAST('\' \'' AS ", wHeap());
     }
      break;
    case Attributes::DEFAULT_USER:
      if (col->getDefaultValue() != NULL)
      {
        if (col->getType()->getTypeQualifier() == NA_CHARACTER_TYPE)
          {
            const CharType *colCharType = (const CharType *)col->getType();
 
            if (colCharType->isUpshifted())
              isUpshifted = TRUE;
          }

	castStr = new(wHeap()) NAString("CAST(", wHeap());
	castStr->append(NAString(col->getDefaultValue(), wHeap()));
	castStr->append(NAString(" AS ", wHeap()));
      }
      else
      {
	da = (diagsArea ? diagsArea : CmpCommon::diags());
	*da << DgSqlCode(-7001)
	  << DgString0("NULL POINTER")
	  << DgString1(col->getFullColRefNameAsAnsiString());
	return -1;
      }
      break;
    case Attributes::DEFAULT_IDENTITY:
      // since this is used only for AddColumn and that we don't allow to add
      // IDENTITY column, it is Ok. to cast it to zero.
      castStr = new(wHeap()) NAString("CAST(0 AS ", wHeap());
      break;
    case Attributes::DEFAULT_FUNCTION:
      castStr = new(wHeap()) NAString("CAST( \' \' AS ", wHeap());
      break;

    case Attributes::NO_DEFAULT:
    default:
      attr->setDefaultValue(dc, NULL);
      return 0;
  }
  // Append Type Name
  castStr->append(NAString(col->getType()->getTypeSQLname(TRUE), wHeap()));
  if (isUpshifted)
    castStr->append(NAString(" UPSHIFT ", wHeap()));
  if (! attr->getNullFlag())
      castStr->append(NAString(" NOT NULL)", wHeap()));
  else
      castStr->append(NAString(")", wHeap()));

  BindWA *bindWA = generator->getBindWA();

  // When creating an SQL/MX table, (Called from
  // addDefaultValuesToRCB) the NATable is NULL.  
  Parser parser(bindWA->currentCmpContext());

  ItemExpr *defaultValueExpr = parser.getItemExprTree(*castStr);

  // if this column is serialized, then encode the default value.
  if (CmpSeabaseDDL::isEncodingNeededForSerialization(col))
    {
      defaultValueExpr = new(wHeap()) CompEncode
	(defaultValueExpr, FALSE, -1, CollationInfo::Sort, TRUE);
    }

  if (!defaultValueExpr || bindWA->errStatus())
  {
    // invalid default value
    da = (diagsArea ? diagsArea : CmpCommon::diags());
    *da << DgSqlCode(-7001)
        << DgString0(col->getDefaultValue() ? col->getDefaultValue() : " ")
        << DgString1(col->getFullColRefNameAsAnsiString());
    
    return -1;
  }

  defaultValueExpr->bindNode(bindWA);

  ValueIdList defaultValueIdList;
  defaultValueIdList.insert(defaultValueExpr->getValueId());
  defaultValue = new(generator->getSpace()) char[attr->getDefaultValueStorageLength()];
  Lng32 length;
  Lng32 offset;
  Lng32 daMark;

  da = (diagsArea ? diagsArea : CmpCommon::diags());
  daMark = da->mark();
  ex_expr::exp_return_type evalReturnCode = defaultValueIdList.evalAtCompileTime
    (0,
     ExpTupleDesc::PACKED_FORMAT,
     defaultValue, attr->getDefaultValueStorageLength() + extraFltLen,
     &length, &offset, da);

  if ((evalReturnCode != ex_expr::EXPR_OK) || (da->getNumber() != daMark))
  {
    // remove all the errors inserted in expression evaluation
    da->rewind(daMark, TRUE);
    // invalid default value
    NAString *cTemp;
    cTemp = unicodeToChar((const NAWchar *) (col->getDefaultValue())
                        , (Int32)NAWstrlen((const NAWchar *) (col->getDefaultValue()))
                        , ComGetErrMsgInterfaceCharSet()
                        , CmpCommon::statementHeap());

    if ( cTemp == NULL ) /* Prevent null ptr reference */
      cTemp = new (CmpCommon::statementHeap()) NAString(CmpCommon::statementHeap());

    *da << DgSqlCode(-7001)
        << DgString0(convertNAString(*cTemp,CmpCommon::statementHeap()))
        << DgString1(col->getFullColRefNameAsAnsiString());
    delete cTemp;
    return -1;
  }

  // Adjusting the resultBuffer's variable Character indicator length to
  // attr VCIndicatorLength
  if (attr->getVCIndicatorLength() > 0)
  {
    char *defaultValueAdj =
           new(generator->getSpace()) char[attr->getDefaultValueStorageLength()];
    short len;
    char *lenPtr;
    char *valuePtr = defaultValueAdj;

    if (attr->getNullFlag())
    {
      str_pad(valuePtr, ExpTupleDesc::NULL_INDICATOR_LENGTH, 0);
      valuePtr += ExpTupleDesc::NULL_INDICATOR_LENGTH;
    }

    if (attr->getVCIndicatorLength() == sizeof(short))
    {
      len = (short)length;
      lenPtr = (char *)&len;
    }
    else
      lenPtr = (char *)&length;

    str_cpy_all(valuePtr, lenPtr, attr->getVCIndicatorLength());
    valuePtr += attr->getVCIndicatorLength();

    str_cpy_all(valuePtr, defaultValue + offset, length);
    attr->setDefaultValue(dc, defaultValueAdj);
  }
  else
    attr->setDefaultValue(dc, defaultValue);

  return 0;
}

void ExpGenerator::addDefaultValues(const ValueIdList & val_id_list,
				    const NAColumnArray &naColArr,
				    ExpTupleDesc * tupleDesc,
				    NABoolean inputIsColumnList)
{
  NABoolean setAddedColumn = FALSE;
  NAString defVal;

  for (unsigned short i = 0; i < val_id_list.entries(); i++)
    {
      NAColumn * col = NULL;
      
      if (inputIsColumnList)
	{
	  ItemExpr * ie = val_id_list[i].getItemExpr();
	  GenAssert(((ie->getOperatorType() == ITM_BASECOLUMN) ||
		     (ie->getOperatorType() == ITM_INDEXCOLUMN)), 
		    "Must be a base or index column");

	  if (ie->getOperatorType() == ITM_BASECOLUMN)
	    {
	      BaseColumn * bc = (BaseColumn *)ie;
	      col = bc->getNAColumn();
	    }
	  else
	    {
	      IndexColumn * ic = (IndexColumn *)ie;
	      col = ic->getNAColumn();
	    }
	}
      else
	{
	  col = naColArr.getColumn(i);
	}

      Attributes * attr = (tupleDesc ? tupleDesc->getAttr(i) : NULL);

      if (attr)
	{
	  short rc = addDefaultValue(col, attr);
	  if (rc)
	    {
	      GenExit();
	      return;
	    }
	}

      if (col->isAddedColumn())
	{
	  setAddedColumn = TRUE;

          // the i-th attribute
          Attributes * ithAttr =
            generator->getMapInfo(val_id_list[i])->getAttr();
          ithAttr->setAddedCol();
          ithAttr->setDefaultFieldNum(i);

	  if (attr)
            {
              attr->setAddedCol();
              attr->setDefaultFieldNum(i);
            }
	}
    } // for

  if ((setAddedColumn) && (tupleDesc))
    tupleDesc->setAddedField();

  // Set EID Olt optimization off for tables with added columns.
  if ( setAddedColumn
       && !( CmpCommon::getDefault( EXPAND_DP2_SHORT_ROWS ) == DF_ON ) )
    //    generator->doOltQueryOptimization() = FALSE;
    generator->oltOptInfo()->setOltEidOpt(FALSE);
}

void ExpGenerator::copyDefaultValues(
				     ExpTupleDesc * tgtTupleDesc,
				     ExpTupleDesc * srcTupleDesc)
{
  Lng32 numAttrs = MINOF(srcTupleDesc->numAttrs(), tgtTupleDesc->numAttrs());
  for (CollIndex i = 0; i < numAttrs; i++)
    {
      Attributes * srcAttr = srcTupleDesc->getAttr(i);
      Attributes * tgtAttr = tgtTupleDesc->getAttr(i);

      if (srcAttr->isAddedCol())
	tgtAttr->setAddedCol();
      
      tgtAttr->setDefaultClass(srcAttr->getDefaultClass());

      if (srcAttr->getDefaultValue())
	{
          Lng32 tgtDefLen = tgtAttr->getDefaultValueStorageLength();
          Lng32 srcDefLen = srcAttr->getDefaultValueStorageLength();
          char* srcDefVal = srcAttr->getDefaultValue();
	  char * tgtDefVal = new(generator->getSpace()) char[tgtDefLen];

          // if source and target def storage lengths dont match, then
          // need to move each part (null, vclen, data) separately.
          if ((tgtDefLen == srcDefLen) &&
              (tgtAttr->getNullFlag() == srcAttr->getNullFlag()) &&
              (tgtAttr->getVCIndicatorLength() == srcAttr->getVCIndicatorLength()) &&
              (tgtAttr->getLength() == srcAttr->getLength()))
            {
              str_cpy_all(tgtDefVal, srcDefVal, srcDefLen);
            }
          else
            {
              char * tgtDefValCurr = tgtDefVal;

              short nullVal = 0;
              if (srcAttr->getNullFlag())
                {
                  str_cpy_all((char*)&nullVal, srcDefVal, 
                              ExpTupleDesc::NULL_INDICATOR_LENGTH);
                  srcDefVal += ExpTupleDesc::NULL_INDICATOR_LENGTH;
                }
              
              if (tgtAttr->getNullFlag())
                {
                  str_cpy_all(tgtDefVal, (char*)&nullVal, 
                              ExpTupleDesc::NULL_INDICATOR_LENGTH);
                  tgtDefValCurr += ExpTupleDesc::NULL_INDICATOR_LENGTH;
                }
              
              Lng32 srcDefLen    = srcAttr->getLength(srcDefVal);
              tgtAttr->setVarLength(srcDefLen, tgtDefValCurr);
              tgtDefValCurr += tgtAttr->getVCIndicatorLength();
              srcDefVal += srcAttr->getVCIndicatorLength();

              str_cpy_all(tgtDefValCurr, srcDefVal, srcDefLen);
            }
	  
	  tgtAttr->setDefaultValue(srcAttr->getDefaultClass(), tgtDefVal);
	}
    }
  
}

short ExpGenerator::genColNameList(const NAColumnArray &naColArr,
				   Queue* &colNameList)
{
  colNameList = NULL;
  if (naColArr.entries() == 0)
    return 0;

  Space * space = generator->getSpace();

  colNameList = new(space) Queue(space);
  for (unsigned short i = 0; i < naColArr.entries(); i++)
    {
      NAColumn * col = naColArr.getColumn(i);

      char * colName =
	space->allocateAndCopyToAlignedSpace(col->getColName().data(),
					     col->getColName().length());

      colNameList->insert(colName);
    }

  return 0;
}

short ExpGenerator::handleUnsupportedCast(Cast * castNode)
{
  const NAType &srcNAType = castNode->child(0)->getValueId().getType();
  const NAType &tgtNAType = castNode->getValueId().getType();
  short srcFsType = srcNAType.getFSDatatype();
  short tgtFsType = tgtNAType.getFSDatatype();

  // check if conversion involves tinyint or largeint unsigned
  NABoolean tinyintCast = FALSE;
  NABoolean largeUnsignedCast = FALSE;
  if (((DFS2REC::isTinyint(srcFsType)) &&
       (NOT DFS2REC::isTinyint(tgtFsType))) ||
      ((NOT DFS2REC::isTinyint(srcFsType)) &&
       (DFS2REC::isTinyint(tgtFsType))))
    tinyintCast = TRUE;

  if ((srcFsType == REC_BIN64_UNSIGNED) ||
      (tgtFsType == REC_BIN64_UNSIGNED))
    largeUnsignedCast = TRUE;

  if ((NOT tinyintCast) && (NOT largeUnsignedCast))
    return 0;

  ex_conv_clause tempClause;
  if (tempClause.isConversionSupported(srcFsType, srcNAType.getNominalSize(),
                                       tgtFsType, tgtNAType.getNominalSize()))
    return 0;

  // if this cast involved a tinyint and is unsupported, convert to
  // smallint.
  if (tinyintCast)
    {
      // add a Cast node to convert from/to tinyint to/from small int.
      NumericType * newType = NULL;
      if (DFS2REC::isInterval(srcFsType)) // interval to tinyint
        {
          const IntervalType &srcInt = (IntervalType&)srcNAType; 
          newType = new (generator->wHeap())
            SQLNumeric(generator->wHeap(), sizeof(short), srcInt.getTotalPrecision(), 
                       srcInt.getFractionPrecision(),
                       TRUE, srcNAType.supportsSQLnull());
        }
      else if (DFS2REC::isInterval(tgtFsType)) // tinyint to interval
        {
          const NumericType &srcNum = (NumericType&)srcNAType; 
           newType = new (generator->wHeap())
             SQLNumeric(generator->wHeap(), sizeof(short), srcNum.getPrecision(), 
                        srcNum.getScale(),
                        NOT srcNum.isUnsigned(), srcNAType.supportsSQLnull());
        }
      else if (DFS2REC::isTinyint(srcFsType)) // tinyint to non-tinyint
        {
          const NumericType &srcNum = (NumericType&)srcNAType; 
          
          if ((srcNum.getScale() == 0) &&
              (srcNum.binaryPrecision()))
            newType = new (generator->wHeap())
              SQLSmall(generator->wHeap(), NOT srcNum.isUnsigned(),
                       tgtNAType.supportsSQLnull());
          else
            newType = new (generator->wHeap())
              SQLNumeric(generator->wHeap(), sizeof(short), srcNum.getPrecision(), 
                         srcNum.getScale(),
                         NOT srcNum.isUnsigned(), 
                         tgtNAType.supportsSQLnull());
        }
      else if (DFS2REC::isTinyint(tgtFsType)) // non-tinyint to tinyint
        {
          const NumericType &srcNum = (NumericType&)srcNAType; 
          const NumericType &tgtNum = (NumericType&)tgtNAType; 
          
          if ((tgtNum.getScale() == 0) &&
              (tgtNum.binaryPrecision()))
            newType = new (generator->wHeap())
              SQLSmall(generator->wHeap(), NOT tgtNum.isUnsigned(),
                       tgtNAType.supportsSQLnull());
          else
            newType = new (generator->wHeap())
              SQLNumeric(generator->wHeap(), sizeof(short), tgtNum.getPrecision(), 
                         tgtNum.getScale(),
                         NOT tgtNum.isUnsigned(), 
                         tgtNAType.supportsSQLnull());
        }

      ItemExpr * newChild =
        new (generator->wHeap())
        Cast(castNode->child(0), newType);
      ((Cast*)newChild)->setFlags(castNode->getFlags());
      castNode->setSrcIsVarcharPtr(FALSE);
      newChild = newChild->bindNode(generator->getBindWA());
      newChild = newChild->preCodeGen(generator);
      if (! newChild)
        return -1;
      
      castNode->setChild(0, newChild);
      srcFsType = castNode->child(0)->getValueId().getType().getFSDatatype();
    }

  if ((srcFsType == REC_BIN64_UNSIGNED) ||
      (tgtFsType == REC_BIN64_UNSIGNED))
    {
      const NumericType &numSrc = (NumericType&)srcNAType;
      // add a Cast node to convert to sqllargeint signed.
      ItemExpr * newChild =
        new (generator->wHeap())
        Cast(castNode->child(0),
             new (generator->wHeap())
             SQLLargeInt(generator->wHeap(), numSrc.getScale(), 1,
                         TRUE,
                         srcNAType.supportsSQLnull()));
      ((Cast*)newChild)->setFlags(castNode->getFlags());
      castNode->setSrcIsVarcharPtr(FALSE);
      newChild = newChild->bindNode(generator->getBindWA());
      newChild = newChild->preCodeGen(generator);
      if (! newChild)
        return -1;
      
      castNode->setChild(0, newChild);
      srcFsType = castNode->child(0)->getValueId().getType().getFSDatatype();
    }

  return 0;
}

/////////////////////////////////////////////////////////////////
// this function returns an expr tree that multiplies the source
// by 10 ** exponent.  If exponent is negative, the returned expr
// tree divides the source by 10 ** (- exponent).
/////////////////////////////////////////////////////////////////
ItemExpr * ExpGenerator::scaleBy10x(const ValueId & source, Lng32 exponent)
{
  ItemExpr * retTree = source.getItemExpr();
  OperatorTypeEnum srcOrigOpType = retTree->origOpType(); 

  //
  // If the exponent is 0, return the source tree unchanged.
  //
  if (exponent == 0)
    return retTree;

  NABoolean downscale = (exponent < 0 ? TRUE : FALSE);
  
  // Retain this flag and pass it on to next ITM_DIVIDE
  // operator if any. This flag indicates that no special
  // rounding be performed. This is set in the case of
  // date-time kind of operations.
  NABoolean ignoreSpecialRounding = 
    (retTree->getOperatorType() != ITM_DIVIDE)? FALSE :
    ((BiArith*)retTree)->ignoreSpecialRounding();
  //
  // If the exponent is positive, multiply the source.  Otherwise, divide the
  // source.
  //
  char *str = new(wHeap()) char[ 100 + abs( exponent ) ];
  if (exponent > 0)
    strcpy(str, "@A1 * 1");
  else {
    strcpy(str, "@A1 / 1");
    exponent = - exponent;
  }
  do {
    strcat(str, "0");
  } while (--exponent > 0);
  retTree = createExprTree(str, 0, 1, retTree);

  // inherit and propogate OrigOpType_
  retTree->setOrigOpType(srcOrigOpType);

  NADELETEBASIC( str, wHeap() );

  if ((retTree) && (downscale) &&
      (retTree->getOperatorType() == ITM_DIVIDE))
    {
      ((BiArith*)retTree)->setDivToDownscale(TRUE);

      if(ignoreSpecialRounding)
        ((BiArith*)retTree)->setIgnoreSpecialRounding();
    }

  //
  // Bind the tree.  If necessary, change the scale of the result to match the
  // scale of the source, so the generator won't upscale the numerator.
  //
  retTree->bindNode(generator->getBindWA());
  const NAType& resultType = retTree->getValueId().getType();
  if (resultType.getTypeQualifier() == NA_NUMERIC_TYPE) {
    Lng32 sourceScale = ((NumericType &) source.getType()).getScale();
    if (((NumericType &) resultType).getScale() != sourceScale)
      ((NumericType &) resultType).setScale(sourceScale);
  }
  return retTree;
}

/////////////////////////////////////////////////////////////////
// if the scales of the source and target types are not
// the same, this function returns an expr tree to upscale
// or downscale the source to the target scale by multiplying
// the source by 10 ** (target_scale - source_scale).
/////////////////////////////////////////////////////////////////
ItemExpr * ExpGenerator::matchScales(const ValueId & source,
				     const NAType & targetType)
{
  ItemExpr * sourceTree = source.getItemExpr();
  ItemExpr * retTree = matchScalesNoCast(source,targetType);

  if (sourceTree != retTree)
    {
      // we generated an expression to change the scale of the source;
      // now add a Cast to make the source datatype match the target
      retTree = new(wHeap()) Cast(retTree, &targetType);
      retTree->bindNode(generator->getBindWA());

      if (handleUnsupportedCast((Cast*)retTree))
        return NULL;

      // Mark this as preCodeGenned so we don't generate more
      // scaling code to handle possible scale differences in the
      // new Cast (note that matchScalesNoCast() in this case has
      // already preCodeGenned the child of the Cast)
      retTree->markAsPreCodeGenned();
    }

  // Note that if sourceTree == retTree above, the tree might not
  // have been preCodeGenned; we let the caller take care of that.

  return retTree;
}


//////////////////////////////////////////////////////////////////
// This function is the "guts" of matchScales(), but it does not
// cast the resulting expression into the target type.  Usually,
// we get to this function via matchScales().  The one exception
// is in key building, where we wish to detect truncation and overflow
// errors due to scaling in a special way.  So, key building calls
// this method directly to avoid generating a Cast.
//////////////////////////////////////////////////////////////////
ItemExpr * ExpGenerator::matchScalesNoCast(const ValueId & source,
					   const NAType & targetType)
{
  ItemExpr * retTree = source.getItemExpr();
  //
  // If the source or target is neither interval nor numeric, return the
  // source tree unchanged.
  //
  NABuiltInTypeEnum sourceTypeQual = source.getType().getTypeQualifier();
  NABuiltInTypeEnum targetTypeQual = targetType.getTypeQualifier();

  if (((sourceTypeQual != NA_NUMERIC_TYPE) &&
       (sourceTypeQual != NA_INTERVAL_TYPE)) ||
      ((targetTypeQual != NA_NUMERIC_TYPE) &&
       (targetTypeQual != NA_INTERVAL_TYPE)))
    return retTree;

  // If it is a null constant no need to scale it.
  if (retTree->getOperatorType() == ITM_CONSTANT)
    {
      ConstValue * constant = (ConstValue *) retTree;
      if (constant->isNull())
        return retTree;
    }

  //
  // Upscale or downscale the source to the target scale.  If the source scale
  // is the same as the target scale, return the source tree unchanged.
  //
  Lng32 sourceScale = (source.getType().getTypeQualifier() == NA_NUMERIC_TYPE)
    ? ((NumericType &) source.getType()).getScale()
    : ((IntervalType &) source.getType()).getFractionPrecision();
  Lng32 targetScale = (targetType.getTypeQualifier() == NA_NUMERIC_TYPE)
    ? ((NumericType &) targetType).getScale()
    : ((IntervalType &) targetType).getFractionPrecision();
  if (sourceScale == targetScale)
    return retTree;

  if ((sourceTypeQual == NA_INTERVAL_TYPE) &&
      (targetTypeQual == NA_INTERVAL_TYPE))
    {
    // the Cast operator can do interval to interval scaling itself
    retTree = new(wHeap()) Cast(retTree,&targetType);
    retTree->bindNode(generator->getBindWA());
    }
  else {
    if (((NumericType &) source.getType()).isExact() &&
        (NOT((NumericType &)targetType).isExact()) &&
	(targetScale != sourceScale)) {
    retTree = new(wHeap()) Cast(retTree,&targetType);
    retTree->bindNode(generator->getBindWA());

    if (handleUnsupportedCast((Cast*)retTree))
      return NULL;

    retTree->markAsPreCodeGenned();
    retTree = scaleBy10x(retTree->getValueId(), targetScale - sourceScale);
    }
    else
      retTree = scaleBy10x(source, targetScale - sourceScale);
  };

  retTree = retTree->preCodeGen(generator);

  return retTree;
}

/////////////////////////////////////////////////////////////////
// if the source is an interval, this function returns an expr
// tree to convert the source type to numeric.
/////////////////////////////////////////////////////////////////
ItemExpr * ExpGenerator::convertIntervalToNumeric(const ValueId & source)
{
  ItemExpr * retTree = source.getItemExpr();
  //
  // If the source is not an interval, return the source tree unchanged.
  //
  if (source.getType().getTypeQualifier() != NA_INTERVAL_TYPE)
    return retTree;
  IntervalType& sourceInterval = (IntervalType&) source.getType();
  //
  // If the source interval does not consist of only a single datetime field,
  // cast it to an interval consisting of only the end field.
  //
  if (sourceInterval.getStartField() != sourceInterval.getEndField())
    retTree = new(wHeap())
      Cast(retTree, new(wHeap())
	   SQLInterval(wHeap(), sourceInterval.supportsSQLnull(),
		       sourceInterval.getEndField(),
		       sourceInterval.getTotalPrecision() -
		       sourceInterval.getFractionPrecision(),
		       sourceInterval.getEndField(),
		       sourceInterval.getFractionPrecision()));
  //
  // Convert the source interval to numeric, bind the tree, and return it.
  //
  const Int16 DisAmbiguate = 0;
  retTree = new(wHeap())
    Cast(retTree, new(wHeap()) SQLNumeric(wHeap(), TRUE, /* signed */
				     sourceInterval.getTotalPrecision(),
				     sourceInterval.getFractionPrecision(),
				     DisAmbiguate, // added for 64bit proj.
				     sourceInterval.supportsSQLnull()));
  retTree->bindNode(generator->getBindWA());

  return retTree;
}

/////////////////////////////////////////////////////////////////
// if the source is a numeric, this function returns an expr
// tree to convert the source type to interval.
/////////////////////////////////////////////////////////////////
ItemExpr * ExpGenerator::convertNumericToInterval(const ValueId & source,
                                                  const NAType & targetType)
{
  ItemExpr * retTree = source.getItemExpr();
  //
  // If the source is not numeric or the target type is not an interval,
  // return the source tree unchanged.
  //
  if ((source.getType().getTypeQualifier() != NA_NUMERIC_TYPE) ||
      (targetType.getTypeQualifier() != NA_INTERVAL_TYPE))
    return retTree;
  NumericType& sourceNumeric = (NumericType&) source.getType();
  IntervalType& targetInterval = (IntervalType&) targetType;

  //
  // Factor the source so that its scale matches the fractional precision of
  // the target, and cast the result to an interval consisting of the target's
  // end field.
  //

  SQLInterval *interval =
    new(wHeap()) SQLInterval(wHeap(), targetInterval.supportsSQLnull(),
                    targetInterval.getEndField(),
                    targetInterval.getTotalPrecision() -
                      targetInterval.getFractionPrecision(),
                    targetInterval.getEndField(),
                    targetInterval.getFractionPrecision());

  retTree = ((UInt32) sourceNumeric.getScale() !=
             targetInterval.getFractionPrecision())
            ? matchScales(retTree->getValueId(), *interval)
            : new(wHeap()) Cast(retTree, interval);
  //
  // Bind the tree and return it.
  //
  retTree->bindNode(generator->getBindWA());
  return retTree;
}

/////////////////////////////////////////////////////////////////
// if the source and target are intervals with different end fields,
// this function returns an expr tree to convert the source type to
// match the target's end field.
/////////////////////////////////////////////////////////////////
ItemExpr * ExpGenerator::matchIntervalEndFields(const ValueId & source,
                                                const NAType & targetType)
{
  ItemExpr * retTree = source.getItemExpr();
  //
  // If either the source or target is not an interval, or if they both have
  // the same end fields, return the source tree unchanged.
  //
  if ((source.getType().getTypeQualifier() != NA_INTERVAL_TYPE) ||
      (targetType.getTypeQualifier() != NA_INTERVAL_TYPE))
    return retTree;
  IntervalType& sourceInterval = (IntervalType&) source.getType();
  IntervalType& targetInterval = (IntervalType&) targetType;
  if (sourceInterval.getEndField() == targetInterval.getEndField())
    return retTree;

  // Create a Cast node to convert to the target type.
  retTree = new(wHeap()) Cast(retTree,&targetType);
  retTree->bindNode(generator->getBindWA());
  return retTree;
}


// input is a ValueIdSet of aggregate nodes
short ExpGenerator::generateAggrExpr(const ValueIdSet &val_id_set,
				     ex_expr::exp_node_type /* node_type */,
				     ex_expr ** expr,
				     short gen_last_clause,
				     NABoolean groupByOperation,
                                     const ValueIdSet *addedInitSet/*optional*/
                                     )
{
  ///////////////////////////////////////////////////////////////////////
  // 3 expressions are generated to evaluate the aggregate.
  // They are used to initialize, evaluate the aggr for each row,
  // and finalize with no rows (move nulls)
  //
  // Different expressions are generated depending on whether operand
  // is nullable or non-nullabls.
  //
  // for MIN, MAX and SUM aggregates.
  //
  // Case 1: when the operand is non-nullable.
  //         For non-grouping operation,
  //         NULL value is moved to result if no rows are found.
  // Case 2: when operand is nullable.
  //         This case needs extra handling for the scenario where all
  //         values of operand that are part of the same group, contain
  //         null values. In this case, the result becomes null.
  //
  //
  // Initialize Expr:
  //
  //                  (converted to)
  // Case 1:
  //   Sum           --------------->   Aggr = 0
  //   Min           --------------->   Aggr = Max value for that datatype
  //   Max           --------------->   Aggr = Min value for that datatype
  //
  // Case 2:
  //   Min/Max/Sum   --------------->   Aggr = NULL
  //
  // Case 1 and 2:
  //   Count         --------------->   Aggr = 0
  //   One/Any True  --------------->   Aggr = FALSE.
  //
  //
  // Perrec Eval Expr:
  // =================
  //
  // MIN Aggregate:
  // Case 1:
  //   Min(A)   ------> AggrMinMax(A, "A < Min(A)");
  // Case 2:
  //   Min(A)   ------> Case
  //                       When Min(A) is NULL then Min(A) = A
  //                       When A is not null AND A < Min(A) Then Min(A) = A
  //                    End
  //
  // MAX Aggregate:
  // Case 1:
  //   Max(A)   ------> AggrMinMax(A, "A > Max(A)");
  // Case 2:
  //   Max(A)   ------> Case
  //                       When Max(A) is NULL then Max(A) = A
  //                       When A is not null AND A > Max(A) Then Max(A) = A
  //                    End
  //
  // SUM Aggregate:
  // Case 1:
  //   Sum(A)   ------> Sum(A) + A
  //
  // Case 2:
  //   Sum(A)   ------> Case
  //                       When Sum(A) is NULL then Sum(A) = A
  //                       When A is not null Then Sum(A) = Sum(A) + A
  //                    End
  //
  // COUNT(A) Aggregate:
  // Case 1:
  //   Count(A)     ------>  Count(A) + 1;
  //
  // Case 2:
  //   Count(A)    -------> Count(A) + Case
  //                                     When A is not null then 1 else 0
  //                                   End
  //
  // Other aggregates, all cases:
  //   Count(*) ------> Count(*) = Count(*) + 1
  //   OneTrue(A)  ------> Aggr = TRUE
  //   AnyTrue(A)  ------> Case
  //                         When A is True then TRUE  (caller short circuits)
  //                         When A is Unknown then NULL
  //                       End
  //
  //
  // Finalize (no rows found). Case 1(with no groupBy) and 2:
  //
  //   Non-count Aggr = NULL
  //
  ////////////////////////////////////////////////////////////////////////


  // generate code to evaluate the initialize expression
  ValueId val_id;
  ItemExpr * newExpr = NULL;
  ValueIdSet * newValIdSet = new(wHeap()) ValueIdSet();
  MapInfo * map_info;

  CollIndex num_aggr_entries = val_id_set.entries();

  short case_;
  for (val_id = val_id_set.init(); val_id_set.next(val_id); val_id_set.advance(val_id))
    {
      ItemExpr * item_expr = val_id.getValueDesc()->getItemExpr();
      if (NOT item_expr->child(0)->castToItemExpr()->getValueId().getType().supportsSQLnull())
	case_ = 1;
      else
	case_ = 2;

      // the original value id list contains the aggregate nodes
      // which are being converted to an equivalent tree in some cases
      // to compute their values. Mark the original aggr nodes
      // to indicate that code has been generated for them.
      // We don't want to generate aggregate clauses for the
      // original aggregate nodes.

      switch (item_expr->getOperatorType())
	{
	case ITM_MIN:
	case ITM_MAX:
	case ITM_SUM:
	  {
	    generator->getMapInfo(val_id)->codeGenerated();
	    ItemExpr * initVal;
	    if (case_ == 1)
		{
		  if (item_expr->getOperatorType() == ITM_MIN)
		    initVal = getMinMaxValue(val_id.getType(),
					     -2/*max without null*/
					     );
		  else if (item_expr->getOperatorType() == ITM_MAX)
		    initVal = getMinMaxValue(val_id.getType(),
					     0 /* min value */
					     );
		  else //SUM
		    {
		      if (val_id.getType().getTypeQualifier() == NA_INTERVAL_TYPE)
			{
			  Int64 zero = 0;
			  NAType *type = val_id.getType().newCopy(wHeap());
			  type->setNullable(FALSE);
			  NAString * nas = new (wHeap()) NAString("0", wHeap());
			  initVal =
			    new(wHeap()) ConstValue(type,
						    (void *)&zero,
						    type->getNominalSize(),
						    nas);
			}
		      else
	  		initVal = new(wHeap()) ConstValue(0);
		  }
		  newExpr = new(wHeap())
		    Cast(initVal, &(val_id.getType()));
		}
	    else // Case 2
	      {
		initVal = generateNullConst(val_id.getType());
		NAType *newType
		  = item_expr->getValueId().getType().newCopy(wHeap());
		newType->setSQLnullFlag();

		newExpr = new(wHeap())
		  Cast(initVal, newType );
	      }

	  }
	  break;

	case ITM_COUNT:
	case ITM_COUNT_NONULL:
	  {
	    generator->getMapInfo(val_id)->codeGenerated();
            newExpr = new(wHeap())
              Cast(new(wHeap()) ConstValue(0), &(val_id.getType()));
	  }
	  break;

	case ITM_ONE_TRUE:
	case ITM_ANY_TRUE:
	  {
	    GenAssert((num_aggr_entries == 1), "Cannot have more than one 'special' aggregates.");

	    generator->getMapInfo(val_id)->codeGenerated();

	    // move boolean FALSE to result
	    newExpr = new(wHeap()) BoolVal(ITM_RETURN_FALSE);
	  }
	  break;

	case ITM_ANY_TRUE_MAX:
	  {
	    GenAssert((num_aggr_entries == 1), "Cannot have more than one 'special' aggregates.");

	    // move boolean FALSE to result
	    newExpr = new(wHeap()) BoolVal(ITM_RETURN_FALSE);
	  }
	  break;

	case ITM_ONE_ROW:
	  {

	    // move null value to all outputs
            ValueId outvid;
            ValueIdSet init_val_id_set;
           
            init_val_id_set += *addedInitSet; // other values to be init'ed.

            for ( outvid = init_val_id_set.init();
                           init_val_id_set.next(outvid);
                           init_val_id_set.advance(outvid) )
            {
              NAType *outType = outvid.getType().newCopy(wHeap());

              // Should be nullable, since one row aggregates are inst-null'ed.
              // except if this is an output from the aggregate node, plus it's
              // boolean.
              if (!outType->supportsSQLnull())
              {
               // The following assertion has been commented out because of the case where
               // although subqueries are nullable the statement enclosing the subquery is
               // not but if the subquery does not contain reference to the outer tables then
               // the whole statement can be pushed down to this side of the tree.
               // GenAssert(outType->getTypeQualifier() == NA_BOOLEAN_TYPE),
               // "outputs from one_row_aggr node should be nullable or BOOLEAN"
               // );
                outType->setNullable(TRUE);
              }

              // Make a null const of the same type as the value to be init'ed.
	      ConstValue * nullv = generateNullConst(outvid.getType());

              // Make a copy of the value, used in the generation of initExpr.
              newExpr = new(wHeap()) Cast(nullv,outType);
	      newExpr = newExpr->bindNode(generator->getBindWA());
	      newValIdSet->insert(newExpr->getValueId());

              // Attach the destination location to the copy. Used later to
              // generate the initExpr.
              Attributes *attr = generator->getMapInfo(outvid)->getAttr();
	      map_info = generator->addMapInfo(newExpr->getValueId(),attr);

              // seems unnecessary, since attr is passed in the call above. ??
	      // (map_info->getAttr())->copyLocationAttrs(attr);

            } // for

            newExpr = NULL;
	  }
	  break;

	case ITM_PIVOT_GROUP:
	  {
	    generator->getMapInfo(val_id)->codeGenerated();
            newExpr = new(wHeap())
              Cast(new(wHeap()) ConstValue(""), &(val_id.getType()));
	  }
	  break;

	default:
	  newExpr = NULL;
	  break;

	}

      if (newExpr != NULL)
	{
	  newExpr->bindNode(generator->getBindWA());
	  newValIdSet->insert(newExpr->getValueId());

	  // assign the data attributes of the aggr node to the convert node.
	  // This will make the result of initialization be moved to the
	  // aggregate location.
          Attributes * attr = generator->getMapInfo(val_id)->getAttr();
	  map_info = generator->addMapInfo(newExpr->getValueId(), attr);
	  (map_info->getAttr())->copyLocationAttrs(attr);
          if(attr->isForceFixed())
            (map_info->getAttr())->setForceFixed();
	}

    }

  ex_expr * init_expr = 0;
  generateSetExpr(*newValIdSet, ex_expr::exp_ARITH_EXPR, &init_expr);

  delete newValIdSet;

  // generate expression to move in null value as the aggr result
  // on an empty set. Applies to all non-count aggr for non-grouping
  // operation.
  ex_expr * final_null_expr = 0;
  if (groupByOperation == FALSE)
    {
      newValIdSet = new(wHeap()) ValueIdSet();
      for (val_id = val_id_set.init(); val_id_set.next(val_id); val_id_set.advance(val_id))
	{
	  ItemExpr * item_expr = val_id.getValueDesc()->getItemExpr();
          if(!item_expr->isAnAggregate()) {
            newExpr = NULL;
          } else {
            // part of fix to genesis case 10-070628-2258, soln 10-070610-5412:
            // guard against boundary case queries against empty table t
            //   "select count(distinct i), count(*) from t"
            //   "select avg(distinct i), count(*) from t"
            //   "select sum(distinct i), count(*) from t"
            // which transforms 
            //   "count(*)" into "sum(count(*))"
            // and can emit false alarms
            //   "error 8421 null cannot be assigned to a not null column"
            // when t is an empty table. 
            // The "sum" in the rewritten aggregate transformed by 
            // Aggregate::rewriteForStageEvaluation() should be treated like the
            // "count(*)" case below so it returns 0 when t is an empty table.
            switch (((Aggregate*)item_expr)->getEffectiveOperatorType())
            {
            case ITM_SUM:
            case ITM_MIN:
            case ITM_MAX:
            case ITM_ONEROW:
            case ITM_PIVOT_GROUP:
	      {
		generator->getMapInfo(val_id)->codeGenerated();
		ConstValue * const_value =
		  generateNullConst(val_id.getType());

		NAType *newType
		  = item_expr->getValueId().getType().newCopy(wHeap());
		newType->setSQLnullFlag();

		newExpr = new(wHeap())
		  Cast(const_value, newType );

	      }
	      break;

	    case ITM_COUNT:
	    case ITM_COUNT_NONULL:
	    case ITM_ONE_TRUE:
	    case ITM_ANY_TRUE:
	    case ITM_ANY_TRUE_MAX:
	    case ITM_ONE_ROW:
	      {
		newExpr = NULL;
	      }
	      break;

	    default:
	      newExpr = NULL;
	      break;

	    }
          }
	  if (newExpr != NULL)
	    {
	      newExpr->bindNode(generator->getBindWA());
	      newValIdSet->insert(newExpr->getValueId());

	      // assign the data attributes of the aggr node to the convert node.
	      // This will make the final null value to be moved to the
	      // aggregate location.
              Attributes * attr = generator->getMapInfo(val_id)->getAttr();
	      map_info = generator->addMapInfo(newExpr->getValueId(), attr);
	      (map_info->getAttr())->copyLocationAttrs(attr);
              if(attr->isForceFixed())
                (map_info->getAttr())->setForceFixed();
	    }
          
	} // for loop

      generateSetExpr(*newValIdSet, ex_expr::exp_ARITH_EXPR,
                      &final_null_expr);

      delete newValIdSet;
    }

  newValIdSet = new(wHeap())  ValueIdSet();

  // generate expression tree to evaluate the perrec aggr expression
  newExpr = 0;
  NABoolean raiseErrorGenerated = FALSE;
  ValueIdList NullSwitcharooVidList;
  for (val_id = val_id_set.init(); val_id_set.next(val_id); val_id_set.advance(val_id))
    {
      NABoolean nullSwitcharoo = FALSE;
      ItemExpr * item_expr = val_id.getValueDesc()->getItemExpr();
      if (NOT item_expr->child(0)->castToItemExpr()->getValueId().getType().supportsSQLnull())
	case_ = 1;
      else
	case_ = 2;

      switch (item_expr->getOperatorType())
	{
	case ITM_MIN:
	  {
	    if (case_ == 1)
	      {
		newExpr =
		  createExprTree("@A2 < @A1", 0, 2, item_expr,
				 item_expr->child(0));
		newExpr =
		  new(wHeap()) AggrMinMax(item_expr->child(0), newExpr);
		if (item_expr->getValueId().getType().supportsSQLnull())
		  nullSwitcharoo = TRUE;
	      } // Case 1
	    else
	      { //Case 2
                newExpr =
                  createExprTree("@A1 IS NULL OR"
                                 "(@A2 IS NOT NULL AND @A2 < @A1)",
                                 0, 2, item_expr, item_expr->child(0));
		newExpr =
                  new(wHeap()) AggrMinMax(item_expr->child(0), newExpr);
	      } // Case 2
	  }
  	  break;

	case ITM_MAX:
	  {
	    if (case_ == 1)
	      {
		newExpr = createExprTree("@A2 > @A1",
                                         0, 2, item_expr, item_expr->child(0));
		newExpr =
                  new(wHeap()) AggrMinMax(item_expr->child(0), newExpr);
		if (item_expr->getValueId().getType().supportsSQLnull())
		  nullSwitcharoo = TRUE;
	      }
	    else
	      {
                newExpr =
                  createExprTree("@A1 IS NULL OR"
                                 "(@A2 IS NOT NULL AND @A2 > @A1)",
                                 0, 2, item_expr, item_expr->child(0));
		newExpr =
                  new(wHeap()) AggrMinMax(item_expr->child(0), newExpr);
	      }
	  }
	  break;

	  // SUM --
	  //
	case ITM_SUM:
	  {
	    // The sum expression is not nullable. Cast the expression
	    // to the same width as the SUM but retain it non-nullability.
	    // BiArithSum has the following semantics:
	    //      if(operandA IS NOT NULL)
	    //        if(operandB IS NOT NULL) SUM = operandA + operandB
	    //        else SUM = operandA
	    //
	    if (case_ == 1)
	      {
		NAType *sumType
		  = item_expr->getValueId().getType().newCopy(wHeap());
		sumType->setNullable(FALSE);
		if (item_expr->child(0)->getValueId().getType().supportsSQLnull())
		  newExpr = new(wHeap()) Cast(item_expr->child(0),
					      sumType, ITM_CAST);
		else
		  newExpr = item_expr->child(0);
		//newExpr = new(wHeap()) Cast(item_expr->child(0),
		//			    sumType,
		//			    ITM_CAST);
		newExpr = new(wHeap()) BiArithSum(ITM_PLUS,
						  newExpr,
						  item_expr);
	      }
	    // The SUM expression is nullable. Cast the expression to the
	    // same width as the SUM. Then apply BiArithSum as above.
	    //
	    else // case_ == 2
	      {
		const NAType &sumType = item_expr->getValueId().getType();
		newExpr = new(wHeap()) Cast(item_expr->child(0),
					    &sumType,
					    ITM_CAST);
		newExpr = new(wHeap()) BiArithSum(ITM_PLUS,
					       newExpr,
					       item_expr);
	      }
	  }
	  break;

	  // COUNT (everything)
	  // BiArithCount has the following semantics:
	  //      if(operandA IS NOT NULL)
	  //        if(operandB IS NOT NULL) SUM = operandB + 1
	  //        else SUM = 1;
	  //
	case ITM_COUNT:
	  {
	    NAType *sumType
	      = item_expr->getValueId().getType().newCopy(wHeap());
	    sumType->setNullable(FALSE);

	    newExpr = new(wHeap()) ConstValue(1);
	    newExpr = new(wHeap()) Cast(newExpr, sumType, ITM_CAST);
	    newExpr = new(wHeap()) BiArithSum(ITM_PLUS,
					      newExpr,
					      item_expr);
	  }
	  break;

	  // COUNT (non nulls)
	  //
	case ITM_COUNT_NONULL:
	  {
	    // The COUNT attribute is non nullable.
	    //
	    NAType *sumType
	      = item_expr->getValueId().getType().newCopy(wHeap());
	    sumType->setNullable(FALSE);
	    if (case_ == 1)
	      {
		newExpr = new(wHeap()) ConstValue(1);
		newExpr = new(wHeap()) Cast(newExpr, sumType, ITM_CAST);
		newExpr = new(wHeap()) BiArithSum(ITM_PLUS,
						  newExpr,
						  item_expr);
	      }
	    // The COUNT attribute is nullable.
	    //
	    else
	      {
		ItemExpr *constZero = new(wHeap()) ConstValue(0);
		ItemExpr *constOne = new(wHeap()) ConstValue(1);
		newExpr = new(wHeap()) ReplaceNull(item_expr->child(0),
						   constOne,
						   constZero);
		newExpr = new(wHeap()) Cast(newExpr, sumType, ITM_CAST);
		newExpr = new(wHeap()) BiArithSum(ITM_PLUS,
						  newExpr,
						  item_expr);
	      }
	  }
	  break;

	case ITM_ONE_TRUE:
	  {
	    // move boolean TRUE to result
	    newExpr = new(wHeap()) BoolVal(ITM_RETURN_TRUE);

	    // assign the data attributes of the original aggr node
	    // to the newExpr.
	    // This will make the result of newExpr be moved to the
	    // original aggregate location.
	    newExpr->bindNode(generator->getBindWA());
            Attributes * attr = generator->getMapInfo(val_id)->getAttr();
	    map_info = generator->addMapInfo(newExpr->getValueId(), attr);
	    (map_info->getAttr())->copyLocationAttrs(attr);

	    // generate the expression that would return TRUE back
	    // to the caller which would short circuit.
	    newExpr = new(wHeap())BoolResult(newExpr);
	    newExpr->bindNode(generator->getBindWA());
	    newValIdSet->insert(newExpr->getValueId());

	    // no need to assign data attrs to newExpr anymore.
	    newExpr = 0;

	    // no need to generate last clause
	    gen_last_clause = 0;
	  }
	  break;

	case ITM_ANY_TRUE:
	  {
	    newExpr = createExprTree("CASE WHEN @B1 IS TRUE THEN @A2 WHEN @B1 IS UNKNOWN THEN @A3 ELSE @A4 END", 0,
				     4,
				     item_expr->child(0),
				     new(wHeap()) BoolVal(ITM_RETURN_TRUE),
				     new(wHeap()) BoolVal(ITM_RETURN_NULL),
				     0);

	    // assign the data attributes of the original aggr node
	    // to the newExpr.
	    // This will make the result of newExpr be moved to the
	    // original aggregate location.
	    newExpr->bindNode(generator->getBindWA());
            Attributes * attr = generator->getMapInfo(val_id)->getAttr();
	    map_info = generator->addMapInfo(newExpr->getValueId(), attr);
	    (map_info->getAttr())->copyLocationAttrs(attr);

	    // generate the expression that would return TRUE back
	    // to the caller which would short circuit.
	    // BTW, BoolResult returns TRUE only if its operand
	    // has evaluated to TRUE.
	    newExpr = new(wHeap())  BoolResult(newExpr);
	    newExpr->bindNode(generator->getBindWA());
	    newValIdSet->insert(newExpr->getValueId());

	    // no need to assign data attrs to newExpr anymore.
	    newExpr = 0;

	    // no need to generate last clause
	    gen_last_clause = 0;
	  }
	  break;

	case ITM_ONE_ROW:
	  {
            // Just create a dummy ONE_ROW aggregate node. Nothing is going
            // to be done on the atp at runtime anyway. We just want a one_row
            // clause generated so that we can keep track of the number of rows
            // returned so far.
            //
            newExpr = new(wHeap()) Aggregate(ITM_ONE_ROW,
                                             new(wHeap()) ConstValue(0),
                                             FALSE,
                                             ITM_ONE_ROW,' ');
	    newExpr->bindNode(generator->getBindWA());

            // Just create an entry in the map table. It won't be used anyway.
	    map_info = generator->addMapInfo(newExpr->getValueId(),0);

            // Just use the same location attrs as the original aggr. It won't
            // be used anyway.
            Attributes * attr = generator->getMapInfo(val_id)->getAttr();
	    (map_info->getAttr())->copyLocationAttrs(attr);

	     // So that a one_row_aggr clause can be generated in a later call.
            newValIdSet->insert(newExpr->getValueId());
            newExpr = NULL;

	  }
	  break;

	case ITM_ANY_TRUE_MAX:
	  {
	    // no conversion is done for these cases
	    newExpr = item_expr;
	  }
	  break;

	case ITM_PIVOT_GROUP:
	  {
            PivotGroup * pg = (PivotGroup*)item_expr;
            newExpr = 
              new(wHeap()) PivotGroup(ITM_PIVOT_GROUP, item_expr->child(0), 
                                      pg->delim(), pg->orderBy(), pg->reqdOrder(),
                                      pg->maxLen(), pg->isDistinct());
	  }
	  break;

	case ITM_ONEROW:
	  {
	   generator->getMapInfo(val_id)->codeGenerated();

	    const NAType &oneRowType = item_expr->getValueId().getType();
	    newExpr = new(wHeap()) Cast(item_expr->child(0),
					&oneRowType,
					ITM_CAST);
	   if (NOT raiseErrorGenerated)
	   {
	     ItemExpr * raiseError = new(wHeap()) Aggregate(ITM_ONE_ROW,
					       new(wHeap()) ConstValue(0),
					       FALSE,
					       ITM_ONE_ROW,' ');
	      raiseError->bindNode(generator->getBindWA());
	      newExpr = new(wHeap()) ItmBlockFunction(raiseError,newExpr);
	      raiseErrorGenerated = TRUE ;
	   }
	  }
	  break ;


	default:
	  newExpr = NULL;
	  break;

	}

      // assign the data attributes of the aggr node to the newExpr.
      // This will make the result of newExpr be moved to the
      // aggregate location.
      if (newExpr != NULL)
	{
	  newExpr->bindNode(generator->getBindWA());
	  newValIdSet->insert(newExpr->getValueId());
	  newExpr->getValueId().changeType(&(val_id.getType()));

          Attributes * attr = generator->getMapInfo(val_id)->getAttr();
	  map_info = generator->addMapInfo(newExpr->getValueId(), attr);
	  (map_info->getAttr())->copyLocationAttrs(attr);
          if(attr->isForceFixed())
            (map_info->getAttr())->setForceFixed();

	  if (nullSwitcharoo)
	    {
	      NullSwitcharooVidList.insert(val_id);
	      attr->setNullFlag(0);
	    }
	}

    }

  // generate expressions to evaluate GROUPING clause
  ValueIdSet groupingValIdSet;
  for (val_id = val_id_set.init(); 
       val_id_set.next(val_id); 
       val_id_set.advance(val_id))
    {
      ItemExpr * item_expr = val_id.getValueDesc()->getItemExpr();
      if (item_expr->getOperatorType() == ITM_GROUPING)
        {
          generator->getMapInfo(val_id)->codeGenerated();
          Aggregate * ag = (Aggregate*)item_expr;
          ItemExpr * groupingExpr = 
            new(wHeap()) AggrGrouping(ag->getRollupGroupIndex());
	  groupingExpr->bindNode(generator->getBindWA());
	  groupingValIdSet.insert(groupingExpr->getValueId());
          
          Attributes * attr = generator->getMapInfo(val_id)->getAttr();
          map_info = generator->addMapInfo(groupingExpr->getValueId(), attr);
          (map_info->getAttr())->copyLocationAttrs(attr);
        }
    } // for

  ex_expr * grouping_expr = NULL;
  if (NOT groupingValIdSet.isEmpty())
    {
      unsigned short pcm = getPCodeMode();
      setPCodeMode(ex_expr::PCODE_NONE);

      generateSetExpr(groupingValIdSet, ex_expr::exp_ARITH_EXPR,
                      &grouping_expr);

      setPCodeMode(pcm);
    }

  ex_expr * perrec_expr = NULL;
  generateSetExpr(*newValIdSet, ex_expr::exp_ARITH_EXPR, &perrec_expr);

  *expr = new(getSpace()) AggrExpr(init_expr,
				   perrec_expr,
				   0, //final_expr,
				   final_null_expr,
                                   grouping_expr);

  for (CollIndex ns = 0; ns < NullSwitcharooVidList.entries(); ns++)
    {
      map_info = generator->getMapInfo(NullSwitcharooVidList[ns]);
      map_info->getAttr()->setNullFlag(-1);
    }

  return 0;
}

// input is a ValueId which points to an arithmetic expression.
short ExpGenerator::generateArithExpr(const ValueId & val_id,
				      ex_expr::exp_node_type node_type,
				      ex_expr ** expr)

{
  initExprGen();
  startExprGen(expr, node_type);

  // generate code for this node and the tree under it
  ItemExpr * temp =
    val_id.getValueDesc()->getItemExpr()->preCodeGen(generator);
  if (! temp)
    return -1;

  temp = temp->preCodeGen(generator);
  ItemExpr * newTemp = NULL;
  Lng32 rc = foldConstants(temp, &newTemp);
  if ((rc == 0) &&
      (newTemp))
    temp = newTemp;

  temp->codeGen(generator);

  endExprGen(expr, -1);

  return 0;
}

// Deterimine if bulk move for Aligned Format can be done or not.
// If so, then generate the new src / tgt bulk move attribute
short ExpGenerator::generateBulkMoveAligned(
                                ValueIdList inValIdList,
                                ValueIdList &outValIdList,
                                UInt32       tupleLength,
                                Int32       *bulkMoveSrcStartOffset //IN(O)
                                )
{
  // turn bulk move off for aligned format for now until more testing is done
  if (CmpCommon::getDefault(COMPRESSED_INTERNAL_FORMAT_BULK_MOVE) == DF_OFF)
    return 0;

  NABoolean bulkMove = TRUE;

  MapInfo * tgtMapInfo = generator->getMapInfoAsIs(inValIdList[0]);
  MapInfo * srcMapInfo =
               generator->getMapInfoAsIs(inValIdList[0].getItemExpr()->
                                 getChild(0)->castToItemExpr()->getValueId());

  GenAssert( tgtMapInfo, "Null target map info");
  GenAssert( srcMapInfo, "Null source map info");

  Attributes * tgtAttr = tgtMapInfo->getAttr();
  Attributes * srcAttr = srcMapInfo->getAttr();

  UInt32 firstTgtAtp   = tgtAttr->getAtp();
  UInt32 firstSrcAtp   = srcAttr->getAtp();
  UInt32 firstTgtAtpIx = tgtAttr->getAtpIndex();
  UInt32 firstSrcAtpIx = srcAttr->getAtpIndex();

  // Determine if bulk move should be considered for nullable columns.
  // Variable length columns can't be done yet since each row will be
  // a different length (based on the values of the variable column values)
  // and the bulk move attribute can only have 1 length - max row size.??????????????????????
  NABoolean bulkMoveNullVarchar =
                    (CmpCommon::getDefault(BULK_MOVE_NULL_VARCHAR) == DF_ON);


  UInt32 voaOffset = 0;
  Int16 vcIndicatorLength=0;
  Int16 nullIndicatorLength=0;
  UInt32 alignment = 0;


  for (CollIndex i = 0; ((i < inValIdList.entries()) && (bulkMove)); i++)
  {
    tgtMapInfo = generator->getMapInfoAsIs(inValIdList[i]);
    if (tgtMapInfo)
      tgtAttr = tgtMapInfo->getAttr();
    else
      tgtAttr = 0;

    srcMapInfo =
      generator->getMapInfoAsIs(inValIdList[i].
                   getItemExpr()->getChild(0)->castToItemExpr()->getValueId());

    if (srcMapInfo)
      srcAttr = srcMapInfo->getAttr();
    else
      srcAttr = 0;

    if (srcAttr && srcAttr->getVCIndicatorLength() && srcAttr->getVoaOffset()> voaOffset)
    {
      voaOffset = srcAttr->getVoaOffset();
      vcIndicatorLength = srcAttr->getVCIndicatorLength();
      nullIndicatorLength = srcAttr->getNullIndicatorLength();

      alignment =  (srcAttr->isSQLMXAlignedFormat() &&
                          (srcAttr->getNextFieldIndex() == ExpOffsetMax))
                          ? ExpAlignedFormat::ALIGNMENT : 0;

    }
    // Must have both the source and target attributes in the same data format
    // to do a bulk move.  Target was checked before getting into this routine.
    if ((srcAttr && (NOT srcAttr->isSQLMXAlignedFormat())) ||
       (tgtAttr &&  (NOT tgtAttr->isSQLMXAlignedFormat())))
      return 0;

    if ((! tgtAttr)                                              ||
        (! srcAttr)                                              ||
        (tgtAttr->getTupleFormat()       != srcAttr->getTupleFormat()) ||
        (tgtAttr->getDatatype()          != srcAttr->getDatatype())    ||
        ((NOT bulkMoveNullVarchar) &&
         (tgtAttr->getNullFlag() || srcAttr->getNullFlag()))           ||
        (tgtAttr->getNullFlag()          != srcAttr->getNullFlag())    ||
        (tgtAttr->getScale()             != srcAttr->getScale())       ||
        (tgtAttr->getPrecision()         != srcAttr->getPrecision())   ||
        (tgtAttr->getLength()            != srcAttr->getLength())      ||
        (srcAttr->getAtpIndex() == 0)                                  ||
        (srcAttr->getAtpIndex() == 1)                                  ||
        ((UInt32)tgtAttr->getAtp()       != firstTgtAtp)          ||
        ((UInt32)srcAttr->getAtp()       != firstSrcAtp)          ||
        ((UInt32)tgtAttr->getAtpIndex()  != firstTgtAtpIx)        ||
        ((UInt32)srcAttr->getAtpIndex()  != firstSrcAtpIx)        ||
        (tgtAttr->getOffset()            != srcAttr->getOffset()) ||
        (tgtAttr->getNullIndOffset()     != srcAttr->getNullIndOffset())  ||
        (tgtAttr->getNullBitIndex()      != srcAttr->getNullBitIndex())   ||
        //(srcAttr->getVCIndicatorLength() > 0)                          ||
	(tgtAttr->getVCIndicatorLength() != srcAttr->getVCIndicatorLength()) ||
        (tgtAttr->getVCLenIndOffset()    != srcAttr->getVCLenIndOffset()) ||
        (tgtAttr->getNullIndOffset()     != srcAttr->getNullIndOffset())   ||
        (tgtAttr->getVoaOffset()         != srcAttr->getVoaOffset())  ||
        (srcAttr->isAddedCol()) ||
        (tgtAttr->isAddedCol()))
    bulkMove = FALSE;
  }

  if (bulkMove == TRUE)
  {
    for (CollIndex i = 0; (i < inValIdList.entries()); i++)
    {
      outValIdList.insert(inValIdList[i].
                    getItemExpr()->getChild(0)->castToItemExpr()->getValueId());
    }

    // 5/21/98: Since the tuple is to be moved as a byte array,
    // the current SQLChar constructor should be sufficient.

    NAType * type = new(generator->wHeap()) SQLChar(generator->wHeap(), (Int32)tupleLength, FALSE);
    ItemExpr * bulkMoveSrc = new(generator->wHeap()) NATypeToItem(type);
    //ItemExpr * bulkMoveTgt = new(generator->wHeap()) Convert (bulkMoveSrc);
    ItemExpr * bulkMoveTgt = new(generator->wHeap()) Convert (bulkMoveSrc,
                                                              voaOffset,
                                                              vcIndicatorLength,
                                                              nullIndicatorLength,
                                                              alignment);

    bulkMoveTgt->synthTypeAndValueId();

    Attributes * tgtAttr = generator->getMapInfo(inValIdList[0])->getAttr();
    Attributes * srcAttr =
      generator->getMapInfo(inValIdList[0].getItemExpr()->getChild(0)->castToItemExpr()->getValueId())->getAttr();

    Attributes * bulkMoveTgtAttr =
                  generator->addMapInfo(bulkMoveTgt->getValueId(), 0)->getAttr();
    Attributes * bulkMoveSrcAttr =
                  generator->addMapInfo(bulkMoveSrc->getValueId(), 0)->getAttr();

    bulkMoveTgtAttr->copyLocationAttrs(tgtAttr);

    bulkMoveSrcAttr->copyLocationAttrs(srcAttr);

    // Bulk move is only done when the complete data row is the same for
    // all source attributes and target attributes.  The starting offset must
    // encompass the Aligned Format header thus set it to 0.
    UInt32 bulkSrcStartOffset = 0;
    UInt32 bulkTgtStartOffset = 0;

    bulkMoveSrcAttr->setOffset( bulkSrcStartOffset );
    bulkMoveTgtAttr->setOffset( bulkTgtStartOffset );

    // If orignal source was a varchar, then must change the bulk src/tgt
    // attribute vc indicator length back to 0 since these are now fixed
    // char's.
    if (srcAttr->isVariableLength())
    {
      bulkMoveSrcAttr->setVCIndicatorLength(0);
      bulkMoveTgtAttr->setVCIndicatorLength(0);
    }

    // Both source and destinations are no longer rowsets
    bulkMoveTgtAttr->setRowsetSize(0);
    bulkMoveSrcAttr->setRowsetSize(0);

    outValIdList.insert(bulkMoveTgt->getValueId());

    if (bulkMoveSrcStartOffset) // param passed in.
    {
      *bulkMoveSrcStartOffset = bulkSrcStartOffset;
    }
  }
  return 0;
}

// Generate a bulk move of the input value Ids if possible.  There are very
// specific conditions for this to be possible - listed below.
// This routine handles the Exploded Internal format and branches to
// the routine ExpGenerator::generateBulkMoveAligned if the target attribute
// has data format Compressed Internal format.
short ExpGenerator::generateBulkMove(ValueIdList inValIdList,
				     ValueIdList &outValIdList,
				     ULng32 tupleLength,
				     Lng32 *bulkMoveSrcStartOffset) //IN(O)
{
  if (bulkMoveSrcStartOffset) // param passed in.
    {
      *bulkMoveSrcStartOffset = -1;
    }

  // no need to check for bulk move if list is empty.
  if (inValIdList.entries() == 0)
    return 0;

  NABoolean bulkMove = TRUE;

  MapInfo * tgtMapInfo;
  MapInfo * srcMapInfo;

  Attributes * tgtAttr;
  Attributes * srcAttr;

  tgtMapInfo = generator->getMapInfoAsIs(inValIdList[0]);

  if (!tgtMapInfo)
    return 0; // must be in maptable to check for bulkmove attrs

  tgtAttr = tgtMapInfo->getAttr();

  srcMapInfo = generator->getMapInfoAsIs(inValIdList[0].getItemExpr()->getChild(0)->castToItemExpr()->getValueId());

  if (!srcMapInfo)
    return 0; // must be in maptable to check for bulkmove attrs

  srcAttr = srcMapInfo->getAttr();

  // If there is only 1 input value id and the associated attribute is
  // not nullable, then bulk move is not needed.
  if ((NOT bulkMoveSrcStartOffset)  // parameter not passed in
      && (inValIdList.entries() == 0)
      && (NOT srcAttr->getNullFlag()))
    return 0;

  // The Compressed Internal format (ie. the Aligned Row Format) has a
  // different criteria when bulk move can be applied.
  // See the method comments for details.
  if ( tgtAttr && tgtAttr->isSQLMXAlignedFormat() )
  {
    return generateBulkMoveAligned( inValIdList,
                                    outValIdList,
                                    tupleLength,
                                    bulkMoveSrcStartOffset );
  }

  // Now only the Exploded Internal format exists as a possibility.
  UInt32 firstTgtAtp = tgtAttr->getAtp();
  UInt32 firstSrcAtp = srcAttr->getAtp();
  UInt32 firstTgtAtpIx = tgtAttr->getAtpIndex();
  UInt32 firstSrcAtpIx = srcAttr->getAtpIndex();
  Int32 firstTgtOffset = tgtAttr->getOffset();
  Int32 firstSrcOffset = srcAttr->getOffset();
  Int32 firstTgtNullOffset = ExpOffsetMax;
  Int32 firstSrcNullOffset = ExpOffsetMax;
  Int32 firstTgtVCLenIndOffset = ExpOffsetMax;
  Int32 firstSrcVCLenIndOffset = ExpOffsetMax;

  // Determine if bulk move should be considered for nullable and/or variable
  // length column values.
  NABoolean bulkMoveNullVarchar =
                    (CmpCommon::getDefault(BULK_MOVE_NULL_VARCHAR) == DF_ON);

  for (CollIndex i = 0;
       ((i < inValIdList.entries()) && (bulkMove));
       i++)
    {
      tgtMapInfo = generator->getMapInfoAsIs(inValIdList[i]);
      if (tgtMapInfo)
	tgtAttr = tgtMapInfo->getAttr();
      else
	tgtAttr = 0;

      srcMapInfo =
	generator->getMapInfoAsIs(inValIdList[i].getItemExpr()->getChild(0)->castToItemExpr()->getValueId());
      if (srcMapInfo)
	srcAttr = srcMapInfo->getAttr();
      else
	srcAttr = 0;

      // initialize the first offset variables
      if (tgtAttr && tgtAttr->getNullFlag() && 
         (firstTgtNullOffset == ExpOffsetMax))
        firstTgtNullOffset = tgtAttr->getNullIndOffset();
      if (srcAttr && srcAttr->getNullFlag() && 
         (firstSrcNullOffset == ExpOffsetMax))
        firstSrcNullOffset = srcAttr->getNullIndOffset();
      if (tgtAttr && tgtAttr->isVariableLength() && 
         (firstTgtVCLenIndOffset == ExpOffsetMax))
        firstTgtVCLenIndOffset = tgtAttr->getVCLenIndOffset();
      if (srcAttr && srcAttr->isVariableLength() && 
         (firstSrcVCLenIndOffset == ExpOffsetMax))
        firstSrcVCLenIndOffset = srcAttr->getVCLenIndOffset();

      if ((! tgtAttr)                                                  ||
          (! srcAttr)                                                  ||
          ((NOT bulkMoveNullVarchar) &&
           (tgtAttr->getNullFlag() || srcAttr->getNullFlag()))         ||
          (tgtAttr->getNullFlag()    != srcAttr->getNullFlag())        ||
          (tgtAttr->getTupleFormat() != srcAttr->getTupleFormat())     ||
          (tgtAttr->getDatatype()    != srcAttr->getDatatype())        ||
          (tgtAttr->getScale()       != srcAttr->getScale())           ||
          (tgtAttr->getPrecision()   != srcAttr->getPrecision())       ||
          (tgtAttr->getLength()      != srcAttr->getLength())          ||
          ((UInt32)tgtAttr->getAtp() != firstTgtAtp)                   ||
          ((UInt32)srcAttr->getAtp() != firstSrcAtp)                   ||
          ((UInt32)tgtAttr->getAtpIndex() != firstTgtAtpIx)            ||
          ((UInt32)srcAttr->getAtpIndex() != firstSrcAtpIx)            ||
          ((tgtAttr->getOffset() - firstTgtOffset)
            != (srcAttr->getOffset() - firstSrcOffset))                ||
          (tgtAttr->getNullFlag() &&
            ((tgtAttr->getOffset() - tgtAttr->getNullIndOffset()) 
              != (srcAttr->getOffset() - srcAttr->getNullIndOffset())))  ||
          (tgtAttr->getNullFlag() &&
            ((tgtAttr->getNullIndOffset() - firstTgtNullOffset) 
              != (srcAttr->getNullIndOffset() - firstSrcNullOffset)))  ||    
          ((NOT bulkMoveNullVarchar) &&
           ((tgtAttr->getVCIndicatorLength() > 0) 
            || (srcAttr->getVCIndicatorLength() > 0)))                 ||
          (tgtAttr->isVariableLength() &&
           ((tgtAttr->getVCLenIndOffset() - firstTgtVCLenIndOffset)
             != (srcAttr->getVCLenIndOffset() - firstSrcVCLenIndOffset))) ||
          (srcAttr->getAtpIndex() == 0)     ||
          (srcAttr->getAtpIndex() == 1)     ||
          (srcAttr->isAddedCol())       ||
          (tgtAttr->isAddedCol()))
      bulkMove = FALSE;
  }

  if (bulkMove == TRUE)
    {
      for (CollIndex i = 0; (i < inValIdList.entries()); i++)
	{
	  outValIdList.insert(inValIdList[i].getItemExpr()->getChild(0)->castToItemExpr()->getValueId());
	}

// 5/21/98: Since the tuple is to be moved as a byte array,
// the current SQLChar constructor should be sufficient.

      NAType * type = new(generator->wHeap()) SQLChar(generator->wHeap(), tupleLength, FALSE);
      ItemExpr * bulkMoveSrc = new(generator->wHeap()) NATypeToItem(type);
      ItemExpr * bulkMoveTgt = new(generator->wHeap()) Convert (bulkMoveSrc);
      bulkMoveTgt->synthTypeAndValueId();

      Attributes * tgtAttr =
	generator->getMapInfo(inValIdList[0])->getAttr();
      Attributes * srcAttr =
	generator->getMapInfo(inValIdList[0].getItemExpr()->getChild(0)->castToItemExpr()->getValueId())->getAttr();

      Attributes * bulkMoveTgtAttr = generator->addMapInfo(bulkMoveTgt->getValueId(), 0)->getAttr();
      Attributes * bulkMoveSrcAttr = generator->addMapInfo(bulkMoveSrc->getValueId(), 0)->getAttr();

      bulkMoveTgtAttr->copyLocationAttrs(tgtAttr);

      bulkMoveSrcAttr->copyLocationAttrs(srcAttr);

      UInt32 bulkSrcStartOffset = srcAttr->getOffset();
      UInt32 bulkTgtStartOffset = tgtAttr->getOffset();

      // Since the src / tgt attributes may be nullable or variable
      // must get the correct beginning offset to use and set it in the
      // new corresponding bulk attribute.
      if ( srcAttr->getNullFlag() )
        bulkSrcStartOffset = srcAttr->getNullIndOffset();
      else if ( srcAttr->isVariableLength() )
        bulkSrcStartOffset = srcAttr->getVCLenIndOffset();
           
      if ( tgtAttr->getNullFlag() )
        bulkTgtStartOffset = tgtAttr->getNullIndOffset();
      else if ( tgtAttr->isVariableLength() )
        bulkTgtStartOffset = tgtAttr->getVCLenIndOffset();
            
      bulkMoveSrcAttr->setOffset( bulkSrcStartOffset );
      bulkMoveTgtAttr->setOffset( bulkTgtStartOffset );

      // If orignal source was a varchar, then must change the bulk src/tgt
      // attribute vc indicator length back to 0 since these are now fixed
      // char's.
      if (srcAttr->isVariableLength())
      {
        bulkMoveSrcAttr->setVCIndicatorLength(0);
        bulkMoveTgtAttr->setVCIndicatorLength(0);
      }

      // Both source and destinations are no longer rowsets
      bulkMoveTgtAttr->setRowsetSize(0);

      bulkMoveSrcAttr->setRowsetSize(0);

      outValIdList.insert(bulkMoveTgt->getValueId());

      if (bulkMoveSrcStartOffset) // param passed in.
	{
          *bulkMoveSrcStartOffset = (Int32)bulkMoveSrcAttr->getOffset();
          // If the field is nullable, then its null indicator offset
          // Else if the field is a varchar, then its var len indicator offset
          if (bulkMoveSrcAttr->getNullIndicatorLength() > 0)
            *bulkMoveSrcStartOffset = (Int32)bulkMoveSrcAttr->getNullIndOffset();
          else if (bulkMoveSrcAttr->isVariableLength())
            *bulkMoveSrcStartOffset = (Int32)bulkMoveSrcAttr->getVCLenIndOffset();
	}
    }

  return 0;
}


//////////////////////////////////////////////////////////////////////
// See GenExpGenerator.h for comments.
///////////////////////////////////////////////////////////////////////
short ExpGenerator::generateContiguousMoveExpr(
					       const ValueIdList & valIdList,
					       short addConvNodes,
					       Int32 atp,
					       Int32 atpIndex,
					       ExpTupleDesc::TupleDataFormat tdataF,
					       ULng32 &tupleLength,
					       ex_expr ** moveExpr,
					       ExpTupleDesc ** tupleDesc,
					       ExpTupleDesc::TupleDescFormat tdescF,
					       MapTable ** newMapTable,
					       ValueIdList *tgtValues,
					       ULng32 startOffset,
					       Lng32 * bulkMoveSrcStartOffset,
					       NABoolean disableConstFolding,
                                               NAColumnArray *colArray,
                                               NABoolean doBulkMoves)
{
  // ---------------------------------------------------------------------
  // Generate an expression to take scattered values (given in valIdList)
  // and copy them to a contiguous buffer tuple (atp,atpIndex). The values
  // are allocated in the tuple in the sequence given in valIdList.
  // On request, the method also returns a map table with new attributes
  // for the value ids in valIdList and a list of the target expressions
  // that were generated.
  // ---------------------------------------------------------------------
  // a list with convert nodes corresponding to valIdList
  ValueIdList convValIdList;

  // Allocate a new map table that describes the value ids in valIdList
  // and convValList. Append it to the end of the list of map tables.
  MapTable *contBufferMapTable = generator->appendAtEnd();

  // should we use a temporary map table for the convert nodes? $$$$

  // ---------------------------------------------------------------------
  // For each value in the list, put a convert node on its top which
  // will take care of the move. Assign attributes for all those convert
  // nodes such that they are stored adjacently in a single tuple
  // (the one described by (atp, atpIndex)).
  // ---------------------------------------------------------------------

  NABoolean alignedFormat = (tdataF == ExpTupleDesc::SQLMX_ALIGNED_FORMAT);
  Attributes ** attrs = new(wHeap()) Attributes * [valIdList.entries()];
  NAColumn *col;
  for (CollIndex i = 0; i < valIdList.entries(); i++)
    {
      ItemExpr * itemExpr = valIdList[i].getItemExpr();

      ItemExpr * convNode;
      if (addConvNodes)
	{
	  // add the convert node
	  convNode = new(wHeap()) Convert (itemExpr);
	  convNode->bindNode(generator->getBindWA());
	}
      else
	convNode = itemExpr;

      convNode->setConstFoldingDisabled(TRUE);
      if (NOT disableConstFolding)
	{
	  convNode->preCodeGen(generator);
	  foldConstants(convNode, NULL);
	}

      // bind/type propagate the new/old node
      convNode->bindNode(generator->getBindWA());
      ValueId convValueId = convNode->getValueId();

      // get a pointer to the map table attributes and set them the
      // way we want them to be
      if (addConvNodes)
	attrs[i] = (generator->addMapInfoToThis(contBufferMapTable, convValueId, 0))->getAttr();
      else
	attrs[i] = (generator->addMapInfo(convValueId, 0))->getAttr();

      if ( alignedFormat  &&
           (colArray == NULL) &&
           ((col = valIdList[i].getNAColumn( TRUE )) != NULL) &&
           col->isAddedColumn() )
        attrs[i]->setAddedCol();

      convValIdList.insert(convValueId);
    }

  // Ensure added columns are tagged before computing offset for the aligned
  // record format since added columns are arranged differently.
  //  if ( (colArray != NULL) && alignedFormat )
  if ( (colArray != NULL) )
  {
    for( Int32 i = 0; i < (Int32)colArray->entries(); i++ )
    {
      col = (*colArray)[i];
      addDefaultValue(col, attrs[i], CmpCommon::diags()); 
    }
  }

  // If generating a contiguous move expression where the target tuple data
  // format is a disk format - Packed or Aligned - then header information
  // must be gathered during processing the attributes. This allows a new 
  // header clause to be generated during endExprGen()
  ExpHdrInfo *hdrInfo = NULL;
  if ( isHeaderNeeded(tdataF) )
    hdrInfo = new( wHeap() )ExpHdrInfo();

  // compute offsets and create tuple descriptor.
  processAttributes((ULng32)valIdList.entries(), attrs, tdataF,
		    tupleLength, atp, atpIndex,  tupleDesc, tdescF,
                    startOffset, hdrInfo);

  // deallocate the attributes array. Don't deallocate the attributes
  // pointed to by the array entries since we didn't allocate them.
  NADELETEBASIC(attrs,wHeap());

  // if bulkmovesrcstartoffset passed in is -2, then always generate
  // move expression even if bulk move using bulkmovesrcstartoffset
  // could be done.
  NABoolean alwaysGenMoveExpr = FALSE;
  if ((moveExpr) &&
      (bulkMoveSrcStartOffset) &&
      (*bulkMoveSrcStartOffset == -2))
    alwaysGenMoveExpr = TRUE;

  ValueIdList bulkMoveValueIdList;

  // Since convert nodes are asked for, check if a bulk move of all source
  // values can be done to the target.
  // if asked not to do bulk move, don't do it.
  if (addConvNodes && doBulkMoves)
  {
    if (generateBulkMove(convValIdList, bulkMoveValueIdList,
                         tupleLength,
                         bulkMoveSrcStartOffset) == -1)
      return -1;

    // If bulk move will be used, then no header clause needs
    // to be generated.
    if (hdrInfo  &&  bulkMoveValueIdList.entries() > 0)
    {
      NADELETEBASIC( hdrInfo, wHeap() );
      hdrInfo = NULL;
    }
  }

  ValueIdList * newValIdList;

  if (bulkMoveValueIdList.entries() > 0)
    newValIdList = &bulkMoveValueIdList;
  else
    newValIdList = &convValIdList;

  // generate the copy expression, if moveExpr is passed in,
  // and bulk move info is not to be returned
  // or bulk move info is to be returned but bulk move is not being done.
  if ((moveExpr) &&
      ((! bulkMoveSrcStartOffset) ||
       (*bulkMoveSrcStartOffset == -1) ||
       (alwaysGenMoveExpr)))
  {
    generateListExpr(*newValIdList, ex_expr::exp_ARITH_EXPR, moveExpr,
                     atp, atpIndex, hdrInfo);

    if ( newValIdList != &convValIdList )
    {
      for (int j =0; (UInt32)j< convValIdList.entries(); j++)
      {
        generator->getMapInfo(convValIdList[j])->codeGenerated();
      }
    }

    if ( hdrInfo != NULL )
    {
      NADELETEBASIC( hdrInfo, wHeap() );
    }
  }

  // if the user requested a map table back, make a new map table and
  // add all the original value ids to it, but assign the attributes
  // of the new, contiguous buffers
  if (newMapTable)
    {
      generator->appendAtEnd();
      *newMapTable = generator->unlinkLast();
      for (CollIndex i = 0; i < valIdList.entries(); i++)
	{
	  // don't add constants. Constants have a fixed location
	  // (atp_index = 0) and are added whenever they are used in an
	  // expression.
	  if (convValIdList[i].getItemExpr()->getOperatorType() !=
	      ITM_CONSTANT)
	    {
	      // Get the attributes of the contiguous buffer...
	      Attributes *contAttrib =
		generator->getMapInfo((convValIdList)[i])->getAttr();

	      // ...add it to the new map table as if it belonged to
	      // the original value id...
              MapInfo * mapInfo =
                generator->addMapInfoToThis((*newMapTable), valIdList[i],contAttrib);

	      // ... and make sure no more code gets generated for it.
	      mapInfo->codeGenerated();
	    }
	}
    }

  // if the caller wants to see the generated expressions for the move
  // targets, insert them into the list supplied by the caller
  if (tgtValues != NULL)
    tgtValues->insert(convValIdList);

  return 0;
}

short
ExpGenerator::genGuardedContigMoveExpr(const ValueIdSet guard,
                                       const ValueIdList & valIdList,
                                       short addConvNodes,
                                       Int32 atp,
                                       Int32 atpIndex,
                                       ExpTupleDesc::TupleDataFormat tdataF,
                                       ULng32 &tupleLength,
                                       ex_expr ** moveExpr,
                                       ExpTupleDesc ** tupleDesc,
                                       ExpTupleDesc::TupleDescFormat tdescF,
                                       MapTable ** newMapTable,
                                       ValueIdList *tgtValues,
                                       ULng32 start_offset)
{
  // ---------------------------------------------------------------------
  // Generate an expression to take scattered values (given in valIdList)
  // and copy them to a contiguous buffer tuple (atp,atpIndex). The values
  // are allocated in the tuple in the sequence given in valIdList.
  // On request, the method also returns a map table with new attributes
  // for the value ids in valIdList and a list of the target expressions
  // that were generated.
  // ---------------------------------------------------------------------
  // a list with convert nodes corresponding to valIdList
  ValueIdList convValIdList;

  // Allocate a new map table that describes the value ids in valIdList
  // and convValList. Append it to the end of the list of map tables.
  MapTable *contBufferMapTable = generator->appendAtEnd();

  // should we use a temporary map table for the convert nodes? $$$$

  // ---------------------------------------------------------------------
  // For each value in the list, put a convert node on its top which
  // will take care of the move. Assign attributes for all those convert
  // nodes such that they are stored adjacently in a single tuple
  // (the one described by (atp, atpIndex)).
  // ---------------------------------------------------------------------

  Attributes ** attrs = new(wHeap()) Attributes * [valIdList.entries()];
  for (CollIndex i = 0; i < valIdList.entries(); i++)
    {
      ItemExpr * itemExpr = valIdList[i].getItemExpr();

      ItemExpr * convNode;
      if (addConvNodes)
	{
	  // add the convert node
	  convNode = new(wHeap()) Convert (itemExpr);
	}
      else
	convNode = itemExpr;

      // bind/type propagate the new/old node
      convNode->bindNode(generator->getBindWA());
      ValueId convValueId = convNode->getValueId();

      // get a pointer to the map table attributes and set them the
      // way we want them to be
      if (addConvNodes)
	attrs[i] = (generator->addMapInfoToThis(contBufferMapTable, convValueId, 0))->getAttr();
      else
	attrs[i] = (generator->addMapInfo(convValueId, 0))->getAttr();

      convValIdList.insert(convValueId);
    }

  // compute offsets and create tuple descriptor.
  processAttributes((ULng32)valIdList.entries(), attrs, tdataF,
		    tupleLength, atp, atpIndex,  tupleDesc, tdescF,
		    start_offset);

  // deallocate the attributes array. Don't deallocate the attributes
  // pointed to by the array entries since we didn't allocate them.
  NADELETEBASIC(attrs,wHeap());

  // generate the copy expression
  genGuardedListExpr(guard, convValIdList,ex_expr::exp_ARITH_EXPR,moveExpr);

  // if the user requested a map table back, make a new map table and
  // add all the original value ids to it, but assign the attributes
  // of the new, contiguous buffers
  if (newMapTable)
    {
      generator->appendAtEnd();
      *newMapTable = generator->unlinkLast();
      for (CollIndex i = 0; i < valIdList.entries(); i++)
	{
	  // don't add constants. Constants have a fixed location
	  // (atp_index = 0) and are added whenever they are used in an
	  // expression.
	  if (convValIdList[i].getItemExpr()->getOperatorType() !=
	      ITM_CONSTANT)
	    {
	      // Get the attributes of the contiguous buffer...
	      Attributes *contAttrib =
		generator->getMapInfo((convValIdList)[i])->getAttr();

	      // ...add it to the new map table as if it belonged to
	      // the original value id...
              MapInfo * mapInfo =
                generator->addMapInfoToThis((*newMapTable), valIdList[i],contAttrib);

	      // ... and make sure no more code gets generated for it.
	      mapInfo->codeGenerated();
	    }
	}
    }

  // if the caller wants to see the generated expressions for the move
  // targets, insert them into the list supplied by the caller
  if (tgtValues != NULL)
    tgtValues->insert(convValIdList);

  return 0;
}

//////////////////////////////////////////////////////////////////////
// Input is a ValueIdList to be exploded into a contiguous buffer.
// Every other parameter is similar to generateContiguousMoveExpr.
///////////////////////////////////////////////////////////////////////
short ExpGenerator::generateExplodeExpr(
     const ValueIdList & val_id_list,  // IN
     Int32 atp,                          // IN
     Int32 atpIndex,                     // IN
     ExpTupleDesc::TupleDataFormat tf, // IN
     ULng32 &tupleLength,       // OUT
     ex_expr ** explodeExpr,              // OUT
     ExpTupleDesc ** tupleDesc, // OUT(O)
     ExpTupleDesc::TupleDescFormat tdescF, // IN
     MapTable ** newMapTable,   // OUT(O)
     ValueIdList *tgtValues,    // OUT(O)
     ULng32 start_offset)  // IN(O)
{
  ValueIdList explodeVidList;
  for (CollIndex i = 0; i < val_id_list.entries(); i++)
    {
      ItemExpr * ie = val_id_list[i].getItemExpr();

      ItemExpr * cast_node;
      if (ie->getValueId().getType().getVarLenHdrSize() > 0)
	{
	  // Explode varchars.
	  cast_node = new(generator->wHeap())
	    ExplodeVarchar (ie, &(ie->getValueId().getType()), FALSE);
	}
      else
	{
	  cast_node = new(generator->wHeap())
	    Cast(ie, &(ie->getValueId().getType()));
      }

      // Bind the cast node and insert the value ID into the list.
      //
      cast_node->bindNode(generator->getBindWA());
      explodeVidList.insert(cast_node->getValueId());
    }

  return generateContiguousMoveExpr(explodeVidList, 0/*don't add conv nodes*/,
				    atp, atpIndex, tf, tupleLength,
				    explodeExpr, tupleDesc, tdescF,
				    newMapTable, tgtValues,
				    start_offset);
}

//
// Expression generated for inserts and non-optimized updates to clear
// any header data areas in the buffer being written to.  This expression
// is only generated when the target is one of the 2 SQL/MX disk formats
//    SQLMX_FORMAT or SQLMX_ALIGNED_FORMAT
// For SQLMX_FORMAT the first fixed field area will be cleared,
// for the aligned format, everything up to the first fixed field will
// be cleared (header + entire VOA + bitmap + any padding).
// For the aligned format, the bitmap offset will be set too.
short ExpGenerator::generateHeaderClause( Int32       atp,
                                          Int32       atpIndex,
                                          ExpHdrInfo *hdrInfo)
{
  ExHeaderClause *hdrClause = NULL;
  Int16 numOperands = 1;        // target row that must have its header cleared
  Attributes **attr;

  GenAssert( hdrInfo != NULL, "Null expression" );

  ExpTupleDesc::TupleDataFormat tdf = (hdrInfo->getBitmapEntryOffset() > 0
                                       ? ExpTupleDesc::SQLMX_ALIGNED_FORMAT
                                       : ExpTupleDesc::SQLMX_FORMAT);

  // This is a showplan statement.
  if (getShowplan())
    numOperands = (Int16)(numOperands * 2);

  attr = new(generator->wHeap()) Attributes * [numOperands];

  // Initialize an attribute for the full header.
  attr[0] = (Attributes *)new(generator->wHeap())
                          SimpleType(hdrInfo->getAdminSize(), 1, 0);
  attr[0]->setDatatype(REC_BYTE_F_ASCII);
  attr[0]->setTupleFormat(tdf);
  attr[0]->setOffset(hdrInfo->getStartOffset()); 
  attr[0]->setNullIndicatorLength(0);
  attr[0]->setNullFlag(0);
  attr[0]->setVCIndicatorLength(0);
  attr[0]->setAtpIndex((Int16)atpIndex);
  attr[0]->setAtp((Int16)atp);

  if (getShowplan())
  {
    attr[0]->setShowplan();
    NAString hdrStr = "Hdr";
    ValueId dummyVID(NULL_VALUE_ID);

    attr[1] = new(generator->wHeap())
              ShowplanAttributes(dummyVID,
                                 convertNAString(hdrStr, generator->wHeap()));
  }

  hdrClause = new(getSpace())ExHeaderClause(attr, getSpace(),
                                            hdrInfo->getAdminSize(),
                                            hdrInfo->getBitmapEntryOffset(),
                                            hdrInfo->getBitmapOffset(),
                                            hdrInfo->getFirstFixedOffset());

  // don't end the expression generation since we didn't start it
  // endExprGen (expr, -1);

  // Add clear header clause to the clause_list. This is attached to the
  // expression by the method endExprGen()
  linkClause(0, hdrClause);

  return 0;
}

// input is a ValueId which points to a boolean tree.
// Generate code for the ItemExprTree corresponding
// to this ValueId.
short ExpGenerator::generateExpr(const ValueId & val_id,
				 ex_expr::exp_node_type node_type,
				 ex_expr ** expr)
{
  initExprGen();
  startExprGen(expr, node_type);

  // generate code for this node and the tree under it
  ItemExpr * temp =
    val_id.getValueDesc()->getItemExpr()->preCodeGen(generator);
  if (! temp)
    return -1;
  temp->codeGen(generator);

  endExprGen(expr, 0);

  return 0;
}

///////////////////////////////////////////////////////////////////////////
// This method is used to figure out if keys are to be extracted from base
// table row and encoded at runtime. If encoding is not needed based on
// certain criteria (detailed below), then offset of the first key column
// inside the base table row is returned.
// At runtime, this offset is used to directly access the key values
// from the base row instead of going thru expression evaluator to
// encode each key. This check is done for performance improvement.
//
// Encoding is needed if:
//   -- the datatype of key column needs encoding (for ex, if it is a
//      signed datatype)
//   -- it is a nullable column. This restriction could be removed in future.
//   -- it is a descending key
//   -- the key columns are not 'next' to each other from left to right
//      in the base row
//   -- the difference in offsets of any two consecutive key columns is
//      not the same as the size of first column. This case can happen
//      if columns are aligned inside base row by introducing filler bytes.
//   -- if any column preceding the first key column in the base table
//      is a varchar
//
// RETURN: TRUE,  if key encoding is needed.
//         FALSE, if key encoding is not needed, in this case the
//                firstKeyColumnOffset contains the offset of the first
//                key column inside the base table row.
/////////////////////////////////////////////////////////////////////////////
NABoolean ExpGenerator::processKeyEncodingOptimization(
     const NAColumnArray &allColumns,             /* IN */
     const NAColumnArray &indexKeyColumns,        /* IN */
     const ValueIdList   &indexKey,               /* IN */
     const short keyTag,                          /* IN */
     ULng32 &keyLen,
     ULng32 &firstKeyColumnOffset)
{
  CollIndex prevColNumber;

  // if this is a primary index (base table), then get the position
  // of the first key in the base table.
  // If this is an index, then the index key columns are the stored
  // in the beginning of the index row. Do not use the getPosition()
  // method as that will give the position of the index column in
  // the base table row. The position of the first
  // index key column in the index is 0.
  // NOTE: if this 'assumtion' about index columns changes, then
  // need to change this logic.
  if (keyTag == 0) // primary index
    prevColNumber =
      (CollIndex)indexKeyColumns[0]->getPosition();
  else
    {
      // index
      prevColNumber = (CollIndex)0;
    }

  ValueId prevValId = indexKey[0];

  // make sure that none of the columns preceding the first key column
  // in the base table row is a varchar
  CollIndex i = 0;
  while ( i < prevColNumber )
    {
      if (allColumns.getColumn(i)->getType()->getVarLenHdrSize() > 0)
	return TRUE;
      else
	i++;
    }

  keyLen = 0;
  const CollIndex indexKeyEntries = indexKey.entries();
  Attributes * prevAttr = generator->getMapInfo(prevValId)->getAttr();
  for (i = 0; i < indexKeyEntries; i++)
    {
      ValueId valId = indexKey[i];

      NAColumn * naCol = indexKeyColumns.getColumn(i);

      Attributes * thisAttr = generator->getMapInfo(valId)->getAttr();

      if ((valId.getType().isEncodingNeeded() == TRUE)  ||
	  ((valId.getType().getTypeQualifier() == NA_CHARACTER_TYPE) &&  
	   ((((CharType&)valId.getType()).isCaseinsensitive())  ||
           (CollationInfo::isSystemCollation(((CharType&)valId.getType()).getCollation())))) ||
	  (valId.getType().supportsSQLnull()  == TRUE)  ||
	  (indexKeyColumns.isAscending(i) == FALSE)     ||
	  ((naCol->getPosition() - prevColNumber) < 0)   ||
	  ((naCol->getPosition() - prevColNumber) > 1)   ||
	  ((thisAttr->getOffset() - prevAttr->getOffset())
	   > prevAttr->getStorageLength())               ||
          (!naCol->isStoredOnDisk()))
	return TRUE;

      prevColNumber = naCol->getPosition();
      prevValId = valId;
      prevAttr = thisAttr;
      keyLen += prevAttr->getStorageLength();
    }

  firstKeyColumnOffset = generator->getMapInfo(indexKey[0])->getAttr()->getOffset();

  return FALSE;
}

NABoolean ExpGenerator::isKeyEncodingNeeded(const IndexDesc * indexDesc,
					    ULng32 &keyLen,
					    ULng32 &firstKeyColumnOffset)
{
  return processKeyEncodingOptimization(
       indexDesc->getNAFileSet()->getAllColumns(),
       indexDesc->getNAFileSet()->getIndexKeyColumns(),
       indexDesc->getIndexKey(),
       indexDesc->getNAFileSet()->getKeytag(),
       keyLen,
       firstKeyColumnOffset);
}

// input is the index descriptor. Generate an expression to
// extract and encode the key of the table and create a
// contiguous row of encoded keys.
// If optimizeKeyEncoding is TRUE, then check to see if encoding could
// be avoided. If so, return the offset to the first key column in
// the data row.
short ExpGenerator::generateKeyEncodeExpr(const IndexDesc * indexDesc,
					  Int32 atp, Int32 atp_index,
					  ExpTupleDesc::TupleDataFormat tf,
					  ULng32 &keyLen,
					  ex_expr ** encode_expr,
					  NABoolean optimizeKeyEncoding,
					  ULng32 &firstKeyColumnOffset,
					  const ValueIdList * inKeyList,
					  NABoolean handleSerialization)
{
  if ((optimizeKeyEncoding == TRUE) &&
      (isKeyEncodingNeeded(indexDesc, keyLen, firstKeyColumnOffset) == FALSE))
    return 0;

  MapTable * mapTable = generator->getMapTable();

  ValueIdList encode_val_id_list;
  CollIndex i = 0;

  Lng32 numEntries = indexDesc->getIndexKey().entries();
  if (inKeyList)
    numEntries = MINOF(inKeyList->entries(),  indexDesc->getIndexKey().entries());

  for (i = 0; i < numEntries; i++)
    {
      // Allocate convert node
      // to move the key value to the key buffer.
      ItemExpr * col_node = 
	(inKeyList ? (*inKeyList)[i].getItemExpr() : 
	 (indexDesc->getIndexKey())[i].getItemExpr());

      short desc_flag = TRUE;
      if ((indexDesc->getNAFileSet()->getIndexKeyColumns()).isAscending(i))
	desc_flag = FALSE;
      
      if ((tf == ExpTupleDesc::SQLMX_KEY_FORMAT) &&
	  (col_node->getValueId().getType().getVarLenHdrSize() > 0) &&
          (NOT ((indexDesc->getNAFileSet()->getIndexKeyColumns()[i])->isPrimaryKeyNotSerialized())))
	{
	  // Explode varchars by moving them to a fixed field
	  // whose length is equal to the max length of varchar.
	  
	  // handle different character set cases.
          const CharType& char_t =
	    (CharType&)(col_node->getValueId().getType());
	  if (!CollationInfo::isSystemCollation(char_t.getCollation()))
	    {
	      col_node = new(wHeap())
		Cast (col_node,
		      (new(wHeap())
		       SQLChar(wHeap(), CharLenInfo(char_t.getStrCharLimit(), char_t.getDataStorageSize()),
			       col_node->getValueId().getType().supportsSQLnull(),
			       FALSE, FALSE, FALSE,
			       char_t.getCharSet(),
			       char_t.getCollation(),
			       char_t.getCoercibility()
			       )
		       )
		      );
	    }
	}

      ItemExpr * enode = NULL;
      if (handleSerialization)
	{
	  NAColumn * nac = indexDesc->getNAFileSet()->getIndexKeyColumns()[i];
          NABoolean isAlignedRowFormat = indexDesc->getNAFileSet()->isSqlmxAlignedRowFormat();
	  if ((!isAlignedRowFormat) && CmpSeabaseDDL::isEncodingNeededForSerialization(nac))
	    {
	      if (desc_flag)
		{
		  // this value is in serializable encoded form. Decode it before generating the
		  // key expr. Do this only if the new key order is different than the original
		  // order. Original encoding is in ascending order.
		  col_node = new(generator->wHeap()) CompDecode
		    (col_node, &col_node->getValueId().getType(),
		     FALSE, TRUE);
		}
	      else
		// col_node is already in encoded format.
		enode = 
		  new(generator->wHeap()) Cast(col_node, &col_node->getValueId().getType());
	    } // encoding/decoding needed
	} // handleSerialization

      if (enode == NULL)
        {
          if (NOT ((indexDesc->getNAFileSet()->getIndexKeyColumns()[i])->isPrimaryKeyNotSerialized()))
            enode = new(wHeap()) CompEncode(col_node, desc_flag);
          else 
            enode = 
              new(generator->wHeap()) Cast(col_node, &col_node->getValueId().getType());
        }            
      
      enode->bindNode(generator->getBindWA());

      encode_val_id_list.insert(enode->getValueId());
    }

  generateContiguousMoveExpr(encode_val_id_list,
			     0, // don't add convert nodes,
			     atp,
			     atp_index,
			     tf,
			     keyLen,
			     encode_expr);

  return 0;
}

short ExpGenerator::generateDeserializedMoveExpr(
						 const ValueIdList & valIdList,
						 Int32 atp,
						 Int32 atpIndex,
						 ExpTupleDesc::TupleDataFormat tdataF,
						 ULng32 &tupleLength,
						 ex_expr ** moveExpr,
						 ExpTupleDesc ** tupleDesc,
						 ExpTupleDesc::TupleDescFormat tdescF,
						 ValueIdList &deserVIDlist,
						 ValueIdSet &alreadyDeserialized)
{
  for (Lng32 i = 0; i < valIdList.entries(); i++)
    {
      ValueId vid = valIdList[i];
      NAColumn * nac = vid.getNAColumn( TRUE );

      ItemExpr * ie = NULL;
      if (nac && CmpSeabaseDDL::isEncodingNeededForSerialization(nac) &&
	  !alreadyDeserialized.contains(vid))
	{
	  ie = new(generator->wHeap()) CompDecode(vid.getItemExpr(), &vid.getType(),
						  FALSE, TRUE);
	}
      else
	{
	  ie = new(generator->wHeap()) Cast(vid.getItemExpr(), &vid.getType());
	}

      ie->bindNode(generator->getBindWA());
      deserVIDlist.insert(ie->getValueId());
    }

  return generateContiguousMoveExpr(
				    deserVIDlist,
				    0, // no conv nodes
				    atp, atpIndex,
				    tdataF,
				    tupleLength,
				    moveExpr,
				    tupleDesc,
				    tdescF);
}

short ExpGenerator::generateExtractKeyColsExpr(
					       const ValueIdList &colVidList,//const IndexDesc * indexDesc,
					       Int32 atp, Int32 atp_index,
					       ULng32 &keyLen,
					       ex_expr ** key_cols_expr)
{
  ValueIdList val_id_list;
  CollIndex i = 0;
  for (i = 0; i < colVidList.entries(); i++)
    //  for (i = 0; i < indexDesc->getIndexColumns().entries(); i++)
    {
      ItemExpr * col_node = colVidList[i].getItemExpr();

      val_id_list.insert(col_node->getValueId());
    }

  generateContiguousMoveExpr(val_id_list,
			     1, // add convert nodes,
			     atp,
			     atp_index,
			     ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
			     keyLen,
			     key_cols_expr);

  return 0;
}

short ExpGenerator::generateKeyColValueExpr(
					    const ValueId vid,
					    Int32 atp, Int32 atp_index,
					    ULng32 &len,
					    ex_expr ** colValExpr)
{

  ItemExpr * eq_node = (vid.getValueDesc())->getItemExpr();

  ItemExpr * keycol = ((*eq_node)[0])->castToItemExpr();
  ItemExpr * keyval = ((*eq_node)[1])->castToItemExpr();

  keyval = keyval->preCodeGen(generator);

  const NAType * sourceType = &(keyval->getValueId().getType());
  const NAType * targetType = &(keycol->getValueId().getType());

  NABoolean generateNarrow = sourceType->errorsCanOccur(*targetType);

  // if narrow is to be generated or varchar key col, then checkAndDelete opt
  // cannot be done (for now).
  if (NOT ((generateNarrow) ||(targetType->getVarLenHdrSize() > 0)))
    {
      ItemExpr * cv = NULL;
      cv = new(wHeap()) Cast(keyval, targetType);

      if (HbaseAccess::isEncodingNeededForSerialization(keycol))
	{
	  cv = new(generator->wHeap()) CompEncode
	    (cv, FALSE, -1, CollationInfo::Sort, TRUE);
	}

      cv = cv->bindNode(generator->getBindWA());
      cv = cv->preCodeGen(generator);

      ValueIdList val_id_list;
      val_id_list.insert(cv->getValueId());
      generateContiguousMoveExpr(val_id_list,
				 0, // no conv nodes
				 atp,
				 atp_index,
				 ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
				 len,
				 colValExpr);
    }

  return 0;
}


ItemExpr * ExpGenerator::generateKeyCast(const ValueId vid,
					 ItemExpr * dataConversionErrorFlag,
					 NABoolean desc_flag,
					 ExpTupleDesc::TupleDataFormat tf,
					 Lng32 &possibleErrorCount,
					 NABoolean allChosenPredsAreEqualPreds,
                                         NABoolean castVarcharToAnsiChar)
{

  ItemExpr * eq_node = (vid.getValueDesc())->getItemExpr();

  ItemExpr * keycol = ((*eq_node)[0])->castToItemExpr();
  ItemExpr * keyval = ((*eq_node)[1])->castToItemExpr();

  // do preCodeGen now, to avoid inserting scaling later
  keyval = keyval->preCodeGen(generator);

  const NAType * sourceType = &(keyval->getValueId().getType());
  const NAType * targetType = &(keycol->getValueId().getType());

  NABoolean caseinsensitiveEncode = FALSE;

  ItemExpr * knode = 0;  // the node to be returned

  NABoolean generateNarrow = sourceType->errorsCanOccur(*targetType);

  switch (tf)
    {
    case ExpTupleDesc::SQLMX_KEY_FORMAT:
      {
	ItemExpr * cnode;

	if (targetType->getTypeQualifier() == NA_CHARACTER_TYPE)
	  {
	    const CharType& char_t =
	      (CharType&)(keycol->getValueId().getType());

	    // Explode varchars by moving them to a fixed field
	    // whose length is equal to the max length of varchar.
	    // Remove the UPSHIFT attr from the target. We don't want
	    // to upshift data for key lookup.
	    if ((keycol->getValueId().getType().getVarLenHdrSize() > 0) ||
		(char_t.isUpshifted()))
	      {
		if (!CollationInfo::isSystemCollation(char_t.getCollation()))
		{
                  if ((castVarcharToAnsiChar) &&
                      (keycol->getValueId().getType().getVarLenHdrSize() > 0))
                    {
                      targetType = new(wHeap())
                        ANSIChar(wHeap(), char_t.getDataStorageSize(),
                                 keycol->getValueId().getType().supportsSQLnull(),
                                 FALSE,
                                 FALSE,
                                 char_t.getCharSet(),
                                 char_t.getCollation(),
                                 char_t.getCoercibility()
                                 );
                    }
                  else
                    {
                      targetType = new(wHeap())
                        SQLChar(wHeap(), CharLenInfo(char_t.getStrCharLimit(), char_t.getDataStorageSize()),
                                keycol->getValueId().getType().supportsSQLnull(),
                                FALSE,
                                ((CharType*)targetType)->isCaseinsensitive(),
                                FALSE,
                                char_t.getCharSet(),
                                char_t.getCollation(),
                                char_t.getCoercibility()
                                );
                    }
		}
	      }
	  }

	NABoolean compEncodeGenerated = FALSE;
	if (generateNarrow)
	  {
	    cnode = new(wHeap()) Narrow (keyval,dataConversionErrorFlag,targetType,
                                         ITM_NARROW, desc_flag);
	  }
	else
	  {
	    if (*sourceType == *targetType)
	      {
		// if source & target are exactly the same and normal scaling
		// is being done, then generate the encode node. This avoids
		// an extra conversion node.
		cnode = new(wHeap()) CompEncode(keyval, desc_flag);
		compEncodeGenerated = TRUE;
	      }
	    else
	      {
		cnode = new(wHeap()) Cast (keyval,targetType);
	      }
	  }

        cnode = cnode->bindNode(generator->getBindWA());
        cnode = cnode->preCodeGen(generator);

	// if both source and target are caseinsensitive, then
	// do caseinsensitive encode.
	if ((targetType->getTypeQualifier() == NA_CHARACTER_TYPE) &&
	    (keyval->getValueId().getType().getTypeQualifier() == NA_CHARACTER_TYPE) &&
	    (((CharType*)targetType)->isCaseinsensitive()) &&
	    (((CharType&)keyval->getValueId().getType()).isCaseinsensitive()))
	  {
	    caseinsensitiveEncode = TRUE;
	  }

	// encode the key for byte comparison.
        knode = cnode;
	if (compEncodeGenerated)
	  {
	    knode = cnode;
	    ((CompEncode*)knode)->setCaseinsensitiveEncode(caseinsensitiveEncode);
	  }
	else if (NOT castVarcharToAnsiChar)
	  {
	    knode = new(wHeap()) CompEncode(cnode, desc_flag);
            knode = knode->bindNode(generator->getBindWA());
	    ((CompEncode*)knode)->setCaseinsensitiveEncode(caseinsensitiveEncode);
	    knode = knode->preCodeGen(generator);
	  }
      }
      break;

    default:
      {
	GenAssert(0, "Unrecognized tuple format");
      }
      break;
    }

  // if data conversion errors could have occurred on a prior column,
  // generate a CASE statement to move in the min or max value for the
  // datatype instead (depending on the conversion error and on whether
  // this column is ascending or descending)

  if ((possibleErrorCount > 0) &&
      (NOT allChosenPredsAreEqualPreds))
    {
      ItemExpr * relativeMin = new(wHeap()) ConstValue(targetType->newCopy(wHeap()),
						       !desc_flag,
						       targetType->supportsSQLnull());
      relativeMin = new(wHeap()) Cast(relativeMin,targetType);

      // Add an encode node here.
      relativeMin = new(wHeap()) CompEncode(relativeMin, desc_flag);

      ItemExpr * relativeMax = new(wHeap()) ConstValue(targetType->newCopy(wHeap()),
						       desc_flag,
						       targetType->supportsSQLnull());
      relativeMax = new(wHeap()) Cast(relativeMax,targetType);

      // Add an encode node here.
      relativeMax = new(wHeap()) CompEncode(relativeMax, desc_flag);

      knode = createExprTree("CASE WHEN @A1 = 0 THEN @A2 WHEN @A1 < 0 THEN @A3 ELSE @A4 END",
                             0,
			     4,
			     dataConversionErrorFlag, // @A1
			     knode, // @A2
			     relativeMax, // @A3
			     relativeMin); // @A4
    }

  GenAssert(knode, "generateKeyCast: knode null pointer ");
  knode = knode->bindNode(generator->getBindWA());
  knode = knode->preCodeGen(generator);

  // knode->displayTree();

  // Check for an error binding the node.
  GenAssert(!generator->getBindWA()->errStatus(),"MDAM: Error binding node.");

  // update count of columns that can have conversion errors
  if (generateNarrow)
    possibleErrorCount++;

  return knode;
}


short ExpGenerator::generateKeyExpr(const NAColumnArray & indexKeyColumns,
				    const ValueIdList & val_id_list,
				    Int32 atp, Int32 atp_index,
				    ItemExpr * dataConversionErrorFlag,
				    ExpTupleDesc::TupleDataFormat tf,
				    ULng32 &keyLen,
				    ex_expr ** key_expr,
				    NABoolean allChosenPredsAreEqualPreds)
{
  // generate key expression.
  // Key value id list has entries of the form:
  //    col1 = value1, col2 = value2, ... colN = valueN
  // All key values are present (missing keys are added in preCodeGen).
  if (val_id_list.entries() > 0)
    {
      ValueIdList key_val_id_list;

      // generate expression to create the key buffer. All key values
      // are part of a contiguous key buffer whose length is same
      // as the key length of the table. Allocate convert nodes
      // to move the key values to the key buffer.

      Lng32 possibleErrorCount = 0;

      short prevAtp = -1, prevAtpIndex = -1;
      UInt32 prevOffset = 0;
      UInt32 firstOffset = 0;
      UInt32 prevStorageLength = 0;
      for (ULng32 i = 0; i < val_id_list.entries(); i++)
	{
	  ItemExpr * knode = NULL;

	  if ((indexKeyColumns[i]->getNATable()->isHbaseCellTable()) ||
	      (indexKeyColumns[i]->getNATable()->isHbaseRowTable()) ||
              (indexKeyColumns[i]->isPrimaryKeyNotSerialized()) ||
              ((indexKeyColumns[i]->getNATable()->isHbaseMapTable()) &&
               (indexKeyColumns[i]->getNATable()->getClusteringIndex()->hasSingleColVarcharKey())))
	    {
	      ItemExpr * eq_node = (val_id_list[i].getValueDesc())->getItemExpr();
	      
	      ItemExpr * keycol = ((*eq_node)[0])->castToItemExpr();
	      ItemExpr * keyval = ((*eq_node)[1])->castToItemExpr();
	      
	      // do preCodeGen now, to avoid inserting scaling later
	      keyval = keyval->preCodeGen(generator);
	      
	      const NAType * sourceType = &(keyval->getValueId().getType());
	      const NAType * targetType = &(keycol->getValueId().getType());
	      
	      knode = new(wHeap()) Cast (keyval,targetType);
	      knode = knode->bindNode(generator->getBindWA());
	      knode = knode->preCodeGen(generator);
	    }
	  else
	    {
	      knode =
		generateKeyCast(val_id_list[i],
				dataConversionErrorFlag,
				!indexKeyColumns.isAscending(i),
				tf,
				possibleErrorCount /* in/out */,
				allChosenPredsAreEqualPreds,
                                FALSE);
	    }

	  key_val_id_list.insert(knode->getValueId());

	}

      generateContiguousMoveExpr(key_val_id_list,
                                 0, // don't add convert nodes,
                                 atp, atp_index, tf, keyLen,
                                 key_expr);
    }

  return 0;
}


short ExpGenerator::generateExclusionExpr(ItemExpr *expr,
					  Int32 atp,
					  Int32 atpindex,
					  ex_expr ** excl_expr)
{
  // if the begin/end key exclusion flag is dynamically calculated, generate
  // a move expression to get the value into a predetermined place
  if (expr)
    {
      // generate move expression
      ValueIdList exclusionResult;
      ULng32 resultLen;

      exclusionResult.insert(expr->getValueId());
      generateContiguousMoveExpr(
	   exclusionResult,
	   -1, // add convert node
	   atp,
	   atpindex,
	   ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
	   resultLen,
	   excl_expr);

      // executor has hard-coded assumption that the result is a long
      GenAssert(resultLen == sizeof(Lng32),
		"Exclusion flag expression result must have length 4");
    }
  return 0;
}

// generate code to do Describe Input and move input values
// from user area to executor area.
short ExpGenerator::generateInputExpr(const ValueIdList &val_id_list,
				      ex_expr::exp_node_type /* node_type */,
				      ex_expr ** expr)
{
  Space * space;
  Lng32 num_input_entries = 0;
  InputOutputExpr * ioExpr;
  Attributes ** attr;
  short retCode;

  initExprGen();

  space = getSpace();
  num_input_entries = 0;
  ioExpr = new(getSpace()) InputOutputExpr();
  *expr = ioExpr;

  (*expr)->setLength(getSpace()->getAllocatedSpaceSize());
  startExprGen(expr, ioExpr->getType());

  ValueId val_id;
  ex_inout_clause * input_clause = 0;

  const NABoolean isJdbc =
    (CmpCommon::getDefault(JDBC_PROCESS) == DF_ON ? TRUE : FALSE);
  const NABoolean isOdbc =
    (CmpCommon::getDefault(ODBC_PROCESS) == DF_ON ? TRUE : FALSE);

  for (CollIndex i = 0; i < val_id_list.entries(); i++)
    {
      val_id = val_id_list[i];

      ValueDesc * val_desc = val_id.getValueDesc();
      ItemExpr * item_expr = val_desc->getItemExpr();
      if ((item_expr->getOperatorType() == ITM_HOSTVAR) ||
	  (item_expr->getOperatorType() == ITM_DYN_PARAM))
	  {

	  item_expr->preCodeGen(generator);
	  item_expr->codeGen(generator);

	  const NAString *hostvarOrParamName = NULL;

	  if (item_expr->getOperatorType() == ITM_HOSTVAR)
	    {
	      hostvarOrParamName = &((HostVar *)item_expr)->getName();
	    }
	  else
	    {
	      hostvarOrParamName = &((DynamicParam *)item_expr)->getName();
	    }

	  Lng32 numAttrs = 1;
	  if (getShowplan())
	    numAttrs *= 2;

	  attr    = new(wHeap()) Attributes * [numAttrs];
	  //	  attr[0] = generator->getMapInfo(val_id)->getAttr();
	  attr[0] = generator->getAttr(item_expr);

	  if (getShowplan())
	    attr[1] =
	      new(wHeap()) ShowplanAttributes(val_id,
					      convertNAString(item_expr->getText(),
							      generator->wHeap()));

	  num_input_entries++;

	  // just give it ITM_CONVERT operator type since there is
	  // no ITM_INOUT type available.
	  input_clause = new(space) ex_inout_clause(ITM_CONVERT, attr, getSpace());

          // The name we assign to the clause will typically be the
          // host variable or dynamic parameter name or an empty name
          // if this is an unnamed dynamic paramter. There is one
          // exception though. When JDBC or ODBC compiles a CALL
          // statement and an IN or INOUT argument is a single UNNAMED
          // dynamic parameter, we assign the FORMAL parameter name to
          // the clause instead of the empty dynamic parameter name.
          const NAString *nameForClause = hostvarOrParamName;
          NABoolean isDynamicParam =
            (item_expr->getOperatorType() == ITM_DYN_PARAM ? TRUE : FALSE);

          if ((isOdbc || isJdbc) && isDynamicParam)
          {
            DynamicParam *param = (DynamicParam *) item_expr;
            const NAString &formalParamName = param->getUdrFormalParamName();
            if (!formalParamName.isNull())
            {
              // Note that we only come here for CALL statements
              const NAString &paramName = param->getName();
              if (paramName.isNull())
              {
                nameForClause = &formalParamName;
              }
            }
          }

          char *nameBuffer = getSpace()->
            AllocateAndCopyToAlignedSpace(*nameForClause, sizeof(Lng32));
          input_clause->setName(nameBuffer);

          if (isJdbc)
	    {
	      if (isDynamicParam) {
		  DynamicParam * param = (DynamicParam *)item_expr;
		  if (NOT param->getParamHeading().isNull())
		  {
		    char * heading =
		      getSpace()->AllocateAndCopyToAlignedSpace(param->getParamHeading(),
								sizeof(Lng32));
		    input_clause->setHeading(heading);
		  }

		if (NOT param->getParamTablename().isNull())
		  {
		    char * tablename =
		      getSpace()->AllocateAndCopyToAlignedSpace(param->getParamTablename(),
								sizeof(Lng32));
		    input_clause->setTableName(tablename);
		  }
		}
	      else { // HostVar
		  HostVar * hv = (HostVar *)item_expr;
		  if (NOT hv->getParamHeading().isNull())
		  {
		    char * heading =
		      getSpace()->AllocateAndCopyToAlignedSpace(hv->getParamHeading(),
								sizeof(Lng32));
		    input_clause->setHeading(heading);
		  }

		if (NOT hv->getParamTablename().isNull())
		  {
		    char * tablename =
		      getSpace()->AllocateAndCopyToAlignedSpace(hv->getParamTablename(),
								sizeof(Lng32));
		    input_clause->setTableName(tablename);
		  }
	      }
	    }

	  // Put CALL statement specific info into input clauses
	  short paramMode = mapMode(item_expr->getParamMode());
	  short paramIdx = (short) item_expr->getHVorDPIndex();

	  if(paramIdx) {
	    ioExpr->setCall(TRUE);
	  }
	  else{
	    ioExpr->setCall(FALSE);
	  }

	  short ordPos = (short) item_expr->getOrdinalPosition();

	  if(ioExpr->isCall()){
	    input_clause->setParamMode(paramMode);
	    input_clause->setParamIdx(paramIdx);
	    input_clause->setOrdPos(ordPos);
	  }
	  else{
	    BriefAssertion(paramMode==0,"Invalid value for param mode");
	    BriefAssertion(paramIdx==0,"Invalid value for param index");
	    BriefAssertion(ordPos==0,"Invalid value for ordinal position");
	    paramMode = PARAMETER_MODE_IN;
	    paramIdx = (short)num_input_entries;
	    ordPos = (short)num_input_entries;
	    input_clause->setParamMode(paramMode);
	    input_clause->setParamIdx(paramIdx);
	    input_clause->setOrdPos(ordPos);
	  }
	  // End
	  linkClause(0, input_clause);
	}
      else
	if ((item_expr->isAUserSuppliedInput()) || //evaluate once functions
		(item_expr->getOperatorType() == ITM_CURRENT_TIMESTAMP) ||
		(item_expr->getOperatorType() == ITM_UNIX_TIMESTAMP) ||
		(item_expr->getOperatorType() == ITM_SLEEP) ||
	    (item_expr->getOperatorType() == ITM_CURRENT_USER) ||
	    (item_expr->getOperatorType() == ITM_SESSION_USER) ||
            (item_expr->getOperatorType() == ITM_EXEC_COUNT) ||
	    (item_expr->getOperatorType() == ITM_CURR_TRANSID))
	{
	  item_expr->preCodeGen(generator);
	  item_expr->codeGen(generator);
	}
    }

  ioExpr->setNumEntries(num_input_entries);

  retCode = endExprGen(expr, -1);

  // Reset ioExpr since after endExprGen() it's possible that the space used
  // for the expression was copied elsewhere and deallocated.
  ioExpr = (InputOutputExpr*)(*expr);

  // if all clauses are inout clauses, then do not evaluate
  // input expr at runtime. This is an optimization.
  // Don't do this optimization if we no longer have a pointer to all clauses
  ex_clause * clause = ioExpr->getClauses();
  NABoolean allInoutClauses = (retCode) ? FALSE : TRUE;
  while ((clause) && (allInoutClauses))
    {
      if (clause->getType() != ex_clause::INOUT_TYPE)
	allInoutClauses = FALSE;

      clause = clause->getNextClause();
    }

  if (allInoutClauses)
    ioExpr->setNoEval(TRUE);

  if (isOdbc || isJdbc)
    {
      // skip type compatibility check at runtime between the user hvar
      // and the input value. Skipping the check will make all conversions
      // (if they are possible) go through. So a user hvar(char,
      // for example) could be converted to an integer input value.
      ioExpr->setSkipTypeCheck(TRUE);
    }

  if (CmpCommon::getDefault(IMPLICIT_HOSTVAR_CONVERSION) == DF_ON)
    {
      ioExpr->setSkipTypeCheck(TRUE);

      ioExpr->setRestrictedSkipTypeCheck(TRUE);
    }

  if (CmpCommon::getDefault(SUPPRESS_CHAR_LIMIT_CHECK) == DF_ON)
    // suppress the fix for TRAFODION-2719, use this only
    // if the new behavior causes a regression in an existing
    // application that cannot be fixed easily
    ioExpr->setSuppressCharLimitCheck(TRUE);

  if ( CmpCommon::getDefault(MARIAQUEST_PROCESS) == DF_ON ) 
    {
      ioExpr->setNoDatetimeValidation(TRUE);
    }

  return 0;
}


// input is a ValueIdList
short ExpGenerator::generateListExpr(const ValueIdList      &val_id_list,
				     ex_expr::exp_node_type  node_type,
				     ex_expr               **expr,
                                     Int32                   atp,
                                     Int32                   atpIndex,
                                     ExpHdrInfo             *hdrInfo)
{
  if (val_id_list.entries() == 0)
    {
      return 0;
    }

  ValueIdList * vidList = (ValueIdList *)&val_id_list;

  /*
  // Do constant folding and simplify expressions.
  ValueIdList tempList;
  tempList = vidList->constantFolding();
  if (!tempList.isEmpty())
    {
      vidList = &tempList;
    }
    */

  initExprGen();
  startExprGen(expr, node_type);

  if ( hdrInfo != NULL )
  {
    if (atp < 0)
    {
      Attributes *attr = generator->getMapInfo( (*vidList)[0] )->getAttr();
      atp = attr->getAtp();
      atpIndex = attr->getAtpIndex();
    }    
    generateHeaderClause(atp, atpIndex, hdrInfo);
  }

  ValueId val_id;
  for (CollIndex i = 0; i < vidList->entries(); i++)
    {
      val_id = (*vidList)[i];

      // generate code for this node and the tree under it
      ItemExpr *itmExpr = val_id.getValueDesc()->getItemExpr();
#ifdef GEN_SF_SC_BUG_TESTING
      if(getenv("GEN_ENABLE_SF_PROTECT_ALL"))
	itmExpr->protectiveSequenceFunctionTransformation(generator);
#endif
      itmExpr = itmExpr->preCodeGen(generator);
      itmExpr->codeGen(generator);
    }

  endExprGen(expr, -1);

  return 0;
}

short ExpGenerator::genGuardedListExpr(const ValueIdSet guard,
                                       const ValueIdList &val_id_list,
                                       ex_expr::exp_node_type node_type,
                                       ex_expr ** expr)
{
  if (val_id_list.entries() == 0 && guard.entries() == 0) {
    return 0;
  }

  ItemExpr *guardedTree = NULL;

  if(val_id_list.entries() == 0 && guard.entries() != 0) {
    guardedTree = new(wHeap()) BoolResult(guard.rebuildExprTree(ITM_AND));
  } else if(guard.entries() == 0) {
    guardedTree = new(wHeap())
      BoolResult(new(wHeap())
                 ItemList(val_id_list.rebuildExprTree(ITM_ITEM_LIST),
                          new(wHeap()) BoolVal(ITM_RETURN_TRUE)));
  } else {

    ItemExpr * trueListTree = new(wHeap())
      ItemList(val_id_list.rebuildExprTree(ITM_ITEM_LIST),
               new(wHeap()) BoolVal(ITM_RETURN_TRUE));

    guardedTree = new(wHeap())
      BoolResult(new (wHeap())
                 BiLogic(ITM_AND,
                         guard.rebuildExprTree(ITM_AND),
                         trueListTree));
  }

  guardedTree->bindNode(generator->getBindWA());

  generateExpr(guardedTree->getValueId(),
               ex_expr::exp_SCAN_PRED,
               expr);

  return 0;
}

// generate code to do Describe Output and move output values
// from executor area to user area.
short ExpGenerator::generateOutputExpr(const ValueIdList &val_id_list,
				       ex_expr::exp_node_type /* node_type */,
				       ex_expr ** expr,
				       RETDesc * ret_desc,
                                       const ItemExprList *spOutParams,
                                       ConstNAStringPtr *colNamesForExpr,
                                       ConstQualifiedNamePtr *tblNamesForExpr)
{
  Lng32 rc;
  Space* space;
  Lng32 num_output_entries;
  InputOutputExpr * ioExpr;

  initExprGen();

  space = getSpace();

  num_output_entries = 0;

  ioExpr = new(getSpace()) InputOutputExpr();
  *expr = ioExpr;

  (*expr)->setLength(getSpace()->getAllocatedSpaceSize());
  startExprGen(expr, ioExpr->getType());

  ValueId val_id;
  ex_inout_clause * output_clause = 0;

  const NABoolean isJdbc =
    (CmpCommon::getDefault(JDBC_PROCESS) == DF_ON ? TRUE : FALSE);
  const NABoolean isOdbc =
    (CmpCommon::getDefault(ODBC_PROCESS) == DF_ON ? TRUE : FALSE);

  const NABoolean isCallStatement = (spOutParams ? TRUE : FALSE);

  // Output expression must produce result in exploded format.
  generator->setExplodedInternalFormat();

  // Normally the name we assign to an unnamed column is "(EXPR)".
  // However for CALL statements, ODBC and JDBC requested we use an
  // empty string.
  NAString empty_colname("(EXPR)", CmpCommon::statementHeap());
  if (isCallStatement && (isOdbc || isJdbc))
    empty_colname = "";

  for (CollIndex i = 0; i < val_id_list.entries(); i++)
  {
    val_id = val_id_list[i];
    ItemExpr * item_expr = val_id.getItemExpr();

    char *nameForClause = 0;
    char *heading = 0;
    char *tableName = 0;
    char *schemaName = 0;
    char *catalogName = 0;

    ItemExpr *spOutExpr = NULL;
    if (isCallStatement)
    {
      spOutExpr = (*spOutParams)[i];
      BriefAssertion(spOutExpr, "Unmatched spOutParams");
    }

    // We allow the caller of this function to inject special names
    // into the generated object. Currently this is only being done
    // for stored procedure result set proxy plans. If a special
    // column name was passed in, colNameFromCaller will point to it.
    const NAString *colNameFromCaller =
      (colNamesForExpr ? colNamesForExpr[i] : NULL);

    // colNameFromRETDesc is the column name from the RETDesc
    const NAString colNameFromRETDesc
      (ret_desc->getColRefNameObj(i).getColNameAsAnsiString());

    // The next IF block will set colname_ptr to point to the name we
    // want in the generated object
    const NAString *colname_ptr = NULL;

    if (colNameFromCaller)
    {
      // The caller wants a special name
      colname_ptr = colNameFromCaller;
    }
    else
    {
      // Use the name from the RETDesc or if that name is not
      // specified, use our manufactured name for unnamed columns
      if (colNameFromRETDesc.length() > 0)
        colname_ptr = &colNameFromRETDesc;
      else
        colname_ptr = &empty_colname;

      // For CALL statements, ODBC and JDBC requested that non-empty
      // parameter names in the SQL text (e.g. "call foo(?x)") take
      // precedence over formal parameter names.
      NAString spOutParamName("", CmpCommon::statementHeap());
      if (isCallStatement && (isOdbc || isJdbc))
      {
        // Even though ODBC and JDBC always do dynamic compiles, we
        // also check for a named static host variable here, to cover
        // the case of SQLJ static compiles. SQLJ static plans are
        // generated with the ODBC_PROCESS default turned on and
        // involve the JDBC runtime stack during execution.
        if (spOutExpr->getOperatorType() == ITM_DYN_PARAM)
          spOutParamName = ((DynamicParam *) spOutExpr)->getName();
        else if (spOutExpr->getOperatorType() == ITM_HOSTVAR)
          spOutParamName = ((HostVar *) spOutExpr)->getName();

        if (spOutParamName.length() > 0)
        {
          colname_ptr = &spOutParamName;
        }
      }

    } // if (colNameFromCaller) else ...

    nameForClause =
      space->AllocateAndCopyToAlignedSpace(*colname_ptr, sizeof(Lng32));

    if (ret_desc->getHeading(i) != NULL)
    {
      heading =
        space->allocateAndCopyToAlignedSpace(ret_desc->getHeading(i),
                                             strlen(ret_desc->getHeading(i)),
                                             sizeof(Lng32));
    }

    // if the output expression (item_expr) and the select list
    // item (from ret_desc) do not have the same type, generate
    // conversion clause.
    item_expr = item_expr->preCodeGen(generator);
    val_id = item_expr->getValueId();

    // If the value is in compressed format, then conversion
    // nodes must be added to convert back to exploded format.
    // Sometimes this is done already - i.e., in the split bottom of top level
    // ESPs.
    NABoolean genConvertNodes = false;
    MapInfo *mapInfo = generator->getMapInfoAsIs(val_id);
    if(mapInfo) {
      genConvertNodes = mapInfo->getAttr()->isSQLMXAlignedFormat();
    }
    else
    {
      if(item_expr->getOperatorType() == ITM_BASECOLUMN) {
        item_expr->codeGen(generator);
        MapInfo *mapInfo = generator->getMapInfoAsIs(val_id);
        if(mapInfo) {
          genConvertNodes = mapInfo->getAttr()->isSQLMXAlignedFormat();
        }
      }
    }

    if ( (NOT(val_id.getType() == ret_desc->getType(i))) || genConvertNodes )
    {
      {
      
         item_expr = new(wHeap()) Cast(item_expr, &(ret_desc->getType(i)));
      }

      item_expr->bindNode(generator->getBindWA());
    }

    ItemExpr * temp = item_expr->preCodeGen(generator);
    ItemExpr *outExpr = NULL;
    rc = foldConstants(temp, &outExpr);
    if ((rc == 0) && (outExpr))
      temp = outExpr;
    temp->codeGen(generator);

    {
      MapInfo *mapInfo = generator->getMapInfoAsIs(temp->getValueId());
      GenAssert(mapInfo, "no mapinf");
      GenAssert(!mapInfo->getAttr()->isSQLMXAlignedFormat(), "Aligned Output");
    }

    //attr = new(wHeap()) Attributes * [1];
    ItemExpr * outNode
      = new(wHeap()) NATypeToItem((NAType *)&temp->getValueId().getType());
    outNode->synthTypeAndValueId();

    Attributes ** attr;
    if (genItemExpr(outNode, &attr, 1, -1) == 1)
      return 0;

    attr[0]->copyLocationAttrs(
      generator->getMapInfo(((ItemExpr *)temp)->getValueId())->getAttr());

    if (genConvertNodes)
    {// bulk move may cause an issue where the values are overriden
      attr[0]->setBulkMoveable(FALSE);
    }
    //attr[0] = getMapTable()->getMapInfo(((ItemExpr *)temp)->getValueId())->getAttr();

    // Get the table/catalog and schema names
    // We get this from the ret_desc because we want the original column
    // list - NOT the VEG transformed column list because some of the
    // columns may have been replaced by constants.

    // We also allow the caller of this function to inject special
    // names into the generated object. Currently this is only being
    // done for stored procedure result set proxy plans.
    const QualifiedName *tblNameFromCaller =
      (tblNamesForExpr ? tblNamesForExpr[i] : NULL);

    // Another case to consider is that NO catalog/schema/table names
    // should be set for this column. In that case, the following
    // boolean should remain FALSE.
    NABoolean tableNameShouldBeSet = FALSE;

    if (tblNamesForExpr)
    {
      if (tblNameFromCaller)
        tableNameShouldBeSet = TRUE;
    }
    else if (((ret_desc->getValueId(i)).getItemExpr()->getOperatorType()
              == ITM_BASECOLUMN) ||
             ((ret_desc->getValueId(i)).getItemExpr()->getOperatorType()
              == ITM_INDEXCOLUMN))
    {
      tableNameShouldBeSet = TRUE;
    }

    if (tableNameShouldBeSet)
    {
      // Initially we set qaname to the caller's special name. If that
      // name was not specified then qaname is changed to point to the
      // name from the RETDesc.
      const QualifiedName *qaname = tblNameFromCaller;

      if (qaname == NULL)
      {
        NAColumn *column = (ret_desc->getValueId(i)).getNAColumn();
        qaname = (const QualifiedName *) column->getTableName(TRUE);
      }

      if (NOT qaname->getObjectName().isNull())
      {
        tableName = space->AllocateAndCopyToAlignedSpace
          (qaname->getObjectName(), sizeof(Lng32));
      }

      // If nametype is Shortansi, we need to extract the schema name
      // from bindWA because at this point the shortansi name has been
      // converted to NSK format. We do not consider SHORTANSI cases
      // when the caller of this function is passing in special table
      // names.
      if (tblNameFromCaller == NULL && SqlParser_NAMETYPE == DF_SHORTANSI)
      {
        SchemaName shortAnsiSchema = ActiveSchemaDB()->getDefaultSchema();

        if (NOT shortAnsiSchema.getSchemaName().isNull())
          schemaName = space->AllocateAndCopyToAlignedSpace
            (shortAnsiSchema.getSchemaName(),sizeof(Lng32));

        if (NOT shortAnsiSchema.getCatalogName().isNull())
          catalogName = space->AllocateAndCopyToAlignedSpace
            (shortAnsiSchema.getCatalogName(),sizeof(Lng32));
      }
      else
      {
        if (NOT qaname->getSchemaName().isNull())
        {
          schemaName = space->AllocateAndCopyToAlignedSpace
            (qaname->getSchemaName(),sizeof(Lng32));
        }
        if (NOT qaname->getCatalogName().isNull())
        {
          catalogName = space->AllocateAndCopyToAlignedSpace
            (qaname->getCatalogName(), sizeof(Lng32));
        }
      }

    } // if (tableNameShouldBeSet)

    output_clause = new(space) ex_inout_clause(ITM_NATYPE, attr, space);

    num_output_entries++;

    output_clause->setName(nameForClause);
    output_clause->setHeading(heading);

    // Put CALL statement specific info into output clauses
    if (spOutExpr)
    {
      short paramMode = mapMode(spOutExpr->getParamMode());
      short paramIdx = (short) spOutExpr->getHVorDPIndex();

      if (paramIdx != 0)
        ioExpr->setCall(TRUE);
      else
        BriefAssertion(0, "Invalid parameter index");

      short ordPos = (short) spOutExpr->getOrdinalPosition();
      output_clause->setParamMode(paramMode);
      output_clause->setParamIdx(paramIdx);
      output_clause->setOrdPos(ordPos);

    }
    else
    {
      short paramMode = PARAMETER_MODE_OUT;
      short paramIdx = 0;
      short ordPos = 0;
      output_clause->setParamMode(paramMode);
      output_clause->setParamIdx(paramIdx);
      output_clause->setOrdPos(ordPos);
    }

    output_clause->setTableName(tableName);
    output_clause->setSchemaName(schemaName);
    output_clause->setCatalogName(catalogName);

    linkClause(0, output_clause);

  } // for each entry in the ValueId list

  if (output_clause)
  {
    short retCode;

    ioExpr->setNumEntries(num_output_entries);

    output_clause->setLastClause();

    retCode = endExprGen(expr, 0);

    // Reset ioExpr since after endExprGen() it's possible that the space used
    // for the expression was copied elsewhere and deallocated.
    ioExpr = (InputOutputExpr*)(*expr);

    // if all clauses are inout clauses, then do not evaluate
    // output expr at runtime. This is an optimization.
    // Don't do this optimization if we no longer have a pointer to all clauses
    ex_clause * clause = ioExpr->getClauses();
    NABoolean allInoutClauses = (retCode) ? FALSE : TRUE;
    while ((clause) && (allInoutClauses))
    {
      if (clause->getType() != ex_clause::INOUT_TYPE)
        allInoutClauses = FALSE;

      clause = clause->getNextClause();
    }

    if (allInoutClauses)
      ioExpr->setNoEval(TRUE);

    if (isOdbc || isJdbc)
    {
      // skip type compatibility check at runtime between the user hvar
      // and the input value. Skipping the check will make all conversions
      // (if they are possible) go through. So a user hvar(char,
      // for example) could be converted to an integer input value.
      ioExpr->setSkipTypeCheck(TRUE);
    }

    if ((CmpCommon::getDefault(IMPLICIT_HOSTVAR_CONVERSION) == DF_ON) ||
        (CmpCommon::getDefault(IMPLICIT_DATETIME_INTERVAL_HOSTVAR_CONVERSION) == DF_ON))
    {
      ioExpr->setSkipTypeCheck(TRUE);

      ioExpr->setRestrictedSkipTypeCheck(TRUE);
    }
  } // output_clause

  return 0;
}

// input is a ValueIdSet
short ExpGenerator::generateSetExpr(const ValueIdSet &val_id_set,
				    ex_expr::exp_node_type node_type,
				    ex_expr ** expr,
				    short gen_last_clause,
                                    ExpHdrInfo * hdrInfo)
{
  ValueId val_id;
  val_id = val_id_set.init();
  if (!val_id_set.next(val_id))
    return 0; // empty set

  initExprGen();
  startExprGen(expr, node_type);

  if (hdrInfo != NULL)
  {
    Attributes *attr = generator->getMapInfo(val_id)->getAttr();
    generateHeaderClause(attr->getAtp(), attr->getAtpIndex(), hdrInfo);
  }

  for (val_id = val_id_set.init(); val_id_set.next(val_id); val_id_set.advance(val_id))
    {
      // generate code for this node and the tree under it
      ItemExpr * temp =
	val_id.getValueDesc()->getItemExpr()->preCodeGen(generator);
      temp->codeGen(generator);
    }

  endExprGen(expr, gen_last_clause);

  return 0;
}

// generateSequenceExpression
//
short ExpGenerator::generateSequenceExpression(const ValueIdSet &sequenceItems, 
                                               ex_expr* &expr)
{
  // If there are no items, just return
  //
  if (sequenceItems.isEmpty()) return 0;

  initExprGen();
  setInSequenceFuncExpr(TRUE);
  startExprGen(&expr, ex_expr::exp_ARITH_EXPR);

  // Loop over the sequence items calling the protective short-circuit
  // transformation, preCodeGen and codeGen on each.
  //
  ValueId valId;
  for (valId = sequenceItems.init();
       sequenceItems.next(valId);
       sequenceItems.advance(valId))
    {
      ItemExpr *itmExpr = valId.getValueDesc()->getItemExpr();
#ifdef GEN_SF_SC_BUG_TESTING
      if(!getenv("GEN_DISABLE_SF_PROTECT"))
#endif
	itmExpr->protectiveSequenceFunctionTransformation(generator);
      itmExpr = valId.getValueDesc()->getItemExpr();
      itmExpr = itmExpr->preCodeGen(generator);
      itmExpr->codeGen(generator);
    }

  setInSequenceFuncExpr(FALSE);
  // Finalize the expression generation machinery.
  //
  endExprGen(&expr, 1);

  return 0;
}

// input is a list of ValueIdUnion.
short ExpGenerator::generateUnionExpr(const ValueIdList &val_id_list,
				      ex_expr::exp_node_type node_type,
				      ex_expr ** left_expr,
				      ex_expr ** right_expr)
{
  // generate code to move the left child row to result row

  initExprGen();
  startExprGen(left_expr, node_type);

  Space * space = getSpace();

  CollIndex i = 0;
  for (i = 0; i < val_id_list.entries(); i++)
    {
      ValueIdUnion * vidu_node = (ValueIdUnion *)(((val_id_list[i]).getValueDesc())->getItemExpr());
      ItemExpr * left_node = ((vidu_node->getLeftSource()).getValueDesc())->getItemExpr();

      Attributes ** attr = new(wHeap()) Attributes * [2];
      ex_conv_clause * conv_clause;

      /* assign result attributes*/
      attr[0] = generator->getMapInfo(vidu_node->getResult())->getAttr();

      ItemExpr * temp = left_node->preCodeGen(generator);
      temp->codeGen(generator);

      attr[1] = generator->getMapInfo(((ItemExpr *)temp)->getValueId())->getAttr();
      conv_clause = new(space) ex_conv_clause(ITM_CONVERT, attr, space);
      linkClause(0, conv_clause);
    }

  endExprGen(left_expr, -1);

  // generate code to move the right child row to result row
  initExprGen();
  startExprGen(right_expr, node_type);

  // Reset space since temporary space object may be used
  space = getSpace();

  for (i = 0; i < val_id_list.entries(); i++)
    {
      ValueIdUnion * vidu_node = (ValueIdUnion *)(((val_id_list[i]).getValueDesc())->getItemExpr());
      ItemExpr * right_node = ((vidu_node->getRightSource()).getValueDesc())->getItemExpr();

      Attributes ** attr = new(wHeap()) Attributes * [2];
      ex_conv_clause * conv_clause;

      /* assign result attributes*/
      attr[0] = generator->getMapInfo(vidu_node->getResult())->getAttr();

      ItemExpr * temp = right_node->preCodeGen(generator);
      temp->codeGen(generator);

      attr[1] = generator->getMapInfo(((ItemExpr *)temp)->getValueId())->getAttr();
      conv_clause = new(space) ex_conv_clause(ITM_CONVERT, attr, space);
      linkClause(0, conv_clause);
    }

  endExprGen(right_expr, -1);

  return 0;
}


short ExpGenerator::processAttributes(ULng32 numAttrs,
				      Attributes ** attrs,
				      ExpTupleDesc::TupleDataFormat tdataF,
				      ULng32 &tupleLength,
				      Int32 atp,
				      Int32 atpIndex,
				      ExpTupleDesc ** tupleDesc,
				      ExpTupleDesc::TupleDescFormat tdescF,
				      ULng32 startOffset,
                                      ExpHdrInfo  * hdrInfo)
{
  ULng32 tuppDescFlags = 0x0;

  ExpTupleDesc::computeOffsets(numAttrs,
			       attrs,
			       tdataF,
			       tupleLength,
			       startOffset,
			       &tuppDescFlags,
			       &tdataF,
                               hdrInfo);

  for (Int32 i = 0; i < (Int32) numAttrs; i++)
    {
      attrs[i]->setAtp(atp);
      attrs[i]->setAtpIndex(atpIndex);
      attrs[i]->setDefaultFieldNum(i);		// this is needed for handling
						// SQL/MP added cols correctly.
    }

  // if tuple descriptor is to be returned, allocate it in 'space'
  if (tupleDesc)
    {
      *tupleDesc
	= new(getSpace()) ExpTupleDesc(numAttrs, attrs, tupleLength,
				       tdataF, tdescF, getSpace());
      (*tupleDesc)->setFlags(tuppDescFlags);
    }

  return 0;
}

short ExpGenerator::processValIdList(ValueIdList valIdList,
				     ExpTupleDesc::TupleDataFormat tdataF,
				     ULng32 &tupleLength,
				     Int32 atp,
				     Int32 atpIndex,
				     ExpTupleDesc ** tupleDesc,
				     ExpTupleDesc::TupleDescFormat tdescF,
				     Lng32 startOffset,
				     Attributes ***returnedAttrs,
                                     NAColumnArray *colArray,
                                     NABoolean isIndex,
                                     NABoolean placeGuOutputFunctionsAtEnd,
                                     ExpHdrInfo * hdrInfo)
{
  MapTable * myMapTable = generator->appendAtEnd();
  Attributes ** attrs = new(wHeap()) Attributes * [valIdList.entries()];

  NABoolean alignedFormat = (tdataF == ExpTupleDesc::SQLMX_ALIGNED_FORMAT);
  NAColumn *col;

  for (CollIndex i = 0; i < valIdList.entries(); i++)
    {
      // get a pointer to the map table attributes and set them the
      // way we want them to be
      attrs[i] = (generator->addMapInfoToThis(myMapTable, valIdList[i], 0))->getAttr();

      // If this is a GenericUpdateOutputFunction
      // and we want these handled specially - mark the attr.
      if (valIdList[i].getItemExpr()->isAGenericUpdateOutputFunction()
          && placeGuOutputFunctionsAtEnd)
	attrs[i]->setGuOutput();

      // There are times we don't have a column array and must use the value id
      // list to get to the attribute and mark it special (DP2Scan is one place).
      // The attribute must be marked 'special' before computing offsets since
      // for the aligned format we may re-arrange fixed size columns, but
      // can NOT re-arrange added columns.
      // Note that indexes (non-clustering indexes) do not have added columns,
      // because we cannot do an alter index add column operation.
      if ( alignedFormat &&
           !isIndex &&
           ( colArray == NULL ) &&
           ((col = valIdList[i].getNAColumn( TRUE )) != NULL) &&
           col->isAddedColumn() )
        attrs[i]->setAddedCol();
    }

  // Ensure added columns are tagged before computing offset for the aligned
  // record format since added columns are arranged differently.
  if ( (colArray != NULL) )
  {
    for( Int32 i = 0; i < (Int32)colArray->entries(); i++ )
    {
      col = (*colArray)[i];
      if (( col->isAddedColumn() ) && (!isIndex))
        attrs[i]->setAddedCol();
    }
  }

  ExpHdrInfo *retHdrInfo = NULL;
  if ( isHeaderNeeded(tdataF) )
    retHdrInfo = hdrInfo;

  // compute offsets and create tuple descriptor.
  processAttributes((ULng32)valIdList.entries(), attrs, tdataF,
		    tupleLength, atp, atpIndex,  tupleDesc, tdescF,
		    startOffset, retHdrInfo);

  if (returnedAttrs)
    {
      // caller wants array of Attributes pointers returned
      *returnedAttrs = attrs;
    }
  else
    {
      // deallocate the attributes array. Don't deallocate the attributes
      // pointed to by the array entries since we didn't allocate them.
      NADELETEBASIC( attrs, wHeap());
    }

// Below is commented out:  it doesn't work because we're adding the wrong
// attributes.  Can't get the correct ones any more because they will have
// been removed by ExpGenerator::endExprGen (removeLast).
// (This code was added, found wanting, and commented out trying to fix
// Genesis 10-980112-5942.)
//
//for (i = 0; i < valIdList.entries(); i++)
//  {
//    ValueId vid = valIdList[i];
//    ValueId vidRepl = vid.getItemExpr()->getReplacementExpr()->getValueId();
//    if (vidRepl != vid)
//	myMapTable->addMapInfo(vidRepl, myMapTable->getMapInfo(vid)->getAttr());
//  }

  return 0;
}


short ExpGenerator::computeTupleSize(const ValueIdList & valIdList,
                                     ExpTupleDesc::TupleDataFormat tdataF,
                                     ULng32 &tupleLength,
                                     Lng32 startOffset,
                                     UInt32 * varCharSize,
                                     UInt32 * headerSize)
{
  MapTable * myMapTable = generator->appendAtEnd();
  UInt32 vcSize = 0;
  UInt32 numAttrs = valIdList.entries();

  Attributes ** attrs = new(wHeap()) Attributes * [numAttrs];
  
  for (CollIndex i = 0; i < valIdList.entries(); i++)
  {
    attrs[i] = (generator->addMapInfoToThis(myMapTable, valIdList[i], 0))->getAttr();
  }

  UInt32 rtnFlags = 0x0;
  if (varCharSize)
    *varCharSize = 0;

  ExpTupleDesc::computeOffsets((ULng32)numAttrs,
                               attrs,
                               tdataF,
                               tupleLength,
                               startOffset,
                               &rtnFlags,
                               NULL,
                               NULL,
                               headerSize,
                               varCharSize);
 
   // deallocate the attributes array. 
   NADELETEBASIC( attrs, wHeap());
  
   if (myMapTable != NULL)
    generator->unlinkMe(myMapTable);


  return 0;
}

short ExpGenerator::assignAtpAndAtpIndex(ValueIdList valIdList,
					 Int32 atp,
					 Int32 atpIndex)
{
  for (CollIndex i = 0; i < valIdList.entries(); i++)
    {
      Attributes * attr = generator->getMapInfo(valIdList[i])->getAttr();
      if (atp >= 0)
	attr->setAtp(atp);
      if (atpIndex >= 0)
	attr->setAtpIndex(atpIndex);
    }

  return 0;
}

Int32 shafoo() {
  return 10;
}

// Called just before the start of expr generation to determine what space
// object to store the expression in.
void ExpGenerator::initExprGen()
{
#ifdef NEW_LEAN_EXPR
  // Attempt to create tempSpace only if we are compiling for leaner
  // expressions.  Also, only do this if PCODE generation is on *and* we're not
  // just generating PCODE for clause evaluation purposes.  Also, the internal
  // PCODE_NO_LEANER_EXPR mode may be set if there are certain expressions we
  // just don't want to make leaner for whatever reasons.  And also :), don't
  // do this if we're compiling for a showplan.

  if ((CmpCommon::getDefault(GEN_LEANER_EXPRESSIONS) == DF_ON) &&
      !(pCodeMode_ & ex_expr::PCODE_NO_LEANER_EXPR) &&
      (pCodeMode_ & ex_expr::PCODE_ON) &&
      !(pCodeMode_ & ex_expr::PCODE_EVAL))
  {
    // Only create tempSpace if it hasn't been created already.  This is done
    // specifically because AggrExpr attempts to create the expression first by
    // calling new() (as opposed to letting startExprGen do it), and then calls
    // generateSetExpr() to create all the clauses.  Since both need to be
    // in tempSpace, initExprGen() gets called twice, so we don't want to
    // create/delete tempSpace twice.

    if (generator->getTempSpace() == NULL) {
      ComSpace * space = new(wHeap()) ComSpace(ComSpace::GENERATOR_SPACE);
      space->setParent(wHeap());
      generator->setTempSpace(space, TRUE);
    }
  }
#endif
}

// called at the start of expr generation
short ExpGenerator::startExprGen(ex_expr ** expr,
				 ex_expr::exp_node_type node_type)
{
  if (*expr == 0)
    *expr = new(getSpace()) ex_expr(node_type);
  (*expr)->setLength(getSpace()->getAllocatedSpaceSize());

  // copy handleIndirectVC flag from expGenerator to expr
  (*expr)->setHandleIndirectVC( handleIndirectVC() );

  // copy forInsertUpdate flag from expGenerator to expr
  (*expr)->setForInsertUpdate( forInsertUpdate() );

  // set up pointer to NExDbgInfo object
  (*expr)->setNExDbgInfo( generator->getNExDbgInfoAddr() ) ;

  mapTableAllocated = -1;
  mapTable_ = generator->appendAtEnd();

  initClauseList();
  initConstantList();
  initPersistentList();

  savePCodeMode();

  return 0;
}

// Input: gen_last_clause, if not passed in or -1, generate a last NO-OP clause
short ExpGenerator::endExprGen(ex_expr ** expr, short gen_last_clause)
{
  UInt32 optFlags;
  short retCode = 0;

  gen_last_clause = 0;

  // Certain expressions may request no PCode to be generated, otherwise
  // get the PCode mode from the ctor ExpGenerator and set it in the
  // expression itself.  This allows us to regenerate PCode at runtime
  // (for versioning) with the same mode specified at compile time.
  (*expr)->setPCodeMode( getPCodeMode() );

  // Get default low-level opt flags and prevent predicate reordering from
  // happening if this expression represents a case statement.
  optFlags = (UInt32)CmpCommon::getDefaultLong(PCODE_OPT_FLAGS);

  UInt32 Enbld = (UInt32)CmpCommon::getDefaultLong(PCODE_NE_ENABLED);
  if ( Enbld == 0 )
     optFlags &= ~( PCodeCfg::NATIVE_EXPR ); // Disable Native Exprs in optFlags

  Enbld = (UInt32)CmpCommon::getDefaultLong(PCODE_EXPR_CACHE_ENABLED);
  if ( Enbld == 0 )
     optFlags |= PCodeCfg::OPT_PCODE_CACHE_DISABLED ; // Disable feature in optFlags

  Enbld = (UInt32)CmpCommon::getDefaultLong(PCODE_EXPR_CACHE_CMP_ONLY);
  if ( Enbld == 1 )
     optFlags |= ( PCodeCfg::EXPR_CACHE_CMP_ONLY ); // Enable Compare-Only mode -- FOR TESTING!

  if (caseStmtGenerated()) {
    optFlags &= ~(PCodeCfg::REORDER_PREDICATES);
    setCaseStmtGenerated(FALSE);
  }

  // Set pcode low-level optimization flags for this expression
  (*expr)->setPCodeOptFlags(optFlags);

  // Set pcode Max Branch Cnt and Max Instr Cnt for PCODE optimization
  UInt32 maxBrnchCnt = (UInt32)CmpCommon::getDefaultLong(PCODE_MAX_OPT_BRANCH_CNT);
  UInt32 maxInstCnt  = (UInt32)CmpCommon::getDefaultLong(PCODE_MAX_OPT_INST_CNT);
  (*expr)->setPCodeMaxOptBrCnt(maxBrnchCnt);
  (*expr)->setPCodeMaxOptInCnt(maxInstCnt);

  if (gen_last_clause)
    {
      /* generate a no-op clause and set it to be the last clause */
      ex_noop_clause *clause = new(getSpace()) ex_noop_clause;
      clause->setLastClause();
      linkClause(0, clause);
    }

  // fixup the next clause pointers
  fixupNextClause();

  // Set the constant expression storage length and area.
  //
  char * constants_area = placeConstants(getConstantList(), getConstLength());
  (*expr)->setConstantsArea(constants_area);
  (*expr)->setConstsLength(getConstLength());

  // Set the persistent expression storage length and initialization area.
  //
  char *persistentInitializationArea
    = placeConstants(getPersistentList(), persistentLength());
  (*expr)->persistentInitializationArea() = persistentInitializationArea;
  (*expr)->persistentLength() = persistentLength();
  (*expr)->persistentArea()
    = getSpace()->allocateAlignedSpace(persistentLength());


  // Set the temporary expression storage length.
  //
  (*expr)->setTempsLength(getTempsLength());

  // set the pointer to the first clause in the ex_expr
  (*expr)->setClauses((ex_clause *)(getClauseList()->getElement()));

  // Fixup the pointers to the constant, temporary, and persistent
  // expression areas.
  //
  //  (*expr)->setFixupConstsAndTemps((short)getFixupConstsAndTemps());

  if (mapTableAllocated)
    {
      mapTable_ = 0;
      generator->removeLast();
    }

  Lng32 len1 = getSpace()->getAllocatedSpaceSize();

  // generate pcode at compile time
  UInt32 f = 0;
  ex_expr_base::setForShowplan(f, FALSE);
  if (generator->genNoFloatValidatePCode())
    ex_expr_base::setNotValidateFloat64(f, TRUE);

  (*expr)->pCodeGenerate(getSpace(), wHeap(), f);
  (*expr)->setPCodeGenCompile(1);
  if ((*expr)->getPCodeNative() &&
      CmpCommon::getDefault(PCODE_NE_IN_SHOWPLAN) == DF_ON)
    (*expr)->setNEInShowplan(TRUE);

  Lng32 pcodeExprLen = getSpace()->getAllocatedSpaceSize() - len1;
  Lng32 totalExprLen =
    getSpace()->getAllocatedSpaceSize() - (*expr)->getLength();

  (*expr)->setLength(totalExprLen);
#ifdef NEW_LEAN_EXPR
  // If tempSpace exists, then the entire expression was written to it, so
  // we need to now make a "lean" copy of it and copy it back into the
  // fragment space.

  // If we are in the process or generating container expressions, then
  // no need to copy to fragment space yet, let's wait till we complete
  // generating the main expression.
  // Note: The term Container Expression is used to denote an expression
  // - ex_expr within an expression - ex_expr.
  if(inContainerExpr())
    return 0;

  ComSpace * tempSpace = generator->getTempSpace();

  NABoolean saveClauses = (getShowplan() || saveClausesInExpr());

  if (tempSpace)
  {
    ex_expr_base * newExpr = NULL;
    NABoolean branchFound = FALSE;

    // Reset tempSpace back to NULL.  Calls to getSpace() will now return the
    // fragment space.
    generator->setTempSpace(NULL, FALSE);

    // If no pCode was generated for this expression, or if the generated
    // pCode contains a clause eval instruction, we need to selectively copy
    // in the expression from tempSpace into the fragment space.  Otherwise,
    // the expression can completely rid itself of it's clauses and we can
    // make a very lean copy of it.

    // Copying some expressions is too hard because they contain clauses with
    // too many embedded pointers which need copying.  Be selective.
    NABoolean tooHard = FALSE;
    for (ex_clause* clause = (*expr)->getClauses();
         clause;
         clause = clause->getNextClause())
      {
        if ((clause->getClassID() == ex_clause::FUNC_HBASE_COLUMN_CREATE) ||
	    (clause->getClassID() == ex_clause::FUNC_HBASE_COLUMNS_DISPLAY))
	  tooHard = TRUE;
        break;
      }

    if (!tooHard && ((*expr)->getPCodeSegment() != NULL))
    {
      // Needed to set the length of the expression
      len1 = getSpace()->getAllocatedSpaceSize();

      // Previous clause ptr
      ex_clause* prevClause = NULL;

      // Determine size of expression.
      totalExprLen = (*expr)->getClassSize();

      // Allocate space in fragment space for just the expression class and
      // copy it over from the expr (which is in tempSpace).
      newExpr = (ex_expr_base*)
          new(generator->getSpace()) char[totalExprLen];
      str_cpy_all((char*)newExpr, (char*)(*expr), totalExprLen);

      // Call makeLeanCopyAll to just copy over the pCode and other stuff (but
      // not the clauses).  Note, this routine is different than makeLeanCopy
      // since it makes the existing expression lean, as opposed to storing
      // the expression in an "expr_lean" expression.  The advantages are that
      // all expressions are supported (which is exactly what we need).  The
      // disadvantages are that the expression isn't as lean as it could be.
      newExpr->makeLeanCopyAll(generator->getSpace());

      // Initially assume that there are no clauses needed to copy over
      newExpr->setClauses(NULL);

      // Walk through clauses list if expression contains EVAL instruction.
      // Otherwise we're pretty much done since PCODE was already copied over.
      if((*expr)->getPCodeSegment()->containsClauseEval() || saveClauses) {
        for (ex_clause* clause = (*expr)->getClauses();
            clause;
            clause = clause->getNextClause())
        {
          short clauseSize;

          // If this has pCode, then we don't need to copy the clause.  Change
          // retCode, however, to reflect the fact that we got rid of a clause.
          // If we're generating a showplan, all clauses are to be emitted.
          if (!clause->noPCodeAvailable() && !saveClauses)
          {
            retCode = 1;
            continue;
          }

          // TBD:
          // Special case given to ExFunctionRandomSelection since this class
          // does not define the method getClassSize().  Adding it would require
          // a DP2 rebuild.  Maybe later - but soon!

          clauseSize =
            (clause->getClassID() == ex_clause::FUNC_RAND_SELECTION_ID)
              ? sizeof(ExFunctionRandomSelection)
              : clause->getClassSize();

          // Record size of space before allocation of clause and other stuff.
          Lng32 beforeSize = getSpace()->getAllocatedSpaceSize();

          // Allocate space for new clause
          ex_clause* newClause = (ex_clause*) new(getSpace()) char[clauseSize];

          // Copy Clause
          str_cpy_all((char*)newClause, (char*)clause, clauseSize);

          // Null-terminate next clause pointer
          newClause->setNextClause(NULL);

          newClause->copyOperands(clause, getSpace());
          newExpr->getPCodeSegment()->replaceClauseEvalPtr(clause, newClause);

          if (newExpr->getClauses() == NULL) {
            newExpr->setClauses(newClause);
          }
          else {
            prevClause->setNextClause(newClause);
          }

          // If a branch clause was previously seen, then we need to fix up it's
          // branch_clause and saved_next pointers (since they were initialized
          // to 0 in the newly copied clause.  The clause currently being
          // processed needs to be examined to see if it's one of these two
          // pointers for the branch clause.  The algorithm used below can be
          // improved if we allocate a list of pointers to branch clauses, but
          // I think simplicity outweights performance in this case.

          if (branchFound)
          {
            for (ex_clause* tempClause = newExpr->getClauses(); tempClause;
                 tempClause = tempClause->getNextClause())
            {
              if (tempClause->getType() == ex_clause::BRANCH_TYPE) {
                ex_branch_clause* branchClause = (ex_branch_clause*)tempClause;
  
                if (branchClause->get_branch_clause() == clause) {
                  branchClause->set_branch_clause(newClause);
                  break;
                }
                else if (branchClause->get_saved_next() == clause) {
                  branchClause->set_saved_next(newClause);
                  break;
                }
              }
            }
          }

          // If we're keeping a branch clause, we have to keep that clauses
          // associated clauses as well (i.e. branch_clause and saved_next
          // clauses.  This is because at runtime we do a check to see if the
          // two are equal to each other.  Also, when we pack the branch clause,
          // we also try and pack the associated clauses - which would lead to
          // an error if that didn't exist.  There may be a workaround here.
          // Also set the branchFound flag here.
  
          if (newClause->getType() == ex_clause::BRANCH_TYPE) {
            ex_branch_clause* branchClause = (ex_branch_clause*)newClause;

            // Only set no-pcode-available flag if we're not generating a
            // showplan.  If we are generating a showplan, then the clauses
            // will already get emitted.  This way we don't falsely report that
            // no pcode is available.

            if (!saveClauses) {
              branchClause->get_branch_clause()->setNoPCodeAvailable(TRUE);
              branchClause->get_saved_next()->setNoPCodeAvailable(TRUE);
            }

            branchFound = TRUE;
          }

          // Record size of space after clause and other stuff allocated.
          Lng32 afterSize = getSpace()->getAllocatedSpaceSize();

          // If showplan is being generated, make sure to discount the size of
          // those clauses which would be deleted if this wasn't a showplan.
          if (saveClauses)
            len1 += (afterSize - beforeSize);

          prevClause = newClause;
        }
      }

      // Search for embedded addresses in pcode segment and fixup if needed
      newExpr->getPCodeSegment()->replaceAttributesPtr(newExpr->getClauses(),
                                                       getSpace());

      newExpr->setLength(getSpace()->getAllocatedSpaceSize() - len1);

      // Point expr to new expression stored in fragment space
      *expr = (ex_expr*)newExpr;

    }
    else
    {
      // Allocate space in fragment for entire expression.
      newExpr = (ex_expr_base*)
        new(getSpace()) char[tempSpace->getAllocatedSpaceSize()];

      // Call the "pack" routine for the base expr class (via "packExpr").
      // This is done so that we can rebase it starting at the expression's
      // new location in the fragment space once it's copied over.  Also note,
      // only the base expr needs to be packed since any other expression
      // pointed to in the expression was already packed and rebased in the
      // fragment space.
      (*expr)->packExpr(tempSpace);

      // Make a full copy of expr from tempSpace to fragment space
      tempSpace->makeContiguous((char*)newExpr,
				 tempSpace->getAllocatedSpaceSize());

      // Point expr to new expression stored in fragment space
      *expr = (ex_expr*)newExpr;

      // Call the "unpack" routine for the base expr class for rebasing.
      (*expr)->unpackExpr((void*)(*expr), 0);
    }

    delete tempSpace;
  }

#else

  if (genLeanExpr())
    {
      // restore the original fragment space.
      ComSpace * tempSpace = generator->getTempSpace();
      generator->setTempSpace(NULL, FALSE);

      ex_expr_base * newExpr = NULL;
      if (((*expr)->getPCodeSegment() == NULL) ||
	  ((*expr)->getPCodeSegment()->containsClauseEval()))
	{
	  // make full copy of expr in fragment space
	  newExpr = (ex_expr_base*)
	    new(generator->getSpace()) char[tempSpace->getAllocatedSpaceSize()];
	  (*expr)->pack(tempSpace);
	  tempSpace->makeContiguous((char*)newExpr,
				    tempSpace->getAllocatedSpaceSize());
	  *expr = (ex_expr*)newExpr;
	  (*expr)->unpack((void*)(*expr), 0);

	  generator->setGenLeanExpr(FALSE);
	}
      else
	{
	  len1 = getSpace()->getAllocatedSpaceSize();

	  // make lean copy of expr in fragment space
	  newExpr =
	    new(generator->getSpace()) ex_expr_lean();
	  (*expr)->makeLeanCopy((ex_expr_lean*)newExpr, generator->getSpace());
	  *expr = (ex_expr*)newExpr;

	  totalExprLen =
	    getSpace()->getAllocatedSpaceSize() - len1;
	  pcodeExprLen = ((ex_expr_lean*)newExpr)->getPCodeSize();

	  ((ex_expr_lean*)newExpr)->setLength(totalExprLen);
	}

      delete tempSpace;
    }

#endif /* NEW_LEAN_EXPR */

  // clear cache of generated subexpressions
  cache_->clear();

  restorePCodeMode();

  return retCode;
}

void ExpGenerator::initClauseList()
{
  clause_list = new(wHeap()) AListNode(wHeap());
};


void ExpGenerator::linkClause(ItemExpr * node, ex_clause * clause)
{
  if (node)
    {
      setClauseLinked(TRUE);

      node->setClause(clause);
    }

  clause_list->linkElement(clause);

  // Do some specialized processing.

  // If this is a function clause, set the origFunctionOperType.
  // This is used to return correct error info at runtime.
  if ((clause->getType() == ex_clause::FUNCTION_TYPE) &&	node &&
      (((ex_function_clause *)clause)->getOperType() != node->origOpType()))
    {
      ((ex_function_clause *)clause)->setDerivedFunction(TRUE);
      ((ex_function_clause *)clause)->setOrigFunctionOperType(
                                                        node->origOpType());
    }
};

void ExpGenerator::fixupNextClause()
{
  AListNode0 *curr_node = clause_list->getHead();

  unsigned short currClauseNum = 0;
  while (curr_node->getNext())
    {
      ((ex_clause *)(curr_node->getElement()))->setNextClause((ex_clause *)(curr_node->getNext()->getElement()));
      if (((ex_clause *)(curr_node->getElement()))->getType() == ex_clause::BRANCH_TYPE)
	{
	  ((ex_clause *)(curr_node->getElement()))->setNextClause((ex_clause *)(curr_node->getNext()->getElement()));
	  ((ex_branch_clause *)curr_node->getElement())->set_saved_next((ex_clause *)(curr_node->getNext()->getElement()));
	}

      if (!curr_node->getNext())
	{
	  // this is the last clause. Mark it so.
	  ((ex_clause *)(curr_node->getElement()))->setLastClause();
	}

      ((ex_clause *)(curr_node->getElement()))->clauseNum() = ++currClauseNum;
      curr_node = curr_node->getNext();
    };
}

void ExpGenerator::initConstantList()
{
  constant_list = new(wHeap()) AListNode(wHeap());
  constants_length = 0;
  temps_length = 0;
};

void ExpGenerator::initPersistentList()
{
  persistentList_ = new(wHeap()) AListNode(wHeap());
  persistentLength_ = 0;
};

AListNode * ExpGenerator::getConstantList()
{
  return constant_list;
};

AListNode * ExpGenerator::getPersistentList()
{
  return persistentList_;
};

void ExpGenerator::linkConstant(void * expr_tree)
{
  constant_list->linkElement(expr_tree);
};

void ExpGenerator::linkPersistent(void *expTree)
{
  persistentList_->linkElement(expTree);
};

char * ExpGenerator::placeConstants(AListNode *list, Int32 length)
{
  // If there are no constants/persistents, bug out...
  //
  if(length == 0) return 0;

  // Allocate space for storing the image of the constants
  //
  char *area = getSpace()->allocateAlignedSpace(length);

  // All uninitialized constant/peristent variables must be zero.
  //
  // All memory from Space is zeroed out by default.
  // memset(area, 0, length);

  // Loop over each constant in the list and construct it in the image area.
  // The data format for the constants area is assumed to be in
  // SQLARK_EXPLODED_FORMAT.
  // See also method ConstValue::getOffsetsinBuffer()
  ConstValue * item;
  AListNode0 *current = list->getHead();
  while (current->getNext())
    {
      item = (ConstValue *)
	(((ExprNode *)(current->getElement()))->castToItemExpr());

      Attributes * attr
	= generator->getMapInfo(item->getValueId())->getAttr();

      if ((attr->getNullFlag()) && (item->isNull())) // null constant
	{
          ExpTupleDesc::setNullValue( area + attr->getNullIndOffset(),
                                      attr->getNullBitIndex(),
                                      attr->getTupleFormat() );
	}
      else
	{
	  if (attr->getNullFlag())
	    {
              ExpTupleDesc::clearNullValue( area + attr->getNullIndOffset(),
                                            attr->getNullBitIndex(),
                                            attr->getTupleFormat() );
	    }

	  if (attr->getVCIndicatorLength() > 0)
	    {
	      str_cpy_all
		(&area[attr->getVCLenIndOffset()],
		 (char *)item->getConstValue()
		 + item->getValueId().getType().getSQLnullHdrSize(),
		 attr->getVCIndicatorLength());
	    }

	  str_cpy_all
	    (&area[attr->getOffset()],
	     (char *)item->getConstValue()
	     + item->getValueId().getType().getSQLnullHdrSize()
	     + attr->getVCIndicatorLength(),
	     attr->getLength());
	}
      current = current->getNext();
    }

  return area;
}

NABoolean GenEvalPredicate(ItemExpr * rootPtr)
{
  // set up binder/generator stuff so expressions could be generated.
  InitSchemaDB();
  CmpStatement cmpStatement(CmpCommon::context());
  ActiveSchemaDB()->createStmtTables();
  BindWA       bindWA(ActiveSchemaDB(), CmpCommon::context());
  Generator    generator(CmpCommon::context());
  ExpGenerator expGen(&generator);
  generator.appendAtEnd();

  generator.setBindWA(&bindWA);
  generator.setExpGenerator(&expGen);
  FragmentDir * compFragDir = generator.getFragmentDir();

  // create the fragment (independent code space) for this expression
  CollIndex myFragmentId = compFragDir->pushFragment(FragmentDir::MASTER);

  // space where RCB will be generated
  Space * space = generator.getSpace();

  // allocate a work cri desc to encode keys. It has
  // 2 entries: 0, for consts. 1, for temps.
  ex_cri_desc * workCriDesc = new(space) ex_cri_desc(2, space);

  ex_expr * expr = 0;

  ItemExpr * boolResult = new(generator.wHeap()) BoolResult(rootPtr);

  boolResult->bindNode(generator.getBindWA());

  expGen.generateExpr(boolResult->getValueId(),
		      ex_expr::exp_SCAN_PRED,
		      &expr);

  // create a DP2 expression and initialize it with the key encode expr.
  ExpDP2Expr * dp2Expr = new(space) ExpDP2Expr(expr,
					       workCriDesc,
					       space);

  dp2Expr->setPCodeMode( expGen.getPCodeMode() );

  dp2Expr->getExpr()->fixup(0,0,0,NULL,NULL,FALSE,NULL);

  atp_struct * workAtp = dp2Expr->getWorkAtp();

  generator.removeAll();

  if (dp2Expr->getExpr()->eval(workAtp, 0) == ex_expr::EXPR_TRUE)
    return TRUE;
  else
    return FALSE;
}

short ExpGenerator::generateSamplingExpr(const ValueId &valId, ex_expr **expr,
					 Int32 &returnFactorOffset)
{
  // Prime the expression generator.
  //
  initExprGen();
  startExprGen(expr, ex_expr::exp_SCAN_PRED);

  // PreCodeGen the expression.
  //
  ItemExpr *temp = valId.getValueDesc()->getItemExpr()->preCodeGen(generator);
  if (!temp) return -1;

  // Set the result of the sampling expression to be a persistent variable.
  // This must be done after preCodeGen because the original item expression
  // is changed. Also, reset the codeGenerated flag for the item so
  // that the actual code will be generated. This is not the usual way
  // to use a persistent variable.
  //
  MapInfo *mapInfo=addPersistent(temp->getValueId(), generator->getMapTable());
  mapInfo->resetCodeGenerated();

  // If there were no errors, codeGen the expression.
  //
  temp->codeGen(generator);

  // Finialize the expression generator.
  //
  endExprGen(expr, 0);

  // Assert that the result of the sampling expression is stored in
  // persisent space. And, compute the offset for the result.
  //
  mapInfo = generator->getMapInfoAsIs(temp->getValueId());
  GenAssert(mapInfo, "Sampling result not in map table!");

  Attributes *attr = mapInfo->getAttr();
  GenAssert(attr->getAtpIndex() == 1,
	    "Sampling result must be a persistent expression variable.");

  returnFactorOffset = attr->getOffset();

  return 0;
}

MapInfo *ExpGenerator::addTemporary(ValueId val, MapTable *mapTable)
{
  // Add the value ID to the last map table.
  //
  MapInfo *mapInfo =
    generator->addMapInfoToThis(generator->getLastMapTable(), val, NULL);

  // Set the attributes to indicate a temporary ... ATP 0, Index 1
  //
  Attributes * mapAttr = mapInfo->getAttr();
  mapAttr->setAtp(0);
  mapAttr->setAtpIndex(1);

  // Compute length of this temporary and assign offsets to the attributes.
  // All temps are in sqlark_exploded format.
  //
  ULng32 len;
  ExpTupleDesc::TupleDataFormat tdataF = ExpTupleDesc::SQLARK_EXPLODED_FORMAT;
  ExpTupleDesc::computeOffsets(mapAttr,
			       tdataF,
			       len,
			       getTempsLength());
  addTempsLength(len);
  return mapInfo;
}

MapInfo *ExpGenerator::addPersistent(ValueId val, MapTable *mapTable)
{
  // Add the value ID to the map table.
  //
  MapInfo *mapInfo = generator->addMapInfoToThis(mapTable, val, NULL);

  // Set the attributes to indicate a persistent: Atp 1 and AtpIndex 1.
  //
  Attributes * mapAttr = mapInfo->getAttr();
  mapAttr->setAtp(1);
  mapAttr->setAtpIndex(1);

  // Compute length of this persistent and assign offsets to the attributes.
  // All persistents are in sqlark_exploded format.
  //
  ULng32 len;
  ExpTupleDesc::TupleDataFormat tdataF = ExpTupleDesc::SQLARK_EXPLODED_FORMAT;
  ExpTupleDesc::computeOffsets(mapAttr,
			       tdataF,
			       len,
			       persistentLength());
  persistentLength() = persistentLength() + len;

  // Mark the item as codeGenned.
  //
  mapInfo->codeGenerated();

  return mapInfo;
}

short ExpGenerator::genItemExpr(ItemExpr * item_expr, Attributes *** out_attr,
				Lng32 num_attrs, short gen_child)
/////////////////////////////////////////////////////////////////////////////
// Description of parameters:
// item_expr (IN) : the tree for which code is to be generated
// out_attr  (OUT): the generated attributes array is returned here. This
//                  is a pointer to an array of pointers, hence 3 *** s.
// num_attrs (IN) : number of attributes in the attribute array.
// gen_child (IN) : if -1, generate code for children.
//
// RETURN VALUE: 0, all ok. 1, code already been generated. -1, error.
/////////////////////////////////////////////////////////////////////////////
{
  MapInfo * map_info = generator->getMapInfoAsIs(item_expr->getValueId());
  if ((map_info) &&
      (map_info->isCodeGenerated()))
    return 1;

  if (!map_info)
    {
      // attempt to perform common subexpression elimination on this
      // expression
      if (cache_->expressionCanBeEliminated(item_expr))
        {
        // an equivalent expression has already been generated, and
        // this one has been replaced by it
        return 1;   // tell caller expression already generated
        }

      // no equivalent expression has been generated... continue...

      // this value has not been added to the map table. Add it
      // to the last map table as a temp. Temps are allocated
      // at atp_index = 1.
      map_info = addTemporary(item_expr->getValueId(), NULL);
    }

  Lng32 numAttrs = num_attrs;
  if (getShowplan())
    numAttrs *= 2;

  Attributes ** attr = new(wHeap()) Attributes * [numAttrs];
  for (Int32 i = 0; i < numAttrs; i++)
    {
      attr[i] = NULL;
    }

  /* assign result attributes*/
  attr[0] = map_info->getAttr();

  if (gen_child)
  {
    item_expr->codegen_and_set_attributes( generator, attr, num_attrs );
  }

  if (getShowplan())
    {
      attr[0+num_attrs] =
	new(wHeap()) ShowplanAttributes(item_expr->getValueId(),
					convertNAString(item_expr->getText(),
							generator->wHeap()));

      attr[0]->setShowplan();

      for (short i = 0; i < num_attrs - 1; i++)
	{
	  attr[i+1+num_attrs] =
	    new(wHeap())
	    ShowplanAttributes(item_expr->child(i)->getValueId(),
			       convertNAString(item_expr->child(i)->getText(),
					       generator->wHeap()));
	}
    }

  map_info->codeGenerated();

  *out_attr = attr;

  // add expression to generated cache (so if we later encounter an
  // equivalent expression, we can just use this one's generated code)
  cache_->add(item_expr);

  return 0;
}

/////////////////////////////////////////////////////////////////////////////
// methods for class ExpGeneratorCache
/////////////////////////////////////////////////////////////////////////////
ExpGeneratorCache::ExpGeneratorCache(Generator * generator)
: generator_(generator), cachedCasts_(generator->wHeap()),
  cachedBiAriths_(generator->wHeap()),
  substitutions_(generator->wHeap()),
  level_(0)
  {
  enableCommonSubexpressionElimination_ = TRUE;
  // getenv() calls are costly. avoid especially in release code.
#ifdef _DEBUG
  if (getenv("NO_COMMON_SUBEX_ELIM"))
    enableCommonSubexpressionElimination_ = FALSE;
#endif
  }

ExpGeneratorCache::~ExpGeneratorCache(void)
  {
  clear();  // to cause clean-up (e.g. avoid memory leak in substitutions_)
  }

// add an expression (which has had code generated) to the cache
void ExpGeneratorCache::add(ItemExpr * ie)
  {
  if (enableCommonSubexpressionElimination_)
    {
    if (level_ == 0) // don't cache anything that can be short-circuited
      {
      switch (ie->getOperatorType())
        {
        case ITM_CAST:
          {
          Cast * cie = (Cast *)ie;
          cachedCasts_.insert(cie);
          break;
          }
        case ITM_PLUS:
        case ITM_MINUS:
        case ITM_TIMES:
        case ITM_DIVIDE:
          {
          BiArith * bie = (BiArith *)ie;
          cachedBiAriths_.insert(bie);
          break;
          }
        default:
          break;
        }
      }
    }
  }


// find an expression which has already been generated equivalent
// to the input parameter; if none exists, returns NULL
ItemExpr * ExpGeneratorCache::findEquivalentGeneratedExpr(ItemExpr * ie)
  {
  ItemExpr * rc = 0;        // assume none exists

  if ((ie) &&
      (enableCommonSubexpressionElimination_))
    {
    switch (ie->getOperatorType())
      {
      case ITM_CAST:
        {
        for (CollIndex i = 0; (i < cachedCasts_.entries()) && (rc == 0); i++)
          {
          Cast * c = cachedCasts_[i];
          if (c->isEquivalentForCodeGeneration(ie))
            rc = c;
          }
        break;
        }
      case ITM_PLUS:
      case ITM_MINUS:
      case ITM_TIMES:
      case ITM_DIVIDE:
        {
        for (CollIndex i = 0; (i < cachedBiAriths_.entries()) && (rc == 0); i++)
          {
          BiArith * b = cachedBiAriths_[i];
          if (b->isEquivalentForCodeGeneration(ie))
            rc = b;
          }
        break;
        }
      default:
        break;
      }
    }

  return rc;
  }

NABoolean ExpGeneratorCache::expressionCanBeEliminated(ItemExpr * ie)
  {
  NABoolean rc = FALSE;  // assume expression cannot be eliminated

  // look to see if code to compute an equivalent expression has
  // already been generated
  ItemExpr * equiv_expr = findEquivalentGeneratedExpr(ie);
  if (equiv_expr)
    {
    // an equivalent expression has already been generated; replace
    // this one with that (common subexpression elimination)

      ValueId  temp1 = equiv_expr->getValueId();
      ValueId &temp2 = temp1;

      substitutions_.insert(new (generator_->wHeap())
        ExpGeneratorCacheSubstitution(ie,temp2));

      rc = TRUE;   // expression can be (and has been!) eliminated
    }
    return rc;
  }

void ExpGeneratorCache::incrementLevel(void)
  {
  level_++;
  }

void ExpGeneratorCache::decrementLevel(void)
  {
  GenAssert(level_ > 0,"Bad level in generated expression cache");
  level_--;
  }

// clear cache
void ExpGeneratorCache::clear(void)
  {
  cachedCasts_.clear();
  cachedBiAriths_.clear();

  // undo all substitutions and delete the substitution objects
  ExpGeneratorCacheSubstitution * subs = 0;
  while (substitutions_.getFirst(subs /* out */))
    {
    subs->undo();
    delete subs;
    }
  GenAssert(substitutions_.isEmpty(),"Bad undeleted substitutions");

  level_ = 0;
  }

Lng32 ExpGenerator::foldConstants(ItemExpr * inExpr, ItemExpr ** outExpr)
{
  Lng32 rc = 0;

  if (outExpr)
    *outExpr = inExpr;

  if (inExpr == NULL)
    return 0;

  if (CmpCommon::getDefault(CONSTANT_FOLDING) == DF_OFF)
    return 0;

  ValueId dummy;
  Lng32 daMark = CmpCommon::diags()->mark();
  rc = ValueIdList::evaluateExpr(dummy,
				 inExpr->getValueId(),
				 -1,
				 FALSE, // don't simplify expr
				 TRUE,  // do eval all consts
				 outExpr,
				 CmpCommon::diags());
  if ((rc < 0) ||
      (CmpCommon::diags()->getNumber() > 0))
    {
      if (outExpr)
         *outExpr = NULL;
      CmpCommon::diags()->rewind(daMark, TRUE);
      return -1;
    }

  return 0;
}

/////////////////////////////////////////////////////////////////////////////
// methods for class ExpGeneratorCacheSubstitution
/////////////////////////////////////////////////////////////////////////////
ExpGeneratorCacheSubstitution::ExpGeneratorCacheSubstitution(ItemExpr * ie,
                                                             ValueId &newValueId)
: ie_(ie), oldValueId_(ie->getValueId()), newValueId_(newValueId)
  {
  // now replace the old valueId in the ItemExpr with the new
  // (the act of creating a substitution causes substitution to be performed!)
  ie->setValueId(newValueId);
  }

// undo a substitution
void ExpGeneratorCacheSubstitution::undo(void)
  {
  // the 'if' below makes this method idempotent
  if (ie_->getValueId() == newValueId_)
    ie_->setValueId(oldValueId_);
  }

// generate a null constant and type it to input type
ConstValue * ExpGenerator::generateNullConst(const NAType &type)
{
  ConstValue * nullConst = new(wHeap()) ConstValue();
  nullConst->bindNode(generator->getBindWA());
  NAType * newType = type.newCopy(wHeap());
  newType->setNullable(TRUE);
  (nullConst->getValueId()).changeType(newType);
  return nullConst;
}