/**********************************************************************
// @@@ 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:         GenRelMisc.C
* RCS:          $Id: GenRelMisc.cpp,v 1.1 2007/10/09 19:38:54  Exp $
* Description:  MapValueId/Root/Tuple operators
*
* Created:      5/17/94
* Modified:     $ $Date: 2007/10/09 19:38:54 $ (GMT)
* Language:     C++
* Status:       $State: Exp $
*
*
*
******************************************************************************
*/
#define   SQLPARSERGLOBALS_FLAGS
#include "ComOptIncludes.h"
#include "GroupAttr.h"
#include "ItemColRef.h"
#include "RelEnforcer.h"
#include "RelJoin.h"
#include "RelExeUtil.h"
#include "RelMisc.h"
#include "RelSet.h"
#include "RelUpdate.h"
#include "RelScan.h"
#include "RelDCL.h"
#include "PartFunc.h"
#include "Cost.h"
#include "GenExpGenerator.h"
#include "GenResources.h"
#include "ComTdbRoot.h"
#include "ComTdbTuple.h"
#include "ComTdbUnion.h"
#include "ComTdbTupleFlow.h"
#include "ComTdbTranspose.h"
#include "ComTdbSort.h"
#include "ComTdbPackRows.h"
#include "ComTdbDDL.h"
#include "ComTdbExeUtil.h"
#include "ComTdbFirstN.h"
#include "ComTdbStats.h"
#include "ComTdbCancel.h"
#include "ExplainTuple.h"
#include "ComTdbHbaseAccess.h"
#include "ComTdbExplain.h"
#include "SchemaDB.h"
#include "ControlDB.h"
#include "NATable.h"
#include "BindWA.h"
#include "ComTransInfo.h"
#include "DefaultConstants.h"
#include "FragDir.h"
#include "PartInputDataDesc.h"
#include "ExpSqlTupp.h"
#include "sql_buffer.h"
#include "ComQueue.h"
#include "ComSqlId.h"
#include "MVInfo.h"
#include "SequenceGeneratorAttributes.h"
#include "CompilationStats.h"
#include "RelRoutine.h"
#include "hs_cont.h"
#include "ComUnits.h"

#include "StmtDDLCleanupObjects.h"

#ifndef HFS2DM
#define HFS2DM
#endif // HFS2DM

#include "ComDefs.h"            // to get common defines (ROUND8)
#include "CmpStatement.h"
#include "ComSmallDefs.h"
#include "sql_buffer_size.h"
#include "ExSqlComp.h"		// for NAExecTrans

#include "ComLocationNames.h"
#include "ComDistribution.h"
#include "OptimizerSimulator.h"

#include "ComCextdecs.h"

#include "TrafDDLdesc.h"

#include "SqlParserGlobals.h"   // Parser Flags

// this comes from GenExplain.cpp (sorry, should have a header file)
TrafDesc * createVirtExplainTableDesc();
void deleteVirtExplainTableDesc(TrafDesc *);

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

 
/////////////////////////////////////////////////////////
//
// MapValueIds::codeGen()
//
/////////////////////////////////////////////////////////
short MapValueIds::codeGen(Generator * generator)
{

  // The MapValueIds node does not result in any executor nodes.  It
  // does not generate a TDB.  It simply 'maps' its lower values to
  // its upper values.  It does this by doing the following for each
  // upper and lower pairing.
  //
  //   - creates a new expressions which converts the lower value to
  //     the type of the upper value.
  //
  //   - Associates this new expression with the ValueId of the upper
  //     value, by replacing the ItemExpr of the upper valueId with
  //     this new expression.
  //
  // The end result is that in nodes above this MapValueIds node,
  // references to the ValueIds of the upper list, will get the new
  // expression (the Cast of the lower value).
  //
  // This code was initially placed in the MapValueIds::preCodeGen(),
  // but this caused some problems with Query trees involving
  // triggers.  The issue was that with triggers it is possible for a
  // ValueId to be sourced (produced) in two different subtrees of the
  // query tree.  One being a MapValueId.  So when the expressions of
  // the upper valueIds were replaced, it not only affected references
  // to the ValueIds above the MapValueIds, it affected the references
  // to the ValueIds in other subtrees.


  // generate code for the child
  child(0)->codeGen(generator);

  const ValueIdList & topValues = map_.getTopValues();

  for (CollIndex i = 0; i < topValues.entries(); i++)
    {
      ValueId valId = topValues[i];

      // if this value id is mapped to a different one (mappedId ) by
      // this node, then convert the "mappedId" to the type of this
      // 'valid'
      //
      ValueId mappedId;
      map_.mapValueIdDown(valId,mappedId);

      if (mappedId != valId)
	{

	  // Convert the source (lower) value to the type of the
          // target (upper) value.
          //
	  ItemExpr * convValue
	    = new(generator->wHeap()) Cast (mappedId.getItemExpr(),
			&(valId.getType()));

	  // bind/type propagate the new node
	  convValue->bindNode(generator->getBindWA());

          // Replace upper value with converted value.
          //
          valId.replaceItemExpr(convValue);

	}
    }

  // No TDB was generated.  Parent will retrieve childs TDB
  //
  return 0;
}

/////////////////////////////////////////////////////////
//
// Some helper classes and functions for PartitionAccess::codeGen
//
/////////////////////////////////////////////////////////

class NodeCountHelper {
friend class NodeHashHelper;
public:
  UInt32 getCount(void) { return nodeDiskCount_;}
  void incCount(void) { nodeDiskCount_++; }
  inline NABoolean operator==(const NodeCountHelper& other) const
  {
    return (nodeDiskCount_ == other.nodeDiskCount_);
  }

private:
  UInt32 nodeDiskCount_;
};

class NodeNameHelper {
friend class NodeHashHelper;
friend ULng32 nodeNameHashFunc( const NodeNameHelper& n );

public:
  const char * const getNodeName(void) { return nodeName_; }
  ULng32 hash() const { return nodeNameHashFunc(*this); }
  inline NABoolean operator==(const NodeNameHelper& other) const
  {
    if (stricmp(nodeName_, other.nodeName_) != 0)
	return FALSE;
    else
        return TRUE;
  }
private:
  char nodeName_[ComGUARDIAN_SYSTEM_NAME_PART_CHAR_MAX_LEN + 1];
};

ULng32 nodeNameHashFunc( const NodeNameHelper& n )
{
  ULng32 retval = 0;
  const char * const c = n.nodeName_;
  Int32 i = 0;
  do {
    retval += c[i++];
  } while (c[i]);
  return retval;
}


class NodeDiskNameHelper {
friend class NodeHashHelper;
friend ULng32 nodeDiskNameHashFunc( const NodeDiskNameHelper& n );

public:
  inline NABoolean operator==(const NodeDiskNameHelper& other) const
  {
    if (stricmp(nodeDiskName_, other.nodeDiskName_) != 0)
	return FALSE;
    else
        return TRUE;
  }

  ULng32 hash() const { return nodeDiskNameHashFunc(*this); }

private:
  char nodeDiskName_[
     ComGUARDIAN_SYSTEM_NAME_PART_CHAR_MAX_LEN + 1    // + 1 for the dot.
   + ComGUARDIAN_VOLUME_NAME_PART_CHAR_MAX_LEN + 1    // + 1 for the \0.
                    ];
};

ULng32 nodeDiskNameHashFunc( const NodeDiskNameHelper& n )
{
  ULng32 retval = 0;
  const char * const c = n.nodeDiskName_;
  Int32 i = 0;
  do {
    retval += c[i++];
  } while (c[i]);
  return retval;
}

class NodeHashHelper {

public:
  NodeHashHelper  ( const char * partn )
    {
      memmove(nodeName_.nodeName_, partn, sizeof nodeName_.nodeName_);
          // Convert 1st dot into a null termininator.
      char * dotPos = strchr(nodeName_.nodeName_, '.');
      *dotPos = '\0';
      memmove(nodeDiskName_.nodeDiskName_, partn,
                                 sizeof nodeDiskName_.nodeDiskName_);
          // Convert 2nd dot into a null termininator.
      dotPos = strchr(nodeDiskName_.nodeDiskName_, '.');
      dotPos = strchr(dotPos+1, '.');
      *dotPos = '\0';
      nodeDiskCount_.nodeDiskCount_ = 1;
    }
  NodeNameHelper * getNodeName(void) { return &nodeName_; }
  NodeDiskNameHelper * getNodeDiskName(void) { return &nodeDiskName_; }
  NodeCountHelper * getNodeDiskCount(void) { return &nodeDiskCount_ ; }
private:
  NodeHashHelper();
  NodeCountHelper nodeDiskCount_ ;
  NodeNameHelper nodeName_;
  NodeDiskNameHelper nodeDiskName_;
};

static void replaceBaseValue(ItemExpr *incomingExpr, 
			     ItemExpr *resultExpr, 
			     CollHeap *heap,
			     NABoolean setFound) 
{
  static THREAD_P NABoolean found = FALSE;

  found = setFound;
  Int32 nc = incomingExpr->getArity();

  // ITM_ASSIGN operator will not be a leaf node.
  if ((nc != 0) && (found == FALSE)) //have not found yet.
     {
       ItemExpr *child1 = incomingExpr->child(1);
       ItemExpr *newExpr = NULL;
       if (incomingExpr->getOperatorType() == ITM_ASSIGN &&
	   (child1 != NULL && child1->getOperatorType() == ITM_ASSIGN)
	   )
	 {
	   newExpr = new(heap) BiArith(ITM_PLUS,
				       resultExpr,
				       child1);

	   newExpr->synthTypeAndValueId(TRUE);
	   //set type to original type after if has been changed to BigNum above
	   newExpr->getValueId().changeType(new (heap) SQLLargeInt(heap, 1 /* signed */,
								    0 /* not null */));
	   incomingExpr->setChild(1,newExpr);
	   found = TRUE;
	   return;
	 }

       for (Lng32 i = 0; i < (Lng32)nc; i++)
	{
	  if (found == FALSE)
	    replaceBaseValue(incomingExpr->child(i), resultExpr, heap, found);
	}
    } 
  return; 
}

short GenericUtilExpr::codeGen(Generator * generator)
{
  GenAssert(0, "GenericUtilExpr::codeGen. Should not reach here.");

  return 0;
}

/////////////////////////////////////////////////////////
//
// DDLExpr::codeGen()
//
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
//
// ExeUtilExpr::codeGen()
//
/////////////////////////////////////////////////////////
const char * DDLExpr::getVirtualTableName()
{ return (producesOutput() ? "DDL_EXPR__" : NULL); }

TrafDesc *DDLExpr::createVirtualTableDesc()
{
  TrafDesc * table_desc = NULL;
  if (producesOutput())
    {
      table_desc = 
        Generator::createVirtualTableDesc(getVirtualTableName(),
                                          NULL, // let it decide what heap to use
                                          ComTdbDDL::getVirtTableNumCols(),
                                          ComTdbDDL::getVirtTableColumnInfo(),
                                          ComTdbDDL::getVirtTableNumKeys(),
                                          ComTdbDDL::getVirtTableKeyInfo());
    }
  return table_desc;
}

short DDLExpr::codeGen(Generator * generator)
{
  Space * space = generator->getSpace();

  generator->verifyUpdatableTransMode(NULL, generator->getTransMode(), NULL);

  // remove trailing blanks and append a semicolon, if one is not present.
  char * ddlStmt = NULL;

  Int32 i = strlen(getDDLStmtText());
  while ((i > 0) && (getDDLStmtText()[i-1] == ' '))
    i--;

  if (getDDLStmtText()[i-1] == ';')
    i--;
 
  ddlStmt = space->allocateAlignedSpace(i+2);
  strncpy(ddlStmt, getDDLStmtText(), i);
  
  // add a semicolon to the end of str (required by the parser)
  ddlStmt[i++]   = ';';
 
  ddlStmt[i] = '\0';

  ex_cri_desc * givenDesc
    = generator->getCriDesc(Generator::DOWN);
  ex_cri_desc * returnedDesc = givenDesc;
  ex_cri_desc * workCriDesc = NULL;
  const Int32 work_atp = 1;
  const Int32 ddl_row_atp_index = 2;
  if (producesOutput())
    {
      // allocate a map table for the retrieved columns
      generator->appendAtEnd();

      returnedDesc = new(space) ex_cri_desc(givenDesc->noTuples() + 1, space);
      workCriDesc = new(space) ex_cri_desc(4, space);
      short rc = processOutputRow(generator, work_atp, ddl_row_atp_index,
                                  returnedDesc);
      if (rc)
        {
          return -1;
        }
    }

  NAString catSchName = 
    generator->currentCmpContext()->schemaDB_->getDefaultSchema().getSchemaNameAsAnsiString();
  
  CMPASSERT(!catSchName.isNull());		     // not empty
  CMPASSERT(catSchName.first('.') != NA_NPOS);	     // quick test: 'cat.sch'
  
  char * catSchNameStr = space->allocateAlignedSpace(catSchName.length() + 1);
  strcpy(catSchNameStr, catSchName.data());

  ComTdbDDL * ddl_tdb = NULL;

  if (returnStatus_)
    {
      ComTdbDDLwithStatus *ddl_ws_tdb = new(space)
        ComTdbDDLwithStatus(ddlStmt,
                            strlen(ddlStmt),
                            (Int16)getDDLStmtTextCharSet(),
                            catSchNameStr, strlen(catSchNameStr),
                            0, 0, // no input expr
                            0, 0, // no output expr
                            workCriDesc, (producesOutput() ? ddl_row_atp_index : 0),
                            givenDesc,
                            returnedDesc,
                            (queue_index)getDefault(GEN_DDL_SIZE_DOWN),
                            (queue_index)getDefault(GEN_DDL_SIZE_UP),
                            getDefault(GEN_DDL_NUM_BUFFERS),
                            getDefault(GEN_DDL_BUFFER_SIZE));
      
      ddl_ws_tdb->setReturnStatus(TRUE);

      if (isCleanup_)
        {
          ddl_ws_tdb->setMDcleanup(TRUE);

          StmtDDLCleanupObjects * co = 
            getExprNode()->castToElemDDLNode()->castToStmtDDLCleanupObjects();

          if (co->checkOnly())
            ddl_ws_tdb->setCheckOnly(TRUE);

          if (co->returnDetails())
            ddl_ws_tdb->setReturnDetails(TRUE);

        }
      else if (initHbase())
        ddl_ws_tdb->setInitTraf(TRUE);

      ddl_tdb = ddl_ws_tdb;
    }
  else
    ddl_tdb = new(space)
      ComTdbDDL(ddlStmt,
                strlen(ddlStmt),
                (Int16)getDDLStmtTextCharSet(),
                catSchNameStr, strlen(catSchNameStr),
                0, 0, // no input expr
                0, 0, // no output expr
                workCriDesc, (producesOutput() ? ddl_row_atp_index : 0),
                givenDesc,
                returnedDesc,
                (queue_index)getDefault(GEN_DDL_SIZE_DOWN),
                (queue_index)getDefault(GEN_DDL_SIZE_UP),
                getDefault(GEN_DDL_NUM_BUFFERS),
                getDefault(GEN_DDL_BUFFER_SIZE));
  
  if (isHbase_)
    {
      ddl_tdb->setHbaseDDL(TRUE);
      
      if (hbaseDDLNoUserXn_)
        ddl_tdb->setHbaseDDLNoUserXn(TRUE);
    }
  
  generator->initTdbFields(ddl_tdb);
      
  if(!generator->explainDisabled()) {
    generator->setExplainTuple(
       addExplainInfo(ddl_tdb, 0, 0, generator));
  }

  // no tupps are returned
  generator->setCriDesc((ex_cri_desc *)(generator->getCriDesc(Generator::DOWN)),
			Generator::UP);
  generator->setGenObj(this, ddl_tdb);

  // Set the transaction flag.
  if (xnNeeded())
    {
      if (NOT isHbase_)
	generator->setTransactionFlag(-1);
      else if (getExprNode() && 
               getExprNode()->castToStmtDDLNode()->ddlXns() &&
               (NOT hbaseDDLNoUserXn_))
        {
          // treat like a transactional IUD operation which need to be
          // aborted in case of an error.
          generator->setFoundAnUpdate(TRUE);
	  generator->setUpdAbortOnError(TRUE);
          
          generator->setTransactionFlag(-1);
        }
      else if (NOT hbaseDDLNoUserXn_) 
	generator->setTransactionFlag(-1);
    }

  return 0;
}

/////////////////////////////////////////////////////////
//
// ExeUtilMetadataUpgrade::codeGen()
//
/////////////////////////////////////////////////////////
short ExeUtilMetadataUpgrade::codeGen(Generator * generator)
{
  ExpGenerator * expGen = generator->getExpGenerator();
  Space * space = generator->getSpace();

  // allocate a map table for the retrieved columns
  generator->appendAtEnd();

  ex_cri_desc * givenDesc
    = generator->getCriDesc(Generator::DOWN);

  ex_cri_desc * returnedDesc
    = new(space) ex_cri_desc(givenDesc->noTuples() + 1, space);

  ex_cri_desc * workCriDesc = new(space) ex_cri_desc(4, space);
  const Int32 work_atp = 1;
  const Int32 exe_util_row_atp_index = 2;

  short rc = processOutputRow(generator, work_atp, exe_util_row_atp_index,
                              returnedDesc);
  if (rc)
    {
      return -1;
    }

  ComTdbDDLwithStatus * upgd_tdb = new(space)
    ComTdbDDLwithStatus(NULL, 0, 0,
                        NULL, 0, 
                        0, 0, // no input expr
                        0, 0, // no output expr
                        NULL, 0,
                        givenDesc,
                        returnedDesc,
                        (queue_index)getDefault(GEN_DDL_SIZE_DOWN),
                        (queue_index)getDefault(GEN_DDL_SIZE_UP),
                        getDefault(GEN_DDL_NUM_BUFFERS),
                        getDefault(GEN_DDL_BUFFER_SIZE));

  if (getMDVersion())
    upgd_tdb->setGetMDVersion(TRUE);
  else if (getSWVersion())
    upgd_tdb->setGetSWVersion(TRUE);
  else
    upgd_tdb->setMDupgrade(TRUE);

  generator->initTdbFields(upgd_tdb);
  
  if(!generator->explainDisabled()) {
    generator->setExplainTuple(
       addExplainInfo(upgd_tdb, 0, 0, generator));
  }

  generator->setCriDesc(givenDesc, Generator::DOWN);
  generator->setCriDesc(returnedDesc, Generator::UP);
  
  generator->setGenObj(this, upgd_tdb);

  // Reset the transaction flag.
  generator->setTransactionFlag(0);

  return 0;
}

/////////////////////////////////////////////////////////
//
// FirstN::codeGen()
//
/////////////////////////////////////////////////////////
short FirstN::codeGen(Generator * generator)
{
  ExpGenerator* expGen = generator->getExpGenerator();
  Space * space = generator->getSpace();

  ex_cri_desc * given_desc = generator->getCriDesc(Generator::DOWN);

  // generate code for my child
  child(0)->codeGen(generator);
  ComTdb * child_tdb = (ComTdb *)(generator->getGenObj());
  ExplainTuple *childExplainTuple = generator->getExplainTuple();

  ex_cri_desc * returned_desc = generator->getCriDesc(Generator::UP);

  ex_cri_desc * work_cri_desc = NULL;
  ex_expr * firstNRowsExpr = NULL;
  if (firstNRowsParam_)
    {
      Int32 work_atp = 1; // temps
      Int32 work_atp_index = 2;  // where the result row will be
      work_cri_desc = new(space) ex_cri_desc(3, space);

      // input param is typed as nullable. Make it non-nullable and unsigned.
      NAType * newNAT = 
        firstNRowsParam_->getValueId().getType().newCopy(generator->wHeap());
      newNAT->setNullable(FALSE, FALSE);
      
      Cast * fnp = new(generator->wHeap()) Cast(firstNRowsParam_, newNAT);
      fnp->bindNode(generator->getBindWA());
      
      ValueIdList vidL;
      vidL.insert(fnp->getValueId());

      UInt32 firstNValLen = 0;
      expGen->generateContiguousMoveExpr(vidL,
                                         0, // no convert nodes,
                                         work_atp, work_atp_index,
                                         ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
                                         firstNValLen, &firstNRowsExpr,
                                         NULL, ExpTupleDesc::SHORT_FORMAT);
    }
  
  ComTdbFirstN * firstN_tdb
    = new(space) ComTdbFirstN(
                              child_tdb,
                              getFirstNRows(),
                              firstNRowsExpr,
                              work_cri_desc,
                              given_desc,
                              returned_desc,
                              child_tdb->getMaxQueueSizeDown(),
                              child_tdb->getMaxQueueSizeUp(),
                              1, 4096);
  
  generator->initTdbFields(firstN_tdb);
  
  if(!generator->explainDisabled()) {
    generator->setExplainTuple(
                               addExplainInfo(firstN_tdb, childExplainTuple, 0, generator));
  }
  
  generator->setGenObj(this, firstN_tdb);
  
  return 0;
}


/////////////////////////////////////////////////////////
//
// RelRoot::genSimilarityInfo()
//
/////////////////////////////////////////////////////////
TrafQuerySimilarityInfo * RelRoot::genSimilarityInfo(Generator *generator)
{
  ExpGenerator * exp_gen = generator->getExpGenerator();

  NABoolean recompOnTSMismatch = FALSE;
  NABoolean errorOnTSMismatch = FALSE;

  // generate the similarity info.
  Space * space = generator->getSpace();

  NABoolean disableAutoRecomp   = (CmpCommon::getDefault(AUTOMATIC_RECOMPILATION) == DF_OFF);

  Queue * siList = new(space) Queue(space);
  TrafQuerySimilarityInfo * qsi = NULL;

  if (generator->getTrafSimTableInfoList().entries() > 0)
    qsi = new(space) TrafQuerySimilarityInfo(siList);

  CollIndex i = 0;

  for (CollIndex i = 0; i < generator->getTrafSimTableInfoList().entries(); i++)
    {
      TrafSimilarityTableInfo * genTsi =
	(TrafSimilarityTableInfo *)(generator->getTrafSimTableInfoList()[i]);
      
      char * genTablename =
        space->allocateAndCopyToAlignedSpace(genTsi->tableName(), str_len(genTsi->tableName()), 0);
      char * genRootDir = 
        space->allocateAndCopyToAlignedSpace(genTsi->hdfsRootDir(), str_len(genTsi->hdfsRootDir()), 0);
 
      char * genHdfsHostName =
        space->allocateAndCopyToAlignedSpace(genTsi->hdfsHostName(), str_len(genTsi->hdfsHostName()), 0);
        
      TrafSimilarityTableInfo * si = 
        new(space) TrafSimilarityTableInfo(genTablename,   
                                           genTsi->isHive(),
                                           genRootDir,
                                           genTsi->modTS(),
                                           genTsi->numPartnLevels(),
                                           NULL,
                                           genHdfsHostName,
                                           genTsi->hdfsPort());
      qsi->siList()->insert(si);
    }

  if (qsi)
    {
      qsi->setDisableAutoRecomp(disableAutoRecomp);
    }

  return qsi;
}

short RelRoot::codeGen(Generator * generator)
{
  ExpGenerator * exp_gen = generator->getExpGenerator();
  Space * space;
  FragmentDir *compFragDir = generator->getFragmentDir();
  NABoolean childTdbIsNull = FALSE;

  // -- MVs
  // Mark in the generator that we are doing an INTERNAL REFRESH command now.
  if (isRootOfInternalRefresh())
    generator->setInternalRefreshStatement();

  MapTable * map_table = generator->appendAtEnd();

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

  // When the master executor gets the generated space, it assumes that
  // the root node is stored at the very beginning of the space, so
  // make sure that the master fragment is fragment 0 (the code
  // below makes sure that the root node is at the beginning of its
  // fragment).
  GenAssert(myFragmentId == 0,"NOT myFragmentId == 0");

  // now we can get a hold of the space object for this fragment
  space = generator->getSpace();

  // usually space for a node is generated after generating code for
  // its children. In case of root, generate the root tdb first.
  // This is done so that the start of the generated code space
  // could point to the root tdb. The tdb, however, is not initialized
  // yet.
  ComTdbRoot *root_tdb = new(space) ComTdbRoot();
  generator->initTdbFields(root_tdb);

  // tell the root tdb whether we collect statistics or not
  if (generator->computeStats())
    {
      root_tdb->setCollectStats(generator->computeStats());
      root_tdb->setCollectStatsType(generator->collectStatsType());
      root_tdb->setCollectRtsStats(generator->collectRtsStats());
    }

   
  //For consistent display of overflow_mode in stats.
  root_tdb->setOverflowMode(generator->getOverflowMode());

    // set the object for the top level fragment
  compFragDir->setTopObj((char *) root_tdb);

  // Copy the current context-wide TransMode,
  // then overlay with this stmt's "FOR xxx ACCESS" setting, if any.
  TransMode * transMode = new(space) TransMode();
  transMode->updateTransMode(generator->getTransMode());
  //
  if (accessOptions().accessType() != TransMode::ACCESS_TYPE_NOT_SPECIFIED_)
    {
      // "FOR xxx ACCESS" becomes an IsolationLevel, and both IL and AccessMode
      // are set in the transMode
      transMode->updateAccessModeFromIsolationLevel(
        TransMode::ATtoIL(accessOptions().accessType()));

      transMode->setStmtLevelAccessOptions();
    }
  else if ( ( generator->currentCmpContext()->internalCompile() == CmpContext::INTERNAL_MODULENAME) ||
            ( CmpCommon::statement()->isSMDRecompile() )
          )
    {
      // As a nicety to everyone writing a trusted .mdf (RFORK, etc),
      // we set this flag so that cli/Statement::execute() will not
      // recompile those trusted stmts due to any TransMode mismatch.
      // (Otherwise, everyone would need to add "FOR xxx ACCESS" to each stmt!)
      //
      transMode->setStmtLevelAccessOptions();
    }

  ex_expr * input_expr = 0;
  ex_expr * output_expr = 0;
  CollIndex i;

  ex_expr * pkey_expr = NULL;
  ULng32 pkey_len = 0;
  
  ex_expr* pred_expr = NULL;

  ULng32 cacheVarsSize = 0;
  //  unsigned long tablenameCacheVarsSize = 0;

  // max number of rows in user rowwise rowset.
  Lng32 rwrsMaxSize = 0;

  // index into the user params to find the value of the number of
  // actual rows in the rowwise rowset buffer.
  short rwrsInputSizeIndex = 0;

  // index into the user params to find the value of the max length
  // of each row in the user rowwise rowset buffer.
  short rwrsMaxInputRowlenIndex = 0;

  // index into the user params to find the value of the address
  // of rowwise rowset buffer in user space.
  short rwrsBufferAddrIndex = 0;

  // index into user params to find the value of the partition number
  // where this rwrs need to be shipped to.
  short rwrsPartnNumIndex = -1; // not specified

  // length of the each internal tuple where user's row will be moved in
  // at runtime.
  Lng32 rwrsMaxInternalRowlen = 0;

  RWRSInfo *rwrsInfo = NULL;
  char *rwrsInfoBuf = NULL;
  if (getHostArraysArea() && getHostArraysArea()->getRowwiseRowset())
    {
      rwrsInfo = (RWRSInfo *) new (space) char[sizeof(RWRSInfo)];

      rwrsInfoBuf = (char*)rwrsInfo;

      rwrsMaxSize = 
	(Lng32)((ConstValue*)getHostArraysArea()->rwrsMaxSize())->
	getExactNumericValue();

      NABoolean packedFormat      = FALSE;
      NABoolean compressed        = FALSE;
      NABoolean dcompressInMaster = FALSE;
      NABoolean compressInMaster  = FALSE;
      NABoolean partnNumInBuffer  = FALSE;
      getHostArraysArea()->getBufferAttributes(packedFormat,
					       compressed, dcompressInMaster,
					       compressInMaster,
					       partnNumInBuffer);
      rwrsInfo->setRWRSisCompressed(compressed);
      rwrsInfo->setDcompressInMaster(dcompressInMaster);
      rwrsInfo->setPartnNumInBuffer(partnNumInBuffer);
    }

  // inputVars() can contain multiple references to the same
  // param/hostvar value, if it is specified more than once in
  // a statement. (Seems like a bug to me, but no one is around
  // to fix it, so i will just work around it). The CharacteristicInputs
  // do not contain duplicate references. Use them to create a non-duplicate
  // newInputVars list.
  ValueIdList newInputVars, cacheVars, rwrsVars;
  NABoolean userInputVars = FALSE;
  short entry = 1;
  for (i = 0; i < inputVars().entries(); i++)
  {
    // CharacteristicInputs contains constants. Don't add
    // them as input. Add hostvar/params to map table, if not
    // already added. This will remove duplicates.
    // Add the non-duplicate input val-ids to the newInputVars list.
    ValueId val_id = inputVars()[i];
    ItemExpr * item_expr = val_id.getItemExpr();
    
    // We create a dummy host var in case it gets a value id from an
    // assignment in compound statements. Such variable will not need
    // to be processed by Cli since it gets its value inside the statement
    NABoolean blankHV = FALSE ;
    if (item_expr->previousHostVar()) {
      Int32 j = 0;
      for (j = 0; j < i; j++) {
	ItemExpr *ie = inputVars()[j].getItemExpr();
	if (ie->getOperatorType() == ITM_HOSTVAR) {
	  if (item_expr->previousName() == ((HostVar *) ie)->getName()) {
	    break;
	  }
	}
      }
      
      if (i == j) {
	NAString str1 = "previousHV__";
	char str2[30];
	str_itoa(i, str2);
	str1 += str2;
	item_expr = new(generator->wHeap()) HostVar(str1,
						    new(generator->wHeap()) SQLUnknown(generator->wHeap()));
	item_expr->bindNode(generator->getBindWA());
	blankHV = TRUE;
	val_id = item_expr->getValueId();
      }
    }
    
    OperatorTypeEnum op = item_expr->getOperatorType();
    
    if ((op == ITM_HOSTVAR) ||
	(op == ITM_DYN_PARAM)){
      userInputVars = TRUE;
      
      // Vicz: filter out the OUT HostVar/DynamicParam
      
      ComColumnDirection paramMode = item_expr->getParamMode();
      
      if(paramMode == COM_OUTPUT_COLUMN)
	continue;
      
    }
    
    // the list of operator types that was present here in R1.8 code in
    // almost equivalent to isAUserSuppliedInput()
    // except for Constant which cannot be handled here as its atpindex
    // should be 0 and not 2.
    // The num_tupps local variable just outside this IF will create
    // attributes with atpindex 2.
    // Constants are added later to the MapTable.
    if (((item_expr->isAUserSuppliedInput()) && // for evaluate once functions
	 (op != ITM_CONSTANT)) &&
	(! generator->getMapInfoAsIs(val_id))) // not added yet
      {
	MapInfo *map = generator->addMapInfoToThis(generator->getLastMapTable(),
						   val_id, NULL);
	
	// Transfer the information on rowsets that is in this host variable
	// into its attribute so we know this information at run time
	if (op == ITM_HOSTVAR || op == ITM_DYN_PARAM)
	  {
	    Attributes *attr = map->getAttr();
	    UInt32 rowsetInfo;
	    
	    if (op == ITM_HOSTVAR)
	      {
		HostVar *hv = (HostVar *) (val_id.getItemExpr());
		rowsetInfo = hv->getRowsetInfo();
		if (blankHV)
		  {
		    attr->setBlankHV();
		  }
	      }
	    else  // (op == ITM_DYN_PARAM)
	      {
		DynamicParam *dp = (DynamicParam *) (val_id.getItemExpr());
		rowsetInfo = dp->getRowsetInfo();

		if (dp->isDPRowsetForInputSize())
		  rwrsInputSizeIndex = entry;
		else if (dp->isRowwiseRowsetInputMaxRowlen())
		  rwrsMaxInputRowlenIndex = entry;
		else if (dp->isRowwiseRowsetInputBuffer())
		  rwrsBufferAddrIndex = entry;
		else if (dp->isRowwiseRowsetPartnNum())
		  rwrsPartnNumIndex = entry;
	      }
	    
	    attr->setRowsetInfo((Int16)rowsetInfo);
	  }
	
	if ((op == ITM_DYN_PARAM) &&
	    ((DynamicParam *)item_expr)->isRowInRowwiseRowset())
	  {
	    rwrsVars.insert(val_id);
	  }
	else if (op == ITM_CACHE_PARAM)
	  {
	    // This is a parameter generated by Query Caching
	    cacheVars.insert(val_id);
	  }
	else
	  {
	    newInputVars.insert(val_id);
	    entry++;
	  }
      }
  } // for
  
  Int32 num_tupps = 2; /* atp_index 0 for constants, 1 for temps */

  // create a row(tuple) with input param/hostvar values and pass
  // it to the child.
  // assign offset to elements in the input vars list.
  // Offsets are assigned in the input row tuple (atp index = 2).
  Attributes ** attrs = new(generator->wHeap())
	Attributes * [newInputVars.entries()];
  for (i = 0; i < newInputVars.entries(); i++)
    {
      attrs[i] = generator->addMapInfo(newInputVars[i], NULL)->getAttr();
    }

  ULng32 input_vars_size = 0;
  exp_gen->processAttributes(newInputVars.entries(), attrs,
			     ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
			     input_vars_size, 0 /*atp*/, num_tupps/*atpIdx*/);

  //++Triggers,
  // Save the offsets of triggerStatus and UniqueExecuteId,
  // so ex_root_tcb can set it's value
  Lng32 triggersStatusOffset = -1;
  Lng32 uniqueExecuteIdOffset = -1;

  for (i = 0; i < newInputVars.entries(); i++)
    {
      ItemExpr * item_expr = (newInputVars)[i].getItemExpr();
      if (item_expr->getOperatorType() == ITM_UNIQUE_EXECUTE_ID)
	uniqueExecuteIdOffset = attrs[i]->getOffset();
      if (item_expr->getOperatorType() == ITM_GET_TRIGGERS_STATUS)
	{
	  GenAssert(getTriggersList()->entries()>0,
		    "No triggers, yet TriggerStatusOffset != -1");
	  triggersStatusOffset = attrs[i]->getOffset();
	}
    }
  
  //--Triggers,

  num_tupps += ((newInputVars.entries() > 0) ? 1 : 0); // plus 1 to hold the input
                                                      // params and hostvars.

  if (updateCurrentOf())
    {
      GenAssert(pkeyList().entries() > 0, "pkeyList().entries() must be > 0");

      // create a row(tuple) with pkey hostvar values and pass
      // it to the child.
      // assign offset to elements in the pkeyList.
      // Offset is assigned at atp index which one greater than where
      // the input num_tupps is.
      Attributes ** attrs = new(generator->wHeap())
	Attributes * [pkeyList().entries()];
      for (i = 0; i < pkeyList().entries(); i++)
	{
	  attrs[i] = generator->addMapInfo(pkeyList()[i], NULL)->getAttr();
	}

      exp_gen->processAttributes(pkeyList().entries(), attrs,
				 ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
				 pkey_len,0/*atp*/,num_tupps/*atpIdx*/);
      num_tupps += 1;
    }

  // Process expressions generated by Query Caching.
  Attributes ** cachedAttrs = NULL;
  if (cacheVars.entries() > 0) {
    cachedAttrs = new(generator->wHeap())
	Attributes * [cacheVars.entries()];
    for (i = 0; i < cacheVars.entries(); i++)
    {
      cachedAttrs[i] = generator->addMapInfo(cacheVars[i], NULL)->getAttr();
    }

    exp_gen->processAttributes(cacheVars.entries(), cachedAttrs,
			       ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
			       cacheVarsSize,0/*atp*/,num_tupps/*atpIdx*/);
    num_tupps += 1;
  }

  // Space needed for query caching. This is where the values of ConstantParameters
  // will go
  //  char *queryCacheParameterBuffer = (char *) new (space) char[cacheVarsSize];
  NABoolean qCacheInfoIsClass = FALSE;
  if (CmpCommon::getDefault(QUERY_CACHE_RUNTIME) == DF_ON)
    qCacheInfoIsClass = TRUE;

  char *parameterBuffer = (char *) new (space) char[cacheVarsSize];
  char *qCacheInfoBuf = NULL;
  if (qCacheInfoIsClass)
    {
      QCacheInfo *qCacheInfo =
	(QCacheInfo *) new (space) char[sizeof(QCacheInfo)];
      qCacheInfo->setParameterBuffer(parameterBuffer);
      qCacheInfoBuf = (char*)qCacheInfo;
    }
  else
    qCacheInfoBuf = parameterBuffer;

  // Check for reasons why the query plan should not be cached.
  // Note: This does not influence the use of cache parameters,
  // it's too late at this time to undo that.
  const LIST(CSEInfo *) *cseInfoList = CmpCommon::statement()->getCSEInfoList();

  if (cseInfoList &&
      CmpCommon::getDefault(CSE_CACHE_TEMP_QUERIES) == DF_OFF)
    for (CollIndex i=0; i<cseInfoList->entries(); i++)
      if (cseInfoList->at(i)->usesATempTable())
        generator->setNonCacheableCSEPlan(TRUE);

  // compute offsets for rwrs attrs. Offsets are computed separately
  // for rwrs vars since these values will be moved as part of input
  // row at runtime. This input row should only contain values which are
  // being inserted (ex, in the VALUES clause) and not any other input
  // values (like, input size, buffer, etc). 
  // If rwrs vars was included in newInputVars before computing
  // the offsets, then these offsets will also include the non-rwrs
  // vars which will not be correct.
  //
  // Do not assign any atp index at this time.
  // atp index will be determined at runtime
  // when the actual rows that are extracted from the rowset, 
  // processed and moved up the queue.
  Attributes ** rwrsAttrs = NULL;

  // next var is used if buffer need to be decompressed using the unicode
  // decoding alogorithm. 
  NABoolean useUnicodeDcompress = FALSE;

  if (rwrsVars.entries() > 0) 
    {
      rwrsAttrs = new(generator->wHeap())
	Attributes * [rwrsVars.entries()];
      for (i = 0; i < rwrsVars.entries(); i++)
	{
	  rwrsAttrs[i] = generator->addMapInfo(rwrsVars[i], NULL)->getAttr();

	  if (rwrsAttrs[i]->getCharSet() != CharInfo::ISO88591)
	    useUnicodeDcompress = TRUE;
	}
      
      // assign offsets.
      // No real atp index is to be assigned.
      // Cannot make it -1 as processAttrs doesn't like that.
      // Make atp index to be SHRT_MAX (out of reach).
      ULng32 len;
      exp_gen->processAttributes(rwrsVars.entries(), rwrsAttrs,
				 ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
				 len, 
				 0/*atp*/, SHRT_MAX/*atpIdx*/);
      rwrsMaxInternalRowlen = len;
    }

  if (rwrsInfo)
    {
      rwrsInfo->setRwrsInfo(rwrsMaxSize, rwrsInputSizeIndex,
			    rwrsMaxInputRowlenIndex, rwrsBufferAddrIndex,
			    rwrsPartnNumIndex,
			    rwrsMaxInternalRowlen);

      if (rwrsInfo->rwrsIsCompressed())
	rwrsInfo->setUseUnicodeDcompress(useUnicodeDcompress);
    }

  // generate the input expression to move in hostvar/param values
  // from user area.
  // Include rwrs in newInputVars before generating the input expr
  // since we want all of these vars to be returned to the used when
  // they are 'described' at runtime.
  if ((newInputVars.entries() > 0) ||
      (rwrsVars.entries() > 0))
    {
      newInputVars.insert(rwrsVars);
      exp_gen->generateInputExpr(newInputVars, ex_expr::exp_INPUT_OUTPUT,
				 &input_expr);
    }

  ex_cri_desc * cri_desc = new(space) ex_cri_desc(num_tupps, space);
  generator->setCriDesc(cri_desc, Generator::DOWN);
  generator->setInputExpr((void *)input_expr);

  ExplainDesc *explainDesc = NULL;

  if(!generator->explainDisabled())
    {
      // Create a space object for the explain fragment
      if(generator->getExplainFragDirIndex() == NULL_COLL_INDEX)
	{
	  // Create an Explain Fragment
	  generator->setExplainFragDirIndex(
	       generator->getFragmentDir()->pushFragment(FragmentDir::EXPLAIN,0));
	  generator->getFragmentDir()->popFragment();
	}

      ExplainFunc explainFunc;
      TrafDesc *explainDescStruct = explainFunc.createVirtualTableDesc();

      Space *explainSpace = generator->getFragmentDir()->
	getSpace(generator->getExplainFragDirIndex());

      TrafTableDesc *tableDesc = explainDescStruct->tableDesc();

      // Determine the length of the Explain Tuple.
      Lng32 recLength = tableDesc->record_length;

      // Determine the number of columns in the Explain Tuple.
      Lng32 numCols = tableDesc->colcount;

      explainDesc =
	new(explainSpace) ExplainDesc(numCols, recLength, explainSpace);

      TrafDesc *cols = tableDesc->columns_desc;

      // For each column of the Virtual Explain Table, extract the
      // relevant info. from the table desc and put it into the ExplainDesc
      for(Int32 c = 0; c < numCols; c++ /* no pun intended */)
	{
	  TrafColumnsDesc *colsDesc = (cols->columnsDesc());

	  explainDesc->setColDescr(c,
				   colsDesc->datatype,
				   colsDesc->length,
				   colsDesc->offset,
				   colsDesc->isNullable());

	  cols = cols->next;
	}

      explainFunc.deleteVirtualTableDesc(explainDescStruct);

      compFragDir->setTopObj(generator->getExplainFragDirIndex(),
			     (char *)explainDesc);
    }

  // Take note of whether this is a parallel extract query before
  // generating the child tree.
  NABoolean isExtractProducer = (numExtractStreams_ > 0 ? TRUE : FALSE);
  NABoolean isExtractConsumer =
    (childOperType() == REL_EXTRACT_SOURCE ? TRUE : FALSE);

  // the tree below needs to know if this is a LRU operation, hence
  // make this check before the children are codeGened.
  if (containsLRU())
  {
    generator->setLRUOperation(TRUE);
  }
  if (getTolerateNonFatalError() == RelExpr::NOT_ATOMIC_) 
  {
    generator->setTolerateNonFatalError(TRUE);
  }

  // Copy #BMOs value from Root node into the fragment
  compFragDir->setNumBMOs(myFragmentId, getNumBMOs());
  compFragDir->setBMOsMemoryUsage(myFragmentId, getBMOsMemoryUsage().value());

  // generate child tree
  child(0)->codeGen(generator);
  ComTdb * child_tdb = (ComTdb *)(generator->getGenObj());
  if (child_tdb == (ComTdb *)NULL)
      childTdbIsNull = TRUE;


  // Remap the allocation of ESPs to Nodes/CPUs.
  if (ActiveSchemaDB()->getDefaults().getAsLong(AFFINITY_VALUE) == -2)
     generator->remapESPAllocationRandomly();
  else
     generator->remapESPAllocationAS();

  generator->compilerStatsInfo().affinityNumber()
    = generator->getAffinityValueUsed();

  // if an output expression is present, generate it.
  if (compExpr_.entries() > 0)
  {
    // Special cases to consider are
    // * stored procedure result sets
    // * parallel extract consumers
    // 
    // In these plans we want special table and column names in the
    // output expression. The names will come from the root's child
    // node and be pointed to by these two variables. For all other
    // ("normal") statements, these two pointers will remain NULL.
    //
    ConstNAStringPtr *colNamesForExpr = NULL;
    ConstQualifiedNamePtr *tblNamesForExpr = NULL;

    OperatorTypeEnum childType =
      child(0)->castToRelExpr()->getOperatorType();

    ComUInt32 numColumns = getRETDesc()->getDegree();

    if ((childType == REL_SP_PROXY || isExtractConsumer) &&
        numColumns > 0)
    {
      ProxyFunc *proxy;

      if (childType == REL_SP_PROXY)
      {
        // This is a stored procedure result set
        proxy = (ProxyFunc *) child(0)->castToRelExpr();
      }
      else
      {
        // This is an extract consumer. The extract operator is not
        // the direct child of the root. An exchange operator sits
        // between the two.
        GenAssert(childType == REL_EXCHANGE,
                  "Child of root should be exchange for consumer query");
        GenAssert(child(0)->child(0),
                  "Child of root should not be a leaf for consumer query");
                  
        OperatorTypeEnum grandChildType = 
          child(0)->child(0)->castToRelExpr()->getOperatorType();

        GenAssert(grandChildType == REL_EXTRACT_SOURCE,
                  "Grandchild of root has unexpected type for consumer query");

        proxy = (ProxyFunc *) child(0)->child(0)->castToRelExpr();
      }

      // Populate the table and column name collections that will be
      // used below to generate the output expression.
      colNamesForExpr = new (generator->wHeap())
        ConstNAStringPtr[numColumns];
      tblNamesForExpr = new (generator->wHeap())
        ConstQualifiedNamePtr[numColumns];

      for (ComUInt32 i = 0; i < numColumns; i++)
      {
        colNamesForExpr[i] = proxy->getColumnNameForDescriptor(i);
        tblNamesForExpr[i] = proxy->getTableNameForDescriptor(i);
      }
    }

    exp_gen->generateOutputExpr(compExpr_,
                                ex_expr::exp_INPUT_OUTPUT,
                                &output_expr,
                                getRETDesc(), 
                                getSpOutParams(),
                                colNamesForExpr,
                                tblNamesForExpr);
  }

  if (getPredExprTree())
    {
      //      ItemExpr * newPredTree = executorPred().rebuildExprTree(ITM_AND,TRUE,TRUE);
      exp_gen->generateExpr(getPredExprTree()->getValueId(), ex_expr::exp_SCAN_PRED,
			    &pred_expr);
    }

  // if child's primary key columns are to be returned to be passed
  // on to UPDATE WHERE CURRENT OF query, generate an
  // expression to compute the pkey row.
  ex_cri_desc * work_cri_desc = NULL;

  if (updatableSelect() == TRUE)
    {
      GenAssert(pkeyList().entries() > 0, "pkeyList().entries() must be > 0");

      work_cri_desc = new(space) ex_cri_desc(3, space);

      exp_gen->generateContiguousMoveExpr(pkeyList(),
					  1, // add convert nodes,
					  1, 2,
					  ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
					  pkey_len, &pkey_expr,
					  NULL, ExpTupleDesc::SHORT_FORMAT);
    }

  // if this is an 'update where current of' query, pass in
  // the fetched cursor name or hvar number root tdb.
  char * fetchedCursorName = NULL;
  short  fetchedCursorHvar = -1;
  if (updateCurrentOf())
    {
      if (currOfCursorName_->getOperatorType() == ITM_CONSTANT)
	{
	  // cursor name is specified as a literal
	  NABoolean tv;
	  ConstValue * cv = currOfCursorName_->castToConstValue(tv);

	  fetchedCursorName =
	    space->allocateAndCopyToAlignedSpace((char *)(cv->getConstValue()),
						 cv->getStorageSize(),
						 0);
	}
      else
	{
	  // cursor name was specified as a hvar
	  HostVar * cursorHvar = (HostVar *)currOfCursorName_;

	  // search for this hostvar in the input hvar list
	  for (i = 0; i < inputVars().entries(); i++)
	    {
	      ValueId val_id = inputVars()[i];
	      if (cursorHvar->getOperatorType() == ITM_HOSTVAR)
		{
		  HostVar * hv = (HostVar *)(val_id.getItemExpr());

		  if (hv->getName() == cursorHvar->getName())
		    fetchedCursorHvar = (short)i+1; // 1-based
		}
	    } // more input

	} // cursor name is in a hvar
    }

  // Create a list of update columns for UPDATE CURRENT OF or updateable
  // SELECT statements (cursors). For UPDATE CURRENT OF, the update columns
  // are obtained from the GenericUpate Node. For cursors, the update columns
  // are obtained from this (RelRoot) node.
  Lng32 numUpdateCol = 0;
  Lng32 *updateColList = NULL;

  if (updateCurrentOf()) // UPDATE/DELETE ... where CURRENT OF query.
  {
    GenAssert(updateCol().entries() == 0,
              "UPDATE CURRENT OF: updateCol non-zero");

    // Get the update node.
    GenericUpdate *update = (GenericUpdate*)generator->updateCurrentOfRel();

    GenAssert(update != NULL, "UPDATE CURRENT OF: NULL update node");

    /*
    // create the update col list for UPDATE...WHERE CURRENT OF CURSOR only.
    // The updateCurrentOf() is set for both UPDATE and DELETE queries.
    if ((update->getOperatorType() == REL_DP2_UPDATE_CURSOR) ||
	(update->getOperatorType() == REL_DP2_UPDATE_UNIQUE))
      {
	// Get the list of assignment expressions from the STOI of the
	// update node.
        SqlTableOpenInfo *updateStoi = update->getOptStoi()->getStoi();

	// Allocate an array for the column list.
	numUpdateCol = updateStoi->getColumnListCount();

	GenAssert(numUpdateCol > 0,
                  "UPDATE CURRENT OF: No update columns");

	updateColList = new(space) Lng32[numUpdateCol];

	// Populate the array with the update columns from the left side
	// of each expression which is a column.
	for (i = 0; (Lng32)i < numUpdateCol; i++)
	  {
            updateColList[i] = updateStoi->getUpdateColumn(i);
	  }
      } // update...where current of.
    */
  }
  else if (updatableSelect())
    {
      numUpdateCol = updateCol().entries();
      
      if (numUpdateCol > 0)
        {
          // Allocate an array for the column list.
      updateColList = new(space) Lng32[numUpdateCol];

      // Populate the array with the update columns of this node.
      for (i = 0; (Lng32)i < numUpdateCol; i++)
      {
        ValueId val_id = updateCol()[i];
        GenAssert(val_id.getItemExpr()->getOperatorType() == ITM_BASECOLUMN,
                  "UpdateCol should be BaseColumn");
        BaseColumn *col = (BaseColumn*)val_id.getItemExpr();
        updateColList[i] = col->getColNumber();
      }
    }
    else
    {
      // All columns are updateable.
      numUpdateCol = -1;
    }
  }

  // copy all the tables open information into the generator space
  // and pass it to the root tdb, which is used to check the
  // security when opening the sql tables or views.
  short noOfTables = (short) generator->getSqlTableOpenInfoList().entries();
  SqlTableOpenInfo **stoiList;
  stoiList = new (space) SqlTableOpenInfo*[noOfTables];
  
  // The Executor Statement class has logic to retry blown away
  // opens on some statements. We can safely do so if we know that
  // disk has not been dirtied, and no rows have been returned
  // to the application.

  // The Executor can deduce this if the blown away open occurs
  // on the first input row, and if the plan writes to at most
  // one object. This follows because an open can be blown away
  // only if no locks are held on any partition of the object.

  // The two variables below are used to compute if the plan
  // accesses more than one object. If not, and if the query is
  // an IUD, we will flag the root tdb as retryable.

  NABoolean moreThanOneTable = FALSE;
  char *firstTable = NULL;

  // ++ Triggers
  // While copying the stoi info, make sure the subjectTable flag is
  // not set more than once for the same table ansi name
  LIST(NAString) *subjectTables = NULL;
  if (getTriggersList())
    subjectTables = new (generator->wHeap())
      LIST(NAString) (generator->wHeap());
  short j=0;

  for (; j < noOfTables; j++)
  {
    stoiList[j] = new (space) SqlTableOpenInfo;
    SqlTableOpenInfo * genStoi =
		(SqlTableOpenInfo *)generator->getSqlTableOpenInfoList()[j];
    *(stoiList[j]) = *genStoi;

    if (moreThanOneTable)
    {
      // No need to check any further.
    }
    else
    {
      if (firstTable == NULL)
      {
        firstTable = genStoi->fileName();
      }
      else if (stricmp( firstTable, genStoi->fileName()))
      {
        // there is more than one distinct object name in the Stoi list
        moreThanOneTable = TRUE;
      }
    }
    stoiList[j]->setFileName(new (space) char[strlen(genStoi->fileName()) + 1]);
    strcpy(stoiList[j]->fileName(), genStoi->fileName());

    stoiList[j]->setAnsiName(new (space) char[strlen(genStoi->ansiName()) + 1]);
    strcpy(stoiList[j]->nonConstAnsiName(), genStoi->ansiName());

    // -- Triggers
    // Prevent duplicate entries for the same subject table
    // and entries for views
    NAString const ansiName(genStoi->ansiName(), generator->wHeap());
    if (genStoi->subjectTable() && subjectTables &&
	!(subjectTables->contains(ansiName)) && !genStoi->isView())
    {
      stoiList[j]->setSubjectTable(TRUE);
      subjectTables->insert(ansiName);
    }
    else
      stoiList[j]->setSubjectTable(FALSE);

    if (genStoi->getColumnListCount())
    {
      stoiList[j]->setColumnList(new (space)
                     short[genStoi->getColumnListCount()]);
      for (short k = 0; k < genStoi->getColumnListCount(); k++)
      {
        stoiList[j]->setUpdateColumn(k,genStoi->getUpdateColumn(k));
      }
    }
  }

  // copy the triggers list into the generator space
  // and pass it to the root tdb, where it is used to check the
  // enable/disable status of triggers.
  short triggersCount = 0;
  ComTimestamp *triggersList = NULL;
  if (getTriggersList())
  {
    GenAssert(subjectTables && (subjectTables->entries() > 0),
	      "Mismatch: Triggers without Subject Tables");
    delete subjectTables;
    subjectTables = NULL;

    triggersCount = (short) getTriggersList()->entries();
    triggersList = new (space) ComTimestamp[triggersCount];

    for (short k=0; k < triggersCount; k++)
      triggersList[k] = getTriggersList()->at(k);
  }

  // copy uninitializedMvList into generator space 
  // to pass to root tdb  
  UninitializedMvName *newMvList = NULL; 
  short uninitializedMvCount = 0;  
  
  if (uninitializedMvList_) 
  {            
      uninitializedMvCount = (short)uninitializedMvList_->entries();
      if( uninitializedMvCount != 0 )
      {
          newMvList = new (space) UninitializedMvName[uninitializedMvCount];
          for( short i = 0; i < uninitializedMvCount; i++ )
          {          
              UninitializedMvName *pMvName = uninitializedMvList_->at(i);

              GenAssert( pMvName, "UninitializedMvName is invalid." );

              newMvList[i].setPhysicalName( pMvName->getPhysicalName() );
              newMvList[i].setAnsiName( pMvName->getAnsiName() );                            
          }
      }
  } 


  // if there were any views referenced in the query, copy the stoi
  // to root tdb. This is used at runtime to check for existence.
  Queue * viewStoiList = NULL;
  if (getViewStoiList().entries() > 0)
    {
      for (CollIndex i = 0; i < getViewStoiList().entries(); i++)
	{

	  if (! viewStoiList)
	    viewStoiList = new(space) Queue(space);

	  SqlTableOpenInfo * stoi = new(space) SqlTableOpenInfo;
	  *stoi = *getViewStoiList()[i]->getStoi();

	  stoi->setFileName(
	    new(space)  char[strlen(getViewStoiList()[i]->getStoi()->fileName()) + 1]);
	  strcpy(stoi->fileName(), getViewStoiList()[i]->getStoi()->fileName());

	  stoi->setAnsiName(
	    new(space)  char[strlen(getViewStoiList()[i]->getStoi()->ansiName()) + 1]);
	  strcpy(stoi->nonConstAnsiName(), getViewStoiList()[i]->getStoi()->ansiName());

          if (getViewStoiList()[i]->getStoi()->getColumnListCount())
	  {
	    stoi->setColumnList(new (space)
	      short[getViewStoiList()[i]->getStoi()->getColumnListCount()]);
	    for (short k = 0; k < getViewStoiList()[i]->getStoi()->getColumnListCount(); k++)
	      {
		stoi->setUpdateColumn(k,getViewStoiList()[i]->getStoi()->getUpdateColumn(k));
	      }
	  }

	  if (CmpCommon::getDefault(VALIDATE_VIEWS_AT_OPEN_TIME) == DF_ON)
	    stoi->setValidateViewsAtOpenTime(TRUE);
          else
            stoi->setValidateViewsAtOpenTime(FALSE);

	  viewStoiList->insert(stoi);

	  // if this view name was used as a variable(hvar, envvar or define),
	  // then add it to the latename info list.
	  HostVar * hv = getViewStoiList()[i]->getCorrName().getPrototype();
	  if (hv != NULL)
	    {
	      LateNameInfo* lateNameInfo = new(generator->wHeap()) LateNameInfo();

	      char * varName;
	      GenAssert(hv->getName().data(), "Hostvar pointer must have name");

	      lateNameInfo->setEnvVar(hv->isEnvVar());

	      lateNameInfo->setCachedParam(hv->isCachedParam());

	      varName = convertNAString(hv->getName(), generator->wHeap());
	      strcpy(lateNameInfo->variableName(), varName);

	      char * prototypeValue =  convertNAString(hv->getPrototypeValue(),
						       generator->wHeap());
	      char * compileTimeAnsiName = prototypeValue;
	      lateNameInfo->setVariable(1);

	      lateNameInfo->setView(1);

              lateNameInfo->setCompileTimeName(compileTimeAnsiName, space);
	      lateNameInfo->setLastUsedName(compileTimeAnsiName, space);
	      lateNameInfo->setNameSpace(COM_TABLE_NAME);

	      lateNameInfo->setInputListIndex(-1);

	      generator->addLateNameInfo(lateNameInfo);

	    } // hv
	} // for
    }

  // UDR Security
  short noOfUdrs = generator->getBindWA()->getUdrStoiList().entries ();

  SqlTableOpenInfo **udrStoiList = NULL;
  if ( noOfUdrs )
  {
    udrStoiList = new (space) SqlTableOpenInfo*[noOfUdrs];
    BindWA *bindWA = generator->getBindWA ();

    for (short udrIdx=0; udrIdx < noOfUdrs; udrIdx++)
    {
      udrStoiList[udrIdx] = new (space) SqlTableOpenInfo;
      SqlTableOpenInfo *genUdrStoi =
       (SqlTableOpenInfo *)bindWA->getUdrStoiList()[udrIdx]->getUdrStoi();

      *(udrStoiList[udrIdx]) = *genUdrStoi;

      udrStoiList[udrIdx]->setAnsiName(
			 new (space)  char[strlen(genUdrStoi->ansiName()) + 1]
				      );
      strcpy(udrStoiList[udrIdx]->nonConstAnsiName(), genUdrStoi->ansiName());
    }
  }

  // setting transaction type flags in the transmode object
  // Determines what type of transaction will be started for this statement,
  // if autocommit is ON.

  // setting accessMode to read_write if it was set to read_only by MX.
  // if isolation_level is read_uncommitted we set accessmode to read only
  // This causes trouble when we try to do DDL or IUD so we are resetting
  // accessMode here. From here on accesMode is used only to start the transaction
  if ((transMode->accessMode() == TransMode::READ_ONLY_) &&
      (generator->needsReadWriteTransaction()))
	transMode->accessMode() = TransMode::READ_WRITE_ ;


  if (generator->withNoRollbackUsed() ||
      (transMode->getRollbackMode() == TransMode::NO_ROLLBACK_))
  {
      if (generator->withNoRollbackUsed())
        transMode->rollbackMode() = TransMode::NO_ROLLBACK_IN_IUD_STATEMENT_ ;

      //      if (childOperType().match(REL_ANY_GEN_UPDATE))
      //        generator->setAqrEnabled(FALSE);

      // AIInterval is set to don't abort (i.e. 0). 
      // A setting of -2 is equivalent to a setting of 0 but has the additional meaning
      // that it will never be overriden by the executor.
      if (transMode->getAutoAbortIntervalInSeconds() == -1)
        transMode->autoAbortIntervalInSeconds() = -2;
  }
  else if ((NOT generator->needsReadWriteTransaction()) &&
	    transMode->accessMode() != TransMode::READ_ONLY_SPECIFIED_BY_USER_ &&
	    containsLRU() == FALSE &&
	    updatableSelect() == FALSE)
  {
    transMode->accessMode() = TransMode::READ_ONLY_ ;
  }

  if (transMode->getAutoAbortIntervalInSeconds() == -1)
  {
      if (transMode->accessMode() == TransMode::READ_ONLY_SPECIFIED_BY_USER_)
	transMode->autoAbortIntervalInSeconds() = -2;
      else if (transMode->accessMode() == TransMode::READ_ONLY_)
	transMode->autoAbortIntervalInSeconds() = 0;
  }

  // create the latename info List to be passed on to root_tdb.
  LateNameInfoList * lnil = NULL;
  Int32 numEntries = 0;
  if  (generator->getLateNameInfoList().entries() > 0)
    numEntries = generator->getLateNameInfoList().entries();
  lnil =
    (LateNameInfoList *)
      space->allocateMemory( sizeof(LateNameInfoList) +
                             (numEntries * sizeof(LateNameInfo)) );

  // Initialize LNIL from real LNIL object (this copies vtblptr into lnil).
  LateNameInfoList lnild;
  memcpy((char *)lnil,&lnild,sizeof(LateNameInfoList));

  lnil->setNumEntries(generator->getLateNameInfoList().entries());

  // This allocates an array of 64-bit pointers in lnil.
  lnil->allocateList(space,numEntries);

  // This sets up the array elements to point to the LateNameInfo objects.
  for (j = 0; j < numEntries; j++)
    lnil->setLateNameInfo(j,((LateNameInfo *)(lnil + 1)) + j);

  NABoolean viewPresent = FALSE;
  NABoolean variablePresent = FALSE;

  // olt opt is only done for tablenames which are literals
  NABoolean doTablenameOltOpt = TRUE;
  if  (generator->getLateNameInfoList().entries() > 0)
    {
      for (CollIndex i = 0;
	   i < generator->getLateNameInfoList().entries(); i++)
	{
	  LateNameInfo * tgt = &(lnil->getLateNameInfo(i));
	  LateNameInfo * src = (LateNameInfo *)generator->getLateNameInfoList()[i];
	  if (src->isVariable())
	    {
              doTablenameOltOpt = FALSE;
	    }

	  // *tgt = *src wouldn't work since it doesn't copy over the vtblptr.
	  memmove(tgt,src,sizeof(LateNameInfo));
	  // find the position of this hostvar in input var list.
	  if ((src->isVariable()) && (! src->isEnvVar()))
	    {
	      if (tgt->isCachedParam())
		{
		  tgt->setCachedParamOffset((Lng32)cachedAttrs[tgt->getInputListIndex()-1]->getOffset());
		}
	      else
		{
		  NABoolean found = FALSE;
		  for (CollIndex i = 0; ((i < newInputVars.entries()) && (! found)); i++)
		    {
		      ValueId val_id = newInputVars[i];
		      ItemExpr * item_expr = val_id.getItemExpr();
		      if (item_expr->getOperatorType() == ITM_HOSTVAR)
			{
			  HostVar * inputHV = (HostVar *)item_expr;
			  if ((inputHV->getName().length() == strlen(src->variableName())) &&
			      (strcmp(inputHV->getName().data(), src->variableName()) == 0))
			    {
			      found = TRUE;
			      tgt->setInputListIndex((short)(i+1));
			    }
			} // hostvar in input list
		    } // for

		  if (! found)
		    GenAssert(0, "Must find prototype hvar in input hvar");
		}
	    } // not an env var or a define.

      if (tgt->compileTimeAnsiName()[0] == '\\')
        {
	  if (NOT tgt->isVariable())
	    {
              tgt->setAnsiPhySame(TRUE);
	    }
	  else
	    {
	      if (tgt->isEnvVar())
		tgt->setAnsiPhySame(TRUE);
	      else
		{
		  // hostvar
		  // If prototype is a fully qualified name, then
		  // ansi-phy names are the same.
		  if (tgt->compileTimeAnsiName()[0] == '\\')
		    tgt->setAnsiPhySame(TRUE);
		};
	    }
        }
      else
        {
	  if (tgt->isVariable())
	    {
	      QualifiedName qn(tgt->compileTimeAnsiName(), 1,
			       generator->wHeap(),
			       generator->getBindWA());
	      qn.applyDefaults(generator->currentCmpContext()->schemaDB_->getDefaultSchema());
	      char * compileTimeAnsiName = space->AllocateAndCopyToAlignedSpace(
		   qn.getQualifiedNameAsAnsiString(), 0);
              tgt->setCompileTimeName(compileTimeAnsiName, space);
	    }
	} // else
      
      if (tgt->isView())
	viewPresent = TRUE;
      
      if (tgt->isVariable())
	variablePresent = TRUE;

      if (tgt->lastUsedAnsiName()[0] != '\0')
      {
	// VO, Metadata Indexes
	if (tgt->getNameSpace() == COM_INDEX_NAME)
	  // This lni is for an index - don't copy the compile time ansi name if the
	  // query is from a system module
	  if ( (generator->currentCmpContext()->internalCompile() != CmpContext::INTERNAL_MODULENAME) &&
	       !CmpCommon::statement()->isSMDRecompile() )
	    tgt->setLastUsedName(tgt->compileTimeAnsiName(),space);
      }

      // Special handling for case where we are recompiling a system module 
      // query. We need to resolve the name here since it will not go 
      // through the resolveNames in the CLI. Do this only for NSK
	} // for
    }

  lnil->setViewPresent(viewPresent);

  lnil->setVariablePresent(variablePresent);

  // Generate info to do similarity check.
  TrafQuerySimilarityInfo * qsi = genSimilarityInfo(generator);

  // generate the executor fragment directory <exFragDir> (list of all
  // fragments of the plan that are executed locally or are downloaded
  // to DP2 or to ESPs) from the generator's copy <compFragDir> and attach
  // it to the root_tdb
  NABoolean fragmentQuotas = CmpCommon::getDefault(ESP_MULTI_FRAGMENTS) == DF_ON;
  ExFragDir *exFragDir =
    new(space) ExFragDir(compFragDir->entries(),space,
                         CmpCommon::getDefault(ESP_MULTI_FRAGMENTS) == DF_ON, 
                         fragmentQuotas, 
                         (UInt16)CmpCommon::getDefaultLong(ESP_MULTI_FRAGMENT_QUOTA_VM),
                           (UInt8)CmpCommon::getDefaultLong(ESP_NUM_FRAGMENTS));

  // We compute the space needed in execution time for input Rowset variables
  for (i = 0; i < inputVars().entries(); i++)
  {
      ValueId val_id = inputVars()[i];
      ItemExpr * item_expr = val_id.getItemExpr();
      OperatorTypeEnum op = item_expr->getOperatorType();
      if (op == ITM_HOSTVAR) {
        HostVar *hostVar = (HostVar *) item_expr;
        if (hostVar->getType()->getTypeQualifier() == NA_ROWSET_TYPE) {
          Lng32 thisSize = hostVar->getType()->getTotalSize();
          input_vars_size += thisSize;
        }
      }
  }

  // find out if this is a delete where current of query.
  NABoolean delCurrOf = FALSE;
  short baseTablenamePosition = -1;
  if (fetchedCursorName || (fetchedCursorHvar >= 0)) // upd/del curr of
    {
      if (childOperType() == REL_UNARY_DELETE)
	delCurrOf = TRUE;
      else
	delCurrOf = FALSE;
    }

  // The ansi names of the table specified in the cursor stmt must match
  // the name specified in the upd/del where curr of stmt. This check
  // is done at runtime.
  // basetablenameposition is the index in the latenameinfolist of
  // the entry whose lastUsedAnsiName contains the name of the table.
  baseTablenamePosition = -1;
  if (updatableSelect())
    {
      // if this is an updatable select, find the ansi name of the basetable.
      // This name will be used at runtime to compare to the tablename
      // specified in an 'upd/del where current of' stmt. The two tablenames
      // must be the same.
      for (Int32 n = 0; n < noOfTables; n++)
	{
	  SqlTableOpenInfo * stoi = stoiList[n];

	  if (NOT stoi->isIndex())
	    {
	      if (baseTablenamePosition == -1)
		{
		  baseTablenamePosition = n;
		}
	    }
	}
      if (baseTablenamePosition == -1)
	{
	  // no base table access used. Only index access is used.
	  // The ansiname field in latenameInfo struct is the ansi name
	  // of the base table. Use that.
	  baseTablenamePosition = 0;
	}
    }
  else if (updateCurrentOf())
    {
      // if this is an update/delete current of query, find the index of
      // the base table. There might be other tables used in the plan
      // for index maintanence and they will either be indices or
      // specialTables with the special type being an INDEX_TABLE.
      // Look only for the true base tables.
      for (Int32 n = 0; n < noOfTables; n++)
	{
	  SqlTableOpenInfo * stoi = stoiList[n];

	  if ((NOT stoi->isIndex()) &&
	      (NOT stoi->specialTable()) &&
              (stoi->getUpdateAccess() ||
               stoi->getDeleteAccess() ))
	    {
	      if (baseTablenamePosition == -1)
		{
		  baseTablenamePosition = n;
		}
	    }
	}

      if (baseTablenamePosition == -1)
	{
	  // No base table found in the stoi list.
	  // Raise an error.
	  GenAssert(0, "Must find updelTableNamePosition!");
	}
    }

  // find out if this was an update,delete or insert query.
  NABoolean updDelInsert = FALSE;
  if (childOperType().match(REL_ANY_GEN_UPDATE))
    updDelInsert = TRUE;

  // Do OLT optimization if:
  //  -- OLT optimization is possible
  //  -- and no upd/del where current of
  //  -- and no late name resolution
  //  -- and no views in query
  NABoolean doOltQryOpt = FALSE;
  if ((oltOptInfo().oltCliOpt()) &&
      (viewStoiList == NULL) &&          // no views
      (doTablenameOltOpt == TRUE) &&                  // no late name info
      (fetchedCursorName == NULL) &&     // no upd/del curr of
      (fetchedCursorHvar < 0) &&
      (delCurrOf == FALSE) &&
      (getFirstNRows() == -1))          // no firstn specified
    {
      doOltQryOpt = TRUE;
    }

  // At runtime, we try to internally reexecute a statement in case of
  // lost opens, if that query has not affected the database(inserted/updated/
  // deleted a row), or a row has not been returned to the application.
  // Do not retry for lost opens of IUD queries if there are more
  // than one tables in the query. This is because we don't know if the db
  // was affected when the open was lost on the non-IUD table in the query.
  // For ex: in an insert...select query, an open could be blown away for
  // the select part of the query.
  // If there is only one table in this query, then that row will get locked
  // during IUD and the open could not be blown away.
  // If some day we put in a scheme to detect that the database
  // was not affected for a multi-table IUD, we can retry for lost
  // opens.
  NABoolean retryableStmt = TRUE;

  if (generator->aqrEnabled())
    {
      retryableStmt = FALSE;
    }

  if (updDelInsert && moreThanOneTable)
    retryableStmt = FALSE;

  if (childOperType() == REL_DDL)
    retryableStmt = FALSE;

  if (isExtractProducer || isExtractConsumer)
    retryableStmt = FALSE;

  // For now we mark statements containing UDRs as non-retryable.
  // This is to avoid executing a stored procedure body multiple times
  // inside a single application request. Currently the only UDR-
  // containing statment is CALL.
  //
  // There are scenarios however in which it would be correct (and
  // helpful) to retry a UDR-containing statement. Perhaps in the
  // future the restriction can be lifted in some cases.  Safe retry
  // scenarios include a subquery input parameter returning a blown
  // away open error before the stored procedure body has executed,
  // and UDR bodies that only do computation and not transactional work.
  if (noOfUdrs > 0)
    retryableStmt = FALSE;

  short maxResultSets = generator->getBindWA()->getMaxResultSets();

  char *queryCostInfoBuf = NULL;
  QueryCostInfo *queryCostInfo =
    (QueryCostInfo *) new (space) char[sizeof(QueryCostInfo)];
  // fill in cost. Taken from explain code in GenExplain.cpp
  if (getRollUpCost())
    {
      double cpu, io, msg, idle, seqIOs, randIOs, total, cardinality;
      double totalMemPerCpu, totalMemPerCpuInKB;
      short maxCpuUsage;
      Lng32 dummy;
      Cost const *operatorCost = getRollUpCost();
      const NABoolean inMaster = generator->getEspLevel() == 0;
      operatorCost->getExternalCostAttr(cpu, io, msg, idle, seqIOs, randIOs, total, dummy);
//      operatorCost->getOcmCostAttr(cpu, io, msg, idle, dummy);
//      total = MINOF(operatorCost->convertToElapsedTime(), 1e32).getValue();

      cardinality = MINOF(getEstRowsUsed(), 1e32).value();

      // get the totalMem that is being used divide by max dop to get an 
      // an estimate of memory usage per cpu. Convert to KB units.
      totalMemPerCpu = 
	generator->getTotalEstimatedMemory() /
	((generator->compilerStatsInfo().dop() > 0) ? 
	 generator->compilerStatsInfo().dop() : 1);
      totalMemPerCpuInKB = totalMemPerCpu / 1024 ;
      maxCpuUsage = generator->getMaxCpuUsage() ;
      queryCostInfo->setCostInfo(cpu, io, msg, idle, seqIOs, randIOs, total,
                                 cardinality, totalMemPerCpuInKB, maxCpuUsage);

      // if resourceUsage need to be set (low/medium/high), set it here.
      // For now, set to 0 which indicates that this value is not 
      // being returned.
      queryCostInfo->setResourceUsage(0);
    }
  
  queryCostInfoBuf = (char*)queryCostInfo;
  //
  // CompilationStatsData  
  CompilationStats* stats = CURRENTSTMT->getCompilationStats();
  char *compilerId = new (space) char[COMPILER_ID_LEN];
  str_cpy_all(compilerId, generator->currentCmpContext()->getCompilerId(),
              COMPILER_ID_LEN);
  Int32 cLen = stats->getCompileInfoLen();
  //
  // make it 1 at minimum
  cLen = ( cLen < 1 ) ? 1 : cLen;

  char *compileInfo = new (space) char[cLen];
  stats->getCompileInfo(compileInfo);      
  //
  // Some of the fields are set here but modified later after generator phase is
  // complete (such as compileEndTime, CMP_PHASE_ALL, and CMP_PHASE_GENERATOR)
  CompilationStatsData *compilationStatsData =
    (CompilationStatsData *) new (space) 
        CompilationStatsData(stats->compileStartTime(),
            stats->compileEndTime(),  
            compilerId, 
            stats->cmpPhaseLength(CompilationStats::CMP_PHASE_ALL),
            stats->cmpPhaseLength(CompilationStats::CMP_PHASE_BINDER),
            stats->cmpPhaseLength(CompilationStats::CMP_PHASE_NORMALIZER),
            stats->cmpPhaseLength(CompilationStats::CMP_PHASE_ANALYZER),
            stats->cmpPhaseLength(CompilationStats::CMP_PHASE_OPTIMIZER),
            stats->cmpPhaseLength(CompilationStats::CMP_PHASE_GENERATOR), 
            stats->metadataCacheHits(),
            stats->metadataCacheLookups(),
            stats->getQueryCacheState(),
            stats->histogramCacheHits(),
            stats->histogramCacheLookups(),
            stats->stmtHeapCurrentSize(),
            stats->cxtHeapCurrentSize(),
            stats->optimizationTasks(),
            stats->optimizationContexts(),
            stats->isRecompile(),
            compileInfo,
            stats->getCompileInfoLen());  
  //
  // CompilerStats 
  char *compilerStatsInfoBuf = NULL;
  CompilerStatsInfo *compilerStatsInfo =
    (CompilerStatsInfo *) new (space) char[sizeof(CompilerStatsInfo)];
  compilerStatsInfoBuf = (char*)compilerStatsInfo;
  *compilerStatsInfo = generator->compilerStatsInfo();  

  // remove the duplicated entries from the schema label list, and put the
  // unique entries in TDB. During execution time, we will check the 
  // LastModTimestamp of the schema label. If the lastModTimestamp has changed,
  // a timestamp mismatch will be returned, allowing for recompilation of the
  // query


  NABoolean validateSSTSFlag = TRUE;

  CollIndex numObjectUIDs = generator->objectUids().entries();
  Int64 *objectUIDsPtr = NULL;
  if (numObjectUIDs > 0)
    {
      objectUIDsPtr  = new (space) Int64[numObjectUIDs];
      for (CollIndex i = 0; i < numObjectUIDs; i++)
        objectUIDsPtr[i] = generator->objectUids()[i];
    }
  
  Queue * listOfSnapshotscanTables =  NULL;
  NAString tmpLocNAS;
  char * tmpLoc = NULL;
  Int64 numObjectNames = generator->objectNames().entries();
  if (numObjectNames >0)
  {
    listOfSnapshotscanTables = new(space) Queue(space);
    for (Lng32 i=0 ; i <generator->objectNames().entries(); i++)
    {
     char * nm = space->allocateAlignedSpace(generator->objectNames()[i].length() + 1);
     strcpy(nm, generator->objectNames()[i].data());
     listOfSnapshotscanTables->insert(nm);
    }

    tmpLocNAS = generator->getSnapshotScanTmpLocation();
    CMPASSERT(tmpLocNAS[tmpLocNAS.length()-1] =='/');
    tmpLoc = space->allocateAlignedSpace(tmpLocNAS.length() + 1);
    strcpy(tmpLoc, tmpLocNAS.data());
  }


  // for describe type commands(showshape, showplan, explain) we don't
  // need to pass in the actual param values even if the query contains
  // params. Reset input_expr. This is done to avoid returning
  // an error later if the actual param value is not set.
 OperatorTypeEnum child_op_type = childOperType();
  if (child_op_type == REL_EXE_UTIL || child_op_type == REL_DESCRIBE)
  {
    RelExpr * lc = child(0)->castToRelExpr();
    OperatorTypeEnum actual_op_type = lc->getOperatorType();

    if (actual_op_type == REL_EXE_UTIL)
    {
      ExeUtilExpr *e = (ExeUtilExpr *)lc;
      if (e->getExeUtilType() == ExeUtilExpr::DISPLAY_EXPLAIN_)
        input_expr = NULL;
    }
    else if (actual_op_type == REL_DESCRIBE)
    {
       Describe *d = (Describe *)lc;
       if (d->getFormat() == Describe::SHAPE_ 
         ||  d->getFormat() == Describe::PLAN_)
           input_expr = NULL;
    }
  }

  // ---------------------------------------------------------------------
  // now initialize the previously allocated root tdb. note that this
  // init *must* come before we fill in the exFragDir's info because there
  // we compute how much space is used by the fragment the root is in.
  // This init() call passes in the space object. The root might allocate
  // more space for its uses inside init().
  // ---------------------------------------------------------------------
  root_tdb->init(child_tdb,
                 cri_desc, // input to child
                 (InputOutputExpr *)input_expr,
                 (InputOutputExpr *)output_expr,
                 input_vars_size,
                 pkey_expr,
                 pkey_len,
                 pred_expr,
                 work_cri_desc,
                 exFragDir,
                 transMode,
                 fetchedCursorName,
                 fetchedCursorHvar,
		 delCurrOf,
                 numUpdateCol,
                 updateColList,
                 (outputVarCntValid() && outputVarCnt()),
                 noOfTables,
                 getFirstNRows(),
                 userInputVars,
                 (getRollUpCost() ?
                  getRollUpCost()->displayTotalCost().getValue() : 0),
                 stoiList,
                 lnil,
                 viewStoiList,
                 qsi,
                 space,
		 uniqueExecuteIdOffset, //++ Triggers -
		 triggersStatusOffset,
		 triggersCount,
		 triggersList,
                 (short)generator->getTempTableId(),
		 (short)baseTablenamePosition,
		 updDelInsert,
		 retryableStmt,
		 getGroupAttr()->isStream(),
		 // next flag is set for destructive stream access protocol.
		 // Not needed for hbase/seabase access.
		 (getGroupAttr()->isEmbeddedUpdateOrDelete() &&
		  (NOT hdfsAccess())),
		 CmpCommon::getDefaultNumeric(STREAM_TIMEOUT),
		 generator->getPlanId(),
		 qCacheInfoBuf,
		 cacheVarsSize,
		 udrStoiList,
		 noOfUdrs,
                 maxResultSets,
		 queryCostInfoBuf,
		 newMvList,
		 uninitializedMvCount,
		 compilerStatsInfoBuf,
		 rwrsInfoBuf,
                 numObjectUIDs ,
                 objectUIDsPtr,
                 compilationStatsData,
                 tmpLoc,
                 listOfSnapshotscanTables);

  root_tdb->setTdbId(generator->getAndIncTdbId());
  
  if (childTdbIsNull)
     root_tdb->setChildTdbIsNull(); 
  if (generator->explainInRms())
     root_tdb->setExplainInRms();

  OperatorTypeEnum childOper = childOperType();

  if (qCacheInfoIsClass)
    root_tdb->setQCacheInfoIsClass(TRUE);

  if (getHostArraysArea() && getHostArraysArea()->getRowwiseRowset())
    {
      root_tdb->setRowwiseRowsetInput(TRUE);
    }
  else
    {
      NABoolean singleRowInput = TRUE;
      if ((input_expr) && ((InputOutputExpr *)input_expr)->isCall())
	singleRowInput = FALSE;

      if (CmpCommon::getDefault(COMP_BOOL_92) == DF_OFF)
	singleRowInput = FALSE;

      root_tdb->setSingleRowInput(singleRowInput);
    }

  if (childOper == REL_DDL)
    {
      root_tdb->setDDLQuery(TRUE);
    }

    root_tdb->setCIFON(isCIFOn_);
    if (generator->currentCmpContext()->isEmbeddedArkcmp())
      //if (IdentifyMyself::GetMyName() == I_AM_EMBEDDED_SQL_COMPILER)
      root_tdb->setEmbeddedCompiler(TRUE);
   else
     root_tdb->setEmbeddedCompiler(FALSE);
  // We check to see if this tree corresponds to a compound statement so
  // we know this at execution time

  RelExpr* checkNode = child(0);

  if ( checkNode->getOperatorType() == REL_EXCHANGE )
    checkNode = checkNode->child(0);

  if ( checkNode->getOperatorType() == REL_PARTITION_ACCESS )
    checkNode = checkNode->child(0);

  if (checkNode->getOperatorType() == REL_COMPOUND_STMT ||
      (checkNode->getOperatorType() == REL_UNION ||
       checkNode->getOperatorType() == REL_MERGE_UNION)
      &&
      ((Union *) (RelExpr *) checkNode)->getUnionForIF()) {
    root_tdb->setCompoundStatement();
  }

  root_tdb->setDoOltQueryOpt(doOltQryOpt);

  root_tdb->setQueryType(ComTdbRoot::SQL_OTHER);

  // set the EMS Event Experience Level information
  // the default is ADVANCED if it is not specified
  if (CmpCommon::getDefault(USER_EXPERIENCE_LEVEL) == DF_BEGINNER)
  {
      root_tdb->setEMSEventExperienceLevelBeginner(TRUE);
  } 
  if (CmpCommon::getDefault(UNC_PROCESS) == DF_ON)
  {
      root_tdb->setUncProcess(TRUE);
  }

  
  // If this is a ustat query set the query type so WMS can monitor it
  if (childOper == REL_DDL)
    {
      DDLExpr *ddlExpr = (DDLExpr *)child(0)->castToRelExpr();
      char * stmt = ddlExpr->getDDLStmtText();
      NAString ddlStr = NAString(stmt);
      ddlStr = ddlStr.strip(NAString::leading, ' ');
      // If this is a ustat statement, set the type 
      Int32 foundUpdStat = 0;
      
      // check if the first token is UPDATE
      size_t position = ddlStr.index("UPDATE", 0, NAString::ignoreCase);
      if (position == 0)
        {
          // found UPDATE. See if the next token is STATISTICS.
          ddlStr = ddlStr(6, ddlStr.length()-6); // skip over UPDATE
          ddlStr = ddlStr.strip(NAString::leading, ' ');
          
          position = ddlStr.index("STATISTICS", 0, NAString::ignoreCase);
          if (position == 0)
            foundUpdStat = -1;
        }
      if (foundUpdStat)
        { 
          root_tdb->setQueryType(ComTdbRoot::SQL_CAT_UTIL);     
        }
    }
  // Disable Cancel for some queries.  But start the logic with 
  // "all queries can be canceled."
  root_tdb->setMayNotCancel(FALSE);

  // Disallow cancel.
  if (CmpCommon::getDefault(COMP_BOOL_20) == DF_ON)
    root_tdb->setMayNotCancel(TRUE);

  if (generator->mayNotCancel())
    root_tdb->setMayNotCancel(TRUE);

  if (updDelInsert)
    {
      if ((childOper == REL_UNARY_INSERT) ||
	  (childOper == REL_LEAF_INSERT) ||
	  (childOper == REL_INSERT_CURSOR))
	root_tdb->setQueryType(ComTdbRoot::SQL_INSERT_NON_UNIQUE);
      else if ((childOper == REL_UNARY_UPDATE) ||
	       (childOper == REL_LEAF_UPDATE) ||
	       (childOper == REL_UPDATE_CURSOR))
	root_tdb->setQueryType(ComTdbRoot::SQL_UPDATE_NON_UNIQUE);
      else if ((childOper == REL_UNARY_DELETE) ||
	       (childOper == REL_LEAF_DELETE) ||
	       (childOper == REL_DELETE_CURSOR))
	root_tdb->setQueryType(ComTdbRoot::SQL_DELETE_NON_UNIQUE);
    }
  
  if (output_expr)
    root_tdb->setQueryType(ComTdbRoot::SQL_SELECT_NON_UNIQUE);
  
  if ((updDelInsert) &&
      (root_tdb->getQueryType() == ComTdbRoot::SQL_INSERT_NON_UNIQUE) &&
      (rwrsInfo))
    {
      root_tdb->setQueryType(ComTdbRoot::SQL_INSERT_RWRS);
    }
  else if ((child(0)) &&
	   (child(0)->castToRelExpr()->getOperatorType() == REL_UTIL_INTERNALSP))
    {
       root_tdb->setQueryType(ComTdbRoot::SQL_CAT_UTIL);
    }
  else if ((child(0)) &&
	   (child(0)->castToRelExpr()->getOperatorType() == REL_DESCRIBE))
    {
      root_tdb->setSubqueryType(ComTdbRoot::SQL_DESCRIBE_QUERY);
    }
  else if ((child(0)) &&
	   (child(0)->castToRelExpr()->getOperatorType() == REL_EXE_UTIL))
    {
      root_tdb->setQueryType(ComTdbRoot::SQL_EXE_UTIL);
      ExeUtilExpr * exeUtil = (ExeUtilExpr*)child(0)->castToRelExpr();
      if (exeUtil->getExeUtilType() == ExeUtilExpr::CREATE_TABLE_AS_)
      {
        if (CmpCommon::getDefault(REDRIVE_CTAS) == DF_OFF)
	  root_tdb->setQueryType(ComTdbRoot::SQL_INSERT_NON_UNIQUE);
        else
          root_tdb->setSubqueryType(ComTdbRoot::SQL_STMT_CTAS);
      }
      else if (exeUtil->getExeUtilType() == ExeUtilExpr::GET_STATISTICS_)
          root_tdb->setSubqueryType(ComTdbRoot::SQL_STMT_GET_STATISTICS);
      else if (exeUtil->getExeUtilType() == ExeUtilExpr::DISPLAY_EXPLAIN_)
	{
          root_tdb->setSubqueryType(ComTdbRoot::SQL_DISPLAY_EXPLAIN);

	   if (CmpCommon::getDefault(EXE_UTIL_RWRS) == DF_ON)
	     root_tdb->setExeUtilRwrs(TRUE);
	}
       else if (exeUtil->getExeUtilType() == ExeUtilExpr::HBASE_COPROC_AGGR_)
          root_tdb->setQueryType(ComTdbRoot::SQL_SELECT_NON_UNIQUE);
       else if (exeUtil->getExeUtilType() == ExeUtilExpr::HBASE_LOAD_)
       {
         root_tdb->setSubqueryType(ComTdbRoot::SQL_STMT_HBASE_LOAD);
       }
       else if (exeUtil->getExeUtilType() == ExeUtilExpr::HBASE_UNLOAD_)
       {
         root_tdb->setSubqueryType(ComTdbRoot::SQL_STMT_HBASE_UNLOAD);
       }
       else if (exeUtil->getExeUtilType() == ExeUtilExpr::LOB_EXTRACT_)
	 {
	   root_tdb->setSubqueryType(ComTdbRoot::SQL_STMT_LOB_EXTRACT);
	 }
       else if(exeUtil->getExeUtilType() == ExeUtilExpr::LOB_UPDATE_UTIL_)
         {
           root_tdb->setSubqueryType(ComTdbRoot::SQL_STMT_LOB_UPDATE_UTIL
); 
         }

      else if (exeUtil->isExeUtilQueryType())
	{
	   root_tdb->setQueryType(ComTdbRoot::SQL_EXE_UTIL);
	}
    }
  else if ((child(0)) &&
	   (child(0)->castToRelExpr()->getOperatorType() == REL_DDL))
    {
      DDLExpr *ddlExpr = (DDLExpr *)child(0)->castToRelExpr();
      
      if (ddlExpr->producesOutput())
        root_tdb->setQueryType(ComTdbRoot::SQL_EXE_UTIL);     
    }
  else if (generator->getBindWA()->hasCallStmts())
  {
    // In this version of the compiler we assume any statement that
    // contains UDRs is either a CALL statement.
    if (maxResultSets > 0)
      root_tdb->setQueryType(ComTdbRoot::SQL_CALL_WITH_RESULT_SETS);
    else
      root_tdb->setQueryType(ComTdbRoot::SQL_CALL_NO_RESULT_SETS);
  }
  else
  {
    OperatorTypeEnum currChildOper = 
      child(0)->castToRelExpr()->getOperatorType();
    
    if (currChildOper == REL_CONTROL_QUERY_DEFAULT)
    {
      root_tdb->setMayNotCancel(TRUE);
      ControlQueryDefault * cqd = 
        (ControlQueryDefault*)child(0)->castToRelExpr();
      if (cqd->dynamic())
      {
        if (cqd->getAttrEnum() == CATALOG)
          root_tdb->setQueryType(ComTdbRoot::SQL_SET_CATALOG); 
        else if (cqd->getAttrEnum() == SCHEMA) 
          root_tdb->setQueryType(ComTdbRoot::SQL_SET_SCHEMA); 
        else
          root_tdb->setQueryType(ComTdbRoot::SQL_CONTROL); 
      }
      else
        root_tdb->setQueryType(ComTdbRoot::SQL_CONTROL); 
    }
    else if ((currChildOper == REL_CONTROL_QUERY_SHAPE) ||
             (currChildOper == REL_CONTROL_TABLE))
    {
      root_tdb->setMayNotCancel(TRUE);
      root_tdb->setQueryType(ComTdbRoot::SQL_CONTROL);
    }
    else if (currChildOper == REL_TRANSACTION)
    {
      root_tdb->setMayNotCancel(TRUE);
      if (((RelTransaction*)child(0)->castToRelExpr())->getType() == SET_TRANSACTION_)
        root_tdb->setQueryType(ComTdbRoot::SQL_SET_TRANSACTION); 
    }
    else if (currChildOper == REL_SP_PROXY)
    {
      // This is a stored procedure result set
      root_tdb->setQueryType(ComTdbRoot::SQL_SP_RESULT_SET);
    }
    else if (currChildOper == REL_EXE_UTIL)
    {
      ExeUtilExpr * exeUtil = (ExeUtilExpr*)child(0)->castToRelExpr();
      if (exeUtil->getExeUtilType() == ExeUtilExpr::CREATE_TABLE_AS_)
	root_tdb->setQueryType(ComTdbRoot::SQL_INSERT_NON_UNIQUE);
    }
    else if (REL_EXPLAIN == currChildOper)
      root_tdb->setMayNotCancel(TRUE);
    else if (REL_SET_TIMEOUT == currChildOper)
      root_tdb->setMayNotCancel(TRUE);
    else if (REL_CONTROL_RUNNING_QUERY == currChildOper)
      root_tdb->setMayNotCancel(TRUE);
  }

  if (generator->isFastExtract())
  {
    root_tdb->setQueryType(ComTdbRoot::SQL_SELECT_UNLOAD);
  }

  if (child(0) && child(0)->castToRelExpr() && 
      child(0)->castToRelExpr()->getOperator().match(REL_ANY_HBASE))
    {
      RelExpr * childExpr = child(0)->castToRelExpr();
      OperatorTypeEnum currChildOper = childExpr->getOperatorType();
      
      if ((childExpr->getOperator().match(REL_ANY_HBASE_GEN_UPDATE)) &&
	  (NOT output_expr))
	{
	  GenericUpdate * gu = (GenericUpdate *)childExpr;
	  
	  if (gu->uniqueHbaseOper())
	    {
	      if (currChildOper == REL_HBASE_UPDATE)
		root_tdb->setQueryType(ComTdbRoot::SQL_UPDATE_UNIQUE);
	      else if (currChildOper == REL_HBASE_DELETE)
		root_tdb->setQueryType(ComTdbRoot::SQL_DELETE_UNIQUE);
	      else
		root_tdb->setQueryType(ComTdbRoot::SQL_INSERT_UNIQUE);
	    }
	  else
	    {
	      if (currChildOper == REL_HBASE_UPDATE)
		root_tdb->setQueryType(ComTdbRoot::SQL_UPDATE_NON_UNIQUE);
	      else if (currChildOper == REL_HBASE_DELETE)
		root_tdb->setQueryType(ComTdbRoot::SQL_DELETE_NON_UNIQUE);
	      else
		root_tdb->setQueryType(ComTdbRoot::SQL_INSERT_NON_UNIQUE);
	    }
	}
      else if (currChildOper == REL_HBASE_ACCESS)
	{
	  HbaseAccess * ha = (HbaseAccess *)childExpr;
	  if (ha->uniqueHbaseOper())
	    root_tdb->setQueryType(ComTdbRoot::SQL_SELECT_UNIQUE);
	  else
	    root_tdb->setQueryType(ComTdbRoot::SQL_SELECT_NON_UNIQUE);
	}
    }

  // To help determine if it is safe to suspend.
  if (child(0) && 
      child(0)->castToRelExpr())
  {
    OperatorTypeEnum currChildOper = 
        child(0)->castToRelExpr()->getOperatorType();
    if ((REL_DDL == currChildOper) ||
        (REL_TRANSACTION == currChildOper) ||
        (REL_EXE_UTIL == currChildOper))
      root_tdb->setMayAlterDb(TRUE);

    if (REL_LOCK == currChildOper)
      root_tdb->setSuspendMayHoldLock(TRUE);
  }

  if (generator->anySerialiableScan())
      root_tdb->setSuspendMayHoldLock(TRUE);
  
  root_tdb->setOdbcQuery(CmpCommon::getDefault(ODBC_PROCESS) == DF_ON);

  if (generator->getTolerateNonFatalError()) {
    root_tdb->setTolerateNonFatalError(TRUE);
    if (CmpCommon::getDefault(NOT_ATOMIC_FAILURE_LIMIT,0) == DF_SYSTEM)
      root_tdb->setNotAtomicFailureLimit(ComCondition::NO_LIMIT_ON_ERROR_CONDITIONS);
    else
      root_tdb->setNotAtomicFailureLimit(CmpCommon::getDefaultLong(NOT_ATOMIC_FAILURE_LIMIT));
  }

  if (generator->embeddedIUDWithLast1()) {
    root_tdb->setEmbeddedIUDWithLast1(TRUE);
  }

  if (generator->embeddedInsert()) {
    root_tdb->setEmbeddedInsert(TRUE);
  }

  if (containsLRU())
    {
      root_tdb->setLRUOperation(TRUE);
    }

  if (generator->aqrEnabled())
    root_tdb->setAqrEnabled(TRUE);

  if (generator->cantReclaimQuery())
    root_tdb->setCantReclaimQuery(TRUE);

    // if a transaction is needed at runtime to execute this query,
  // set that information in the root tdb. Generator synthesized
  // this information based on the kind of query or if START_XN
  // define was set.
  // Certain queries (insert, update, delete) ALWAYS require a transaction
  // at runtime.
  // After parser support for REPEATABLE ACCESS, etc, is in, this
  // information will come from the parse tree for scans.
  if (generator->isTransactionNeeded())
    {
      root_tdb->setTransactionReqd();

      if (generator->foundAnUpdate())
	{
	  if (generator->updAbortOnError() == TRUE)
	    {
	      // if transaction has to be aborted at runtime after an error,
	      // set that info in root_tdb.
	      root_tdb->setUpdAbortOnError(-1);
	    }
	  else if (generator->updPartialOnError() == TRUE)
	    {
	      root_tdb->setUpdPartialOnError(-1);
	    }
	  else if (generator->updErrorInternalOnError() == TRUE)
	    {
	      root_tdb->setUpdErrorOnError(-1);
	    }
	  else if (generator->updErrorOnError() == FALSE)
	    {
	      if (generator->updSavepointOnError() == TRUE)
		{
		  root_tdb->setUpdSavepointOnError(-1);
		}
	      else
		root_tdb->setUpdAbortOnError(-1);
	    }
	  else
	    root_tdb->setUpdErrorOnError(-1);
	}
      else
	{
	  root_tdb->setUpdErrorOnError(-1);
	}
    } // transactionNeeded

  if ((oltOptLean()) &&
      (doOltQryOpt))
    {
      if ((NOT root_tdb->getUpdAbortOnError()) &&
	  (NOT root_tdb->getUpdSavepointOnError()) &&
	  (NOT root_tdb->getUpdPartialOnError()) &&
	  (retryableStmt) &&
	  (NOT root_tdb->thereIsACompoundStatement()))
	{
	  root_tdb->setDoOltQueryOptLean(TRUE);

	  child_tdb->setDoOltQueryOptLean(TRUE);
	}
    }

  if (generator->dp2XnsEnabled())
    {
      root_tdb->setDp2XnsEnabled(generator->dp2XnsEnabled());
    }

  
  if (generator->processLOB()) {
     root_tdb->setProcessLOB(TRUE);
     root_tdb->setUseLibHdfs(CmpCommon::getDefault(USE_LIBHDFS) == DF_ON);
  } 

  // Self-referencing updates
  if (avoidHalloween_)
  {
    if (Generator::DP2LOCKS == generator->getHalloweenProtection())
    {
      // Plan was generated without resetting the generator's 
      // HalloweenProtectionType from DP2Locks, therefore we are
      // using DP2 locks, and cannot allow auto commit off.
      root_tdb->setCheckAutoCommit(TRUE);
    }
  }
  else if (CmpCommon::getDefault(AQR_WNR_DELETE_NO_ROWCOUNT) == DF_ON)
  {
    // Allow non-ACID AQR of NO ROLLBACK DELETE that may have changed 
    // target. Query type (DELETE vs others) and WNR will be evaluated
    // at runtime.
    root_tdb->setAqrWnrDeleteContinue(TRUE);
  }
  if (CmpCommon::getDefault(PSHOLD_CLOSE_ON_ROLLBACK) == DF_ON)
    root_tdb->setPsholdCloseOnRollback(TRUE);
  else
    root_tdb->setPsholdCloseOnRollback(FALSE);
  if (CmpCommon::getDefault(PSHOLD_UPDATE_BEFORE_FETCH) == DF_ON)
    root_tdb->setPsholdUpdateBeforeFetch(TRUE);
  else
    root_tdb->setPsholdUpdateBeforeFetch(FALSE);

  root_tdb->setAbendType(
    (Lng32) CmpCommon::getDefaultNumeric(COMP_INT_38) );

  double cpuLimitCheckFreq = CmpCommon::getDefaultNumeric(COMP_INT_48);
  if (cpuLimitCheckFreq > SHRT_MAX)
    cpuLimitCheckFreq = SHRT_MAX;
  root_tdb->setCpuLimitCheckFreq((short) cpuLimitCheckFreq);

  // Config query execution limits.
  Lng32 cpuLimit = (Lng32) CmpCommon::getDefaultNumeric(QUERY_LIMIT_SQL_PROCESS_CPU);
  if (cpuLimit > 0)
    root_tdb->setCpuLimit(cpuLimit);  

  if (CmpCommon::getDefault(QUERY_LIMIT_SQL_PROCESS_CPU_DEBUG) == DF_ON)
    root_tdb->setQueryLimitDebug();

  if (generator->inMemoryObjectDefn())
    root_tdb->setInMemoryObjectDefn(TRUE);
	
  if (CmpCommon::getDefault(READONLY_CURSOR) == DF_ON)
    root_tdb->setCursorType(SQL_READONLY_CURSOR);
  else
    root_tdb->setCursorType(SQL_UPDATABLE_CURSOR);
	
  if (CmpCommon::getDefault(WMS_QUERY_MONITORING) == DF_ON)
    root_tdb->setWmsMonitorQuery(TRUE);
  else
    root_tdb->setWmsMonitorQuery(FALSE);

  if (CmpCommon::getDefault(WMS_CHILD_QUERY_MONITORING) == DF_ON)
    root_tdb->setWmsChildMonitorQuery(TRUE);
  else
    root_tdb->setWmsChildMonitorQuery(FALSE);

  if (hdfsAccess())
    root_tdb->setHdfsAccess(TRUE);

  if(generator->hiveAccess())
    root_tdb->setHiveAccess(TRUE);

  root_tdb->setBmoMemoryLimitPerNode(ActiveSchemaDB()->getDefaults().getAsDouble(BMO_MEMORY_LIMIT_PER_NODE_IN_MB));
  root_tdb->setEstBmoMemoryPerNode(generator->getTotalBMOsMemoryPerNode().value());

  Int32 numSikEntries = securityKeySet_.entries();
  if (numSikEntries > 0)
  {
    ComSecurityKey * sikValues = new (space) ComSecurityKey[numSikEntries];

    for (Int32 sv = 0; sv < numSikEntries; sv++)
      sikValues[sv] = securityKeySet_[sv];

    SecurityInvKeyInfo * sikInfo = new (space) SecurityInvKeyInfo(
                                     numSikEntries, sikValues); 
    root_tdb->setSikInfo(sikInfo);
  }

  if (!generator->explainDisabled())
    {
      // finish up EXPLAIN
      ExplainTuple *rootExplainTuple =
	addExplainInfo(root_tdb, 0, 0, generator);
      explainDesc->setExplainTreeRoot(rootExplainTuple);

      ExplainTuple *childExplainTuple = generator->getExplainTuple();

      rootExplainTuple->child(0) = childExplainTuple;
      if(childExplainTuple)
	{
	  childExplainTuple->setParent(rootExplainTuple);
	  rootExplainTuple->setChildSeqNum(
	       0,
	       childExplainTuple->getSeqNum());
	}

      generator->setExplainTuple(rootExplainTuple);
    }

  // Generate a list of scratch file options
  exFragDir->setScratchFileOptions(genScratchFileOptions(generator));

  // move ESP nodemask into frag dir
  exFragDir->setNodeMask((ULng32) getDefault(PARALLEL_ESP_NODEMASK));

  // generate the partition input data descriptor from the compile-time
  // partitioning attributes
  ExPartInputDataDesc **partInputDataDescs =
    new(generator->wHeap()) ExPartInputDataDesc *[compFragDir->entries()];
  ExEspNodeMap **nodeMap =
    new(generator->wHeap()) ExEspNodeMap *[compFragDir->entries()];
  for (i = 0; i < compFragDir->entries(); i++)
    {
      if (compFragDir->getPartitioningFunction(i) != NULL)
	{
	  // This fragment has partitioning info, generate it
	  ((PartitioningFunction *) compFragDir->getPartitioningFunction(i))->
	    codeGen(generator,
		    compFragDir->getPartInputDataLength(i));
	  partInputDataDescs[i] =
	    (ExPartInputDataDesc *) (generator->getGenObj());
	  NodeMap::codeGen(compFragDir->getPartitioningFunction(i),
			   compFragDir->getNumESPs(i),
			   generator);
	  nodeMap[i] = (ExEspNodeMap *) (generator->getGenObj());
	}
      else
        {
	  partInputDataDescs[i] = NULL;
          nodeMap[i] = NULL;
        }
    }

  // remove maptable for child tree
  generator->removeAll(map_table);

  // remove my map table
  generator->removeLast();
  generator->setMapTable(NULL);

  // move data entry by entry from the generator's copy into the executor copy
  Lng32 offset = 0;
  Lng32 currLength;
  Lng32 compressThreshold = getDefault(FRAG_COMPRESSION_THRESHOLD);
  NABoolean anyEspFragments = FALSE;

  for (i = 0; i < compFragDir->entries(); i++)
    {
      // translate fragment type enums
      ExFragDir::ExFragEntryType runTimeType = ExFragDir::MASTER;
      currLength = compFragDir->getFragmentLength(i);
      compilerStatsInfo->totalFragmentSize() += currLength;
      switch (compFragDir->getType(i))
	{
	case FragmentDir::MASTER:
	  runTimeType = ExFragDir::MASTER;
	  compilerStatsInfo->masterFragmentSize() += currLength;
	  break;
	case FragmentDir::DP2:
	  runTimeType = ExFragDir::DP2;
	  compilerStatsInfo->dp2FragmentSize() += currLength;
	  break;
	case FragmentDir::ESP:
	  runTimeType = ExFragDir::ESP;
          anyEspFragments = TRUE;
	  compilerStatsInfo->espFragmentSize() += currLength;
	  break;
	case FragmentDir::EXPLAIN:
	  runTimeType = ExFragDir::EXPLAIN;
	  compilerStatsInfo->masterFragmentSize() += currLength;
	  break;
	default:
	  ABORT("Internal error, invalid fragment type");
	}

      // take the pointer of the top-level object in this fragment and
      // convert it to a fragment-relative offset
      Lng32 offsetOfTopNode = compFragDir->getSpace(i)->
	convertToOffset((char *)(compFragDir->getTopNode(i)));

      // now set the values of the previously allocated directory entry

      NABoolean mlimitPerNode = CmpCommon::getDefaultLong(BMO_MEMORY_LIMIT_PER_NODE_IN_MB) > 0;
      UInt16 BMOsMemoryUsage = 0;
      if (mlimitPerNode == TRUE)
        BMOsMemoryUsage = (UInt16)compFragDir->getBMOsMemoryUsage(i);
      else if (compFragDir->getNumBMOs(i) > 1 ||
               (compFragDir->getNumBMOs(i) == 1 && CmpCommon::getDefault(EXE_SINGLE_BMO_QUOTA) == DF_ON))
        BMOsMemoryUsage = (UInt16)CmpCommon::getDefaultLong(EXE_MEMORY_AVAILABLE_IN_MB);

      exFragDir->set(i,
		     runTimeType,
		     (ExFragId) compFragDir->getParentId(i),
		     offset,
		     currLength,
		     -offsetOfTopNode,
		     partInputDataDescs[i],
		     nodeMap[i],
		     compFragDir->getNumESPs(i),
		     compFragDir->getEspLevel(i),
		     compFragDir->getNeedsTransaction(i),
                     (compressThreshold > 0 &&
                      runTimeType == ExFragDir::ESP &&
                      compressThreshold <= compFragDir->getNumESPs(i))?
                       TRUE: FALSE,  // DP2 fragment will be compressed later
                                     // if parent ESP fragment is compressed
                                     // see executor/ex_frag_rt.cpp
		     compFragDir->getSoloFragment(i),
		     BMOsMemoryUsage,
		     compFragDir->getNumBMOs(i) > 0
                     );
      offset += currLength;
    } // for each fragment

  compilerStatsInfo->totalFragmentSize() /= 1024;
  compilerStatsInfo->masterFragmentSize() /= 1024;
  compilerStatsInfo->espFragmentSize() /= 1024;
  compilerStatsInfo->dp2FragmentSize() /= 1024;
  compilerStatsInfo->collectStatsType() = generator->collectStatsType();
  compilerStatsInfo->udr() = noOfUdrs;
  compilerStatsInfo->ofMode() = generator->getOverflowMode();
  compilerStatsInfo->ofSize() = 0;
  compilerStatsInfo->bmo() = generator->getTotalNumBMOs();
  compilerStatsInfo->queryType() = (Int16)root_tdb->getQueryType();
  compilerStatsInfo->subqueryType() = (Int16)root_tdb->getSubqueryType();
  compilerStatsInfo->bmoMemLimitPerNode() = root_tdb->getBmoMemoryLimitPerNode();
  compilerStatsInfo->estBmoMemPerNode() = root_tdb->getEstBmoMemoryPerNode();

  NADELETEBASIC(partInputDataDescs, generator->wHeap());
  NADELETEBASIC(nodeMap, generator->wHeap());

  // Genesis 10-990114-6293:
  // don't recompile a SELECT query if transmode changes to READ ONLY.
  if (readOnlyTransIsOK()) root_tdb->setReadonlyTransactionOK();

  // Inserts into non-audited indexes do not need to run in a transaction,
  // if one does not exist. If one exists (which is the case during a create
  // index operation), need to pass transid to all ESPs during the load
  // index phase, otherwise they will get error 73s returned when they open
  // the index. Store this information in the root TDB, so that the transaction
  // can be passed to ESPs if needed.  Dp2Insert::codeGen has set this
  // generator flag.

  NABoolean recompWarn =
    (CmpCommon::getDefault(RECOMPILATION_WARNINGS) == DF_ON);
  if (recompWarn) root_tdb->setRecompWarn();

  // Set the FROM_SHOWPLAN flag if the statement is from a showplan
  const NAString * val =
    ActiveControlDB()->getControlSessionValue("SHOWPLAN");
  if ( !(childOperType_ == REL_CONTROL_SESSION)
       && (val) && (*val == "ON") )
    root_tdb->setFromShowplan();

  if (CmpCommon::getDefault(EXE_LOG_RETRY_IPC) == DF_ON)
    root_tdb->setLogRetriedIpcErrors(TRUE);

  if (anyEspFragments)
  {
    if (generator->getBindWA()->queryCanUseSeaMonster() &&
        generator->getQueryUsesSM())
      root_tdb->setQueryUsesSM();
  }

  generator->setGenObj(this, root_tdb);

  return 0;

} // RelRoot::codeGen()

short Sort::generateTdb(Generator * generator,
                        ComTdb * child_tdb,
                        ex_expr * sortKeyExpr,
                        ex_expr * sortRecExpr,
                        ULng32 sortKeyLen,
                        ULng32 sortRecLen,
                        ULng32 sortPrefixKeyLen,
                        ex_cri_desc * given_desc,
                        ex_cri_desc * returned_desc,
                        ex_cri_desc * work_cri_desc,
                        Lng32 saveNumEsps,
                        ExplainTuple *childExplainTuple,
                        NABoolean resizeCifRecord,
                        NABoolean considerBufferDefrag,
                        NABoolean operatorCIF)
{

  NADefaults &defs = ActiveSchemaDB()->getDefaults();

  ULng32 numBuffers = (ULng32)getDefault(GEN_SORT_NUM_BUFFERS);
  
  CostScalar bufferSize = getDefault(GEN_SORT_MAX_BUFFER_SIZE);

  UInt32 bufferSize_as_uint32 = 
    (UInt32)(MINOF(CostScalar(UINT_MAX), bufferSize)).getValue(); 

  // allocate buffer to hold atlease one row
  bufferSize_as_uint32 = MAXOF(bufferSize_as_uint32, sortRecLen);

  GenAssert(sortRecLen <= bufferSize_as_uint32, 
      "Record Len greater than GEN_SORT_MAX_BUFFER_SIZE");
  
  ComTdbSort * sort_tdb = 0;
  // always start with quick sort. Sort will switch to
  // replacement sort in case of overflow at runtime.
  SortOptions *sort_options = new(generator->getSpace()) SortOptions();

  Lng32 max_num_buffers = (Lng32)numBuffers;
  NAString tmp;
  CmpCommon::getDefault(SORT_ALGO, tmp, -1);
  if(tmp == "HEAP")
    sort_options->sortType() = SortOptions::ITER_HEAP;
  else if(tmp == "REPSEL")
    sort_options->sortType() = SortOptions::REPLACEMENT_SELECT;
  else if(tmp == "IQS")
    sort_options->sortType() = SortOptions::ITER_QUICK;
  else if(tmp == "QS")
    sort_options->sortType() = SortOptions::QUICKSORT;
  max_num_buffers = (Lng32)getDefault(GEN_SORT_MAX_NUM_BUFFERS);
  sort_options->internalSort() = TRUE;

  unsigned short threshold = (unsigned short) CmpCommon::getDefaultLong(SCRATCH_FREESPACE_THRESHOLD_PERCENT);
  sort_options->scratchFreeSpaceThresholdPct() = threshold;
  sort_options->sortMaxHeapSize() = (short)getDefault(SORT_MAX_HEAP_SIZE_MB);
  sort_options->mergeBufferUnit() = (short)getDefault(SORT_MERGE_BUFFER_UNIT_56KB);
 
  //512kb default size initiliazed in sort_options.
  if(sortRecLen >= sort_options->scratchIOBlockSize())
  {
    Int32 maxScratchIOBlockSize = (Int32)getDefault(SCRATCH_IO_BLOCKSIZE_SORT_MAX);
    // allocate space for atleast one row.
    maxScratchIOBlockSize = MAXOF(maxScratchIOBlockSize, sortRecLen);

    GenAssert(sortRecLen <= maxScratchIOBlockSize, 
         "sortRecLen is greater than SCRATCH_IO_BLOCKSIZE_SORT_MAX");
    sort_options->scratchIOBlockSize() = MINOF(sortRecLen * 128, maxScratchIOBlockSize);
  }
  
  sort_options->scratchIOVectorSize() = (Int16)getDefault(SCRATCH_IO_VECTOR_SIZE_SORT);

  if (CmpCommon::getDefault(EXE_BMO_SET_BUFFERED_WRITES) == DF_ON)
    sort_options->setBufferedWrites(TRUE);
  if (CmpCommon::getDefault(EXE_DIAGNOSTIC_EVENTS) == DF_ON)
    sort_options->setLogDiagnostics(TRUE);
  
  // Disable Compiler Hints checks if: CQD is ON or if SYSTEM - only for HDD
  if (
      (CmpCommon::getDefault(EXE_BMO_DISABLE_CMP_HINTS_OVERFLOW_SORT) == DF_ON)
      ||
      (
       ((generator->getOverflowMode()== ComTdb::OFM_DISK) ||
       (generator->getOverflowMode()== ComTdb::OFM_MMAP)) 
       && 
       (CmpCommon::getDefault(EXE_BMO_DISABLE_CMP_HINTS_OVERFLOW_SORT) 
        == DF_SYSTEM )
      )
     )
	 sort_options->setDisableCmpHintsOverflow(TRUE);
	 
  if (CmpCommon::getDefault(EXE_BMO_DISABLE_OVERFLOW) == DF_ON)
    sort_options->dontOverflow() = TRUE;
  if (CmpCommon::getDefault(SORT_INTERMEDIATE_SCRATCH_CLEANUP) == DF_ON)
    sort_options->setIntermediateScratchCleanup(TRUE);

  sort_options->setResizeCifRecord(resizeCifRecord);
  sort_options->setConsiderBufferDefrag(considerBufferDefrag);

  short memoryQuotaMB = 0;
  double memoryQuotaRatio;
  Lng32 numStreams;
  double bmoMemoryUsagePerNode = generator->getEstMemPerNode(getKey(), numStreams);

  if (CmpCommon::getDefault(SORT_MEMORY_QUOTA_SYSTEM) != DF_OFF)
  {
    // The CQD EXE_MEM_LIMIT_PER_BMO_IN_MB has precedence over the mem quota sys
    memoryQuotaMB = (UInt16)defs.getAsDouble(EXE_MEM_LIMIT_PER_BMO_IN_MB);

    if (memoryQuotaMB > 0) {
     sort_options->memoryQuotaMB() = memoryQuotaMB;
    } else {
  
      UInt16 numBMOsInFrag = (UInt16)generator->getFragmentDir()->getNumBMOs();
  
      // Apply quota system if either one the following two is true:
      //   1. the memory limit feature is turned off and more than one BMOs
      //   2. the memory limit feature is turned on
      
      NABoolean mlimitPerNode = defs.getAsDouble(BMO_MEMORY_LIMIT_PER_NODE_IN_MB) > 0;
  
      if ( mlimitPerNode || numBMOsInFrag > 1 ||
         (numBMOsInFrag == 1 && CmpCommon::getDefault(EXE_SINGLE_BMO_QUOTA) == DF_ON)) {
  
          memoryQuotaMB = (short)
             computeMemoryQuota(generator->getEspLevel() == 0,
                                mlimitPerNode,
                                generator->getBMOsMemoryLimitPerNode().value(),
                                generator->getTotalNumBMOs(),
                                generator->getTotalBMOsMemoryPerNode().value(),
                                numBMOsInFrag, 
                                bmoMemoryUsagePerNode,
                                numStreams,
                                memoryQuotaRatio
                               );
  
      }            
      Lng32 sortMemoryLowbound = defs.getAsLong(BMO_MEMORY_LIMIT_LOWER_BOUND_SORT);
      Lng32 memoryUpperbound = defs.getAsLong(BMO_MEMORY_LIMIT_UPPER_BOUND);
  
      if ( memoryQuotaMB < sortMemoryLowbound ) {
         memoryQuotaMB = (short)sortMemoryLowbound;
         memoryQuotaRatio = BMOQuotaRatio::MIN_QUOTA;
      }
      else if (memoryQuotaMB >  memoryUpperbound)
         memoryQuotaMB = memoryUpperbound;
    }
  }

   //BMO settings. By Default set this value to max available 
   //irrespective of quota is enabled or disabled. Sort at run time
   //will manage to check for quota and available physical memory
   //before consuming memory. Note that if memoryQuota is set zero,
   //sort may not do physical memory or memory pressure checks.
  if ( memoryQuotaMB <= 0  && 
       ! sort_options->disableCmpHintsOverflow() ) // compiler hints enabled
   {
     memoryQuotaMB = (UInt16)defs.getAsLong(EXE_MEMORY_AVAILABLE_IN_MB);
   }
   sort_options->memoryQuotaMB() = memoryQuotaMB;

  if(generator->getOverflowMode() == ComTdb::OFM_SSD )
    sort_options->bmoMaxMemThresholdMB() = (UInt16)defs.getAsLong(SSD_BMO_MAX_MEM_THRESHOLD_IN_MB);
  else
    sort_options->bmoMaxMemThresholdMB() = (UInt16)defs.getAsLong(EXE_MEMORY_AVAILABLE_IN_MB);

   sort_options->pressureThreshold() = 
                  (short)getDefault(GEN_MEM_PRESSURE_THRESHOLD);
   
  short sortGrowthPercent = 
    RelExpr::bmoGrowthPercent(getEstRowsUsed(), getMaxCardEst());

  sort_tdb = new(generator->getSpace())
    ComTdbSort(sortKeyExpr,
	       sortRecExpr,
	       sortKeyLen,
	       sortRecLen,
	       sortPrefixKeyLen,
	       returned_desc->noTuples() - 1,
	       child_tdb,
	       given_desc,
	       returned_desc,
	       work_cri_desc,

	       // if sort input is from top, switch the UP and DOWN queue
	       // sizes
	       (sortFromTop()
		? (queue_index)getDefault(GEN_SORT_SIZE_UP)
		: (queue_index)getDefault(GEN_SORT_SIZE_DOWN)),
	       (queue_index)getDefault(GEN_SORT_SIZE_UP),
	       (Cardinality) (getInputCardinality() * getEstRowsUsed()).getValue(),
	       numBuffers,
	       bufferSize_as_uint32,
	       max_num_buffers,
	       sort_options,
           sortGrowthPercent);
  sort_tdb->setCollectNFErrors(this->collectNFErrors());

  sort_tdb->setSortFromTop(sortFromTop());
  sort_tdb->setOverflowMode(generator->getOverflowMode());
  sort_tdb->setTopNSortEnabled(CmpCommon::getDefault(GEN_SORT_TOPN) == DF_ON);
  sort_tdb->setBmoQuotaRatio(memoryQuotaRatio);
  
  if (generator->getUserSidetreeInsert())
    sort_tdb->setUserSidetreeInsert(TRUE);

  if (getTolerateNonFatalError() == RelExpr::NOT_ATOMIC_) 
    sort_tdb->setTolerateNonFatalError(TRUE);

  sort_tdb->setCIFON(operatorCIF);

  generator->initTdbFields(sort_tdb);

  double sortMemEst = generator->getEstMemPerInst(getKey());
  sort_tdb->setEstimatedMemoryUsage(sortMemEst / 1024);
  generator->addToTotalEstimatedMemory(sortMemEst);

  if (sortPrefixKeyLen > 0)
    ((ComTdbSort *)sort_tdb)->setPartialSort(TRUE);  // do partial sort

  if(CmpCommon::getDefaultLong(SORT_REC_THRESHOLD) > 0)
      ((ComTdbSort *)sort_tdb)->setMinimalSortRecs(CmpCommon::getDefaultLong(SORT_REC_THRESHOLD));

  sort_tdb->setMemoryContingencyMB(getDefault(PHY_MEM_CONTINGENCY_MB));
  float bmoCtzFactor;
  defs.getFloat(BMO_CITIZENSHIP_FACTOR, bmoCtzFactor);
  sort_tdb->setBmoCitizenshipFactor((Float32)bmoCtzFactor);
  sort_tdb->setSortMemEstInKBPerNode(bmoMemoryUsagePerNode /1024);
  if (sortNRows())
     sort_tdb->setTopNThreshold(defs.getAsLong(GEN_SORT_TOPN_THRESHOLD));
  if (!generator->explainDisabled()) {
    generator->setExplainTuple(
       addExplainInfo(sort_tdb, childExplainTuple, 0, generator));
  }

  // set the new up cri desc.
  generator->setCriDesc(returned_desc, Generator::UP);

  generator->setGenObj(this, sort_tdb);

  // reset the expression generation flag to generate float validation pcode
  generator->setGenNoFloatValidatePCode(FALSE);

  return 0;
}

//////////////////////////////////////////////////////////////
//
// Sort::codeGen()
//
/////////////////////////////////////////////////////////
short Sort::codeGen(Generator * generator)
{
  ExpGenerator * exp_gen = generator->getExpGenerator();
  Space * space = generator->getSpace();

   ////////////////////////////////////////////////////////////////////////
  //
  // Layout at this node:
  //
  // |-------------------------------------------------|
  // | input data  |  Sorted data  | child's data      |
  // | ( I tupps ) |  ( 1 tupp )   | ( C tupps )       |
  // |-------------------------------------------------|
  // <-- returned row to parent --->
  // <------------ returned row from child ------------>
  //
  // input data:        the atp input to this node by its parent.
  // sorted data:       tupp where the sorted row is.
  //                    this data is accessed by the key and by the data
  //                    separately.
  //                    The key data is in SQLMX_KEY_FORMAT and the data
  //                    will be in either internal or exploded format.
  // child data:        tupps appended by the child
  //
  // Input to child:    I + 1 tupps
  //
  // Tupps returned from child are only used to create the
  // sorted data. They are not returned to parent.
  //
  /////////////////////////////////////////////////////////////////////////
  // Tupps returned from child are only used to create the
  // sorted data. They are not returned to parent.
  //
  /////////////////////////////////////////////////////////////////////////

  MapTable * last_map_table = generator->getLastMapTable();

  ex_cri_desc * given_desc
    = generator->getCriDesc(Generator::DOWN);

  ex_cri_desc * returned_desc
    = new(space) ex_cri_desc(given_desc->noTuples() + 1, space);

  Int32 work_atp = 1; // temps
  Int32 work_atp_index = 2;  // where the result row will be
  ex_cri_desc * work_cri_desc = new(space) ex_cri_desc(3, space);

  //All the records in the table will not be processed by a single sort 
  //instance if multiple sort instances are involved within ESPs.
  Lng32 saveNumEsps = generator->getNumESPs();
  
  if (sortFromTop())
    generator->setCriDesc(returned_desc, Generator::DOWN);

  // generate code for child tree
  child(0)->codeGen(generator);
  
  //This value is set inside generator by my parent exchange node,
  //as a global variable. Reset the saveNumEsps value back into
  //generator since codegen of my children exchange nodes may have
  //changed it. Resetting is performed here so the codegen of right
  //child nodes of my parent gets the proper value.  
  generator->setNumESPs(saveNumEsps);
  
  ComTdb * child_tdb = (ComTdb *)(generator->getGenObj());
  ExplainTuple *childExplainTuple = generator->getExplainTuple();

  // Before generating any expression for this node, set the
  // the expression generation flag not to generate float
  // validation PCode. This is to speed up PCode evaluation
  generator->setGenNoFloatValidatePCode(TRUE);

  // generate an expression to create the input row
  // to be sent to sort.
  // The input row consists of:
  //   n + m values
  // where, n is the number of encoded key columns.
  //        m is the total number of column values.
  // At runtime, a contiguous row of n + m columns is created
  // and then given to sort.
  // sort prefix key columns are indexed from 0 to k where k < n.


  // The data within the Sort buffer will be contiguous in the format
  // | encoded keys | returned column values |
  // ----------------------------------------
  // The keys will be in key format.
  // The returned column values will be in Exploded or Compressed internal
  // format.

  // generate the key encode value id list used for sorting
  UInt32  sortKeyLen = 0;
  UInt32  sortPrefixKeyLen = 0;
  Int32   prefixKeyCnt = getPrefixSortKey().entries();
  ValueIdList sortKeyValIdList;
  CollIndex   sortKeyListIndex;
  CollIndex   sortRecListIndex;
  for (sortKeyListIndex = 0;
       sortKeyListIndex < getSortKey().entries();
       sortKeyListIndex++)
    {
      ItemExpr * skey_node =
        ((getSortKey()[sortKeyListIndex]).getValueDesc())->getItemExpr();

      short desc_flag = FALSE;

      if (skey_node->getOperatorType() == ITM_INVERSE)
	{
	  desc_flag = TRUE;
	}

      if (skey_node->getValueId().getType().getVarLenHdrSize() > 0)
	{
	  // Explode varchars by moving them to a fixed field
	  // whose length is equal to the max length of varchar.
	  // 5/8/98: add support for VARNCHAR

          const CharType& char_type =
		(CharType&)(skey_node->getValueId().getType());

          //no cast to fixed char in the case of collation (Czech) 
          if (!CollationInfo::isSystemCollation(char_type.getCollation()))
	  {
	    skey_node =
	      new(generator->wHeap())
		Cast (skey_node,
		      (new(generator->wHeap())
			 SQLChar(generator->wHeap(),
                          CharLenInfo(char_type.getStrCharLimit(), char_type.getDataStorageSize()),
			  char_type.supportsSQLnull(),
			  FALSE, FALSE, FALSE,
			  char_type.getCharSet(),
			  char_type.getCollation(),
			  char_type.getCoercibility()
				)
		     )
		    );
	  }
	}

      CompEncode * enode
	= new(generator->wHeap()) CompEncode(skey_node, desc_flag);

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

      sortKeyLen += enode->getValueId().getType().getTotalSize();

      sortKeyValIdList.insert(enode->getValueId());

      if (sortKeyListIndex < (CollIndex) prefixKeyCnt)
        // sort key length is the prefix sort key length
        // Note we need do this assignment only once. Need a better way
        sortPrefixKeyLen = sortKeyLen;
    }
/*
  // Generate the key encode expression ...
  ex_expr * sortKeyExpr = 0;
  exp_gen->generateContiguousMoveExpr(sortKeyValIdList,
                                      0,     // no conv nodes
                                      work_atp, work_atp_index,
                                      ExpTupleDesc::SQLMX_KEY_FORMAT,
                                      sortKeyLen, &sortKeyExpr,
                                      0,  // no tupp descr
                                      ExpTupleDesc::SHORT_FORMAT);
*/
  // Now generate the returned column value value id list that moves the input
  // data into the sort input buffer using convert nodes.
  ValueIdList sortRecValIdList;
  ValueId     valId;
  for (valId = getGroupAttr()->getCharacteristicOutputs().init();
       getGroupAttr()->getCharacteristicOutputs().next(valId);
       getGroupAttr()->getCharacteristicOutputs().advance(valId))
    {
      // add the convert node
      Convert * convNode = new(generator->wHeap())Convert(valId.getItemExpr());
      convNode->bindNode(generator->getBindWA());
      sortRecValIdList.insert(convNode->getValueId());
    }

  UInt32 sortRecLen = 0;
  ex_expr * sortRecExpr = 0;
  ex_expr * sortKeyExpr = 0;
  ExpTupleDesc * tuple_desc = 0;


  // contains the value ids that are being returned (the sorted values)
  MapTable * returnedMapTable = 0;
  ExpTupleDesc::TupleDataFormat tupleFormat = generator->getInternalFormat();

  // resizeCifRecord indicator that tells us whether we need to resize the CIF row or not
  // if CIF is not used then no resizing is done
  // if CIF is used the based on some logic that will be defined we determine whether we need
  // to resize the row or not
  NABoolean resizeCifRecord = FALSE;
  // Sometimes only the key value id list has entries and there are no
  // additional characteristic outputs.
  // This happens when Sort is used as a blocking operator for NAR (Non Atomic
  // Rowsets).
  NABoolean bmo_affinity = (CmpCommon::getDefault(COMPRESSED_INTERNAL_FORMAT_BMO_AFFINITY) == DF_ON);
  NABoolean considerBufferDefrag = FALSE;

  if (sortRecValIdList.entries() > 0)
  {
    if (! bmo_affinity &&
        getCachedTupleFormat() != ExpTupleDesc::UNINITIALIZED_FORMAT &&
        CmpCommon::getDefault(COMPRESSED_INTERNAL_FORMAT) == DF_SYSTEM &&
        CmpCommon::getDefault(COMPRESSED_INTERNAL_FORMAT_BMO) == DF_SYSTEM)
    {
      resizeCifRecord = getCachedResizeCIFRecord();
      tupleFormat = getCachedTupleFormat();
      considerBufferDefrag = getCachedDefrag() && resizeCifRecord;
    }
    else
    {
      //apply heuristic to determine the tuple format and whether we need to resize the row or not
     tupleFormat = determineInternalFormat( sortRecValIdList,
                                            this,
                                            resizeCifRecord,
                                            generator,
                                            bmo_affinity,
                                            considerBufferDefrag);
     considerBufferDefrag = considerBufferDefrag && resizeCifRecord;
    }

  }


  if (tupleFormat == ExpTupleDesc::SQLMX_ALIGNED_FORMAT)
  {
    exp_gen->generateContiguousMoveExpr(sortKeyValIdList,
                                         0,     // no conv nodes
                                         work_atp, work_atp_index,
                                         ExpTupleDesc::SQLMX_KEY_FORMAT,
                                         sortKeyLen, &sortKeyExpr,
                                         0,  // no tupp descr
                                         ExpTupleDesc::SHORT_FORMAT);

    exp_gen->generateContiguousMoveExpr(sortRecValIdList,
                                        0,   // no convert nodes
                                        work_atp, work_atp_index,
                                        tupleFormat,
                                        sortRecLen, &sortRecExpr,
                                        &tuple_desc, ExpTupleDesc::SHORT_FORMAT);
    sortRecLen += sortKeyLen;
    if (resizeCifRecord)
    {
      // with CIF if we need to resize the rows then we need to keep track of the length
      // of the row with the row itself
      // in this case the allocated space for the row will be as folows
      // |row size --(4 bytes)|sort key (sortkeyLen)| data (data length --may be variable)  |
      // ------------------------------------
      sortRecLen += sizeof(UInt32);
    }
  }
  else
  {
    CMPASSERT(resizeCifRecord == FALSE);
    sortKeyValIdList.insertSet(sortRecValIdList);
    exp_gen->generateContiguousMoveExpr(sortKeyValIdList,
                                          0,     // no conv nodes
                                          work_atp, work_atp_index,
                                          ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
                                          sortRecLen, &sortRecExpr,
                                          &tuple_desc,
                                          ExpTupleDesc::SHORT_FORMAT);

  }


  // add in the total area for the keys since we generated this separately
  // and ensure the size is a factor of 8 so the data aligns correctly


  // describe the returned row
  returned_desc->setTupleDescriptor((UInt16)returned_desc->noTuples() - 1,
                                    tuple_desc);

  returnedMapTable = generator->appendAtEnd(); // allocates a new map table
  generator->unlinkLast();

  // Add the returned values to the map table. We get the returned value
  // value id from the char outputs and the item expr from the sort record
  // value id list, starting with the first item expr added to the sort
  // record value id list by the for loop immediately preceding this one.
  sortRecListIndex = 0;
  for (valId = getGroupAttr()->getCharacteristicOutputs().init();
       getGroupAttr()->getCharacteristicOutputs().next(valId);
       getGroupAttr()->getCharacteristicOutputs().advance(valId))
    {
      // ????????????The first time through this loop, sortRecListIndex will point
      // to the first return value convert node. This is because we
      // stopped incrementing the sortRecListIndex after the last sort
      // key was added and we did not increment it when we added the
      // return value convert nodes.
      Attributes *attr =
        generator->getMapInfo(sortRecValIdList[sortRecListIndex++])->getAttr();

      // ...add it to the new map table as if it belonged to
      // the original value id...
      MapInfo * mi =
	generator->addMapInfoToThis(returnedMapTable, valId, attr);

      // All reference to the returned values from this point on
      // will be at atp = 0, atp_index = last entry in returned desc.
      // Offset will be the same as in the workAtp.
      mi->getAttr()->setAtp(0);
      mi->getAttr()->setAtpIndex(returned_desc->noTuples() - 1);

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

    }

  // remove all appended map tables and return the returnedMapTable
  generator->removeAll(last_map_table);
  generator->appendAtEnd(returnedMapTable);

  short rc =
    generateTdb(generator,
		child_tdb,
		sortKeyExpr,
                sortRecExpr,
		sortKeyLen,
		sortRecLen,
		sortPrefixKeyLen,
		given_desc,
		returned_desc,
		work_cri_desc,
		saveNumEsps,
		childExplainTuple,
		resizeCifRecord,
		considerBufferDefrag,
		(tupleFormat == ExpTupleDesc::SQLMX_ALIGNED_FORMAT));

  return rc;
}


ExpTupleDesc::TupleDataFormat Sort::determineInternalFormat( const ValueIdList & valIdList,
                                                                   RelExpr * relExpr,
                                                                   NABoolean & resizeCifRecord,
                                                                   Generator * generator,
                                                                   NABoolean bmo_affinity,
                                                                   NABoolean & considerBufferDefrag)
{

  RelExpr::CifUseOptions bmo_cif = RelExpr::CIF_SYSTEM;


  if (CmpCommon::getDefault(COMPRESSED_INTERNAL_FORMAT_BMO) == DF_OFF)
  {
    bmo_cif = RelExpr::CIF_OFF;
  }
  else
  if (CmpCommon::getDefault(COMPRESSED_INTERNAL_FORMAT_BMO) == DF_ON)
  {
    bmo_cif = RelExpr::CIF_ON;
  }

  //CIF_SYSTEM

  UInt32 sortKeyLength = getSortKey().getRowLength();
  return generator->determineInternalFormat(valIdList, 
                                            relExpr, 
                                            resizeCifRecord, 
                                            bmo_cif,
                                            bmo_affinity,
                                            considerBufferDefrag,
                                            sortKeyLength);

}
//////////////////////////////////////////////////////////////
//
// SortFromTop::codeGen()
//
/////////////////////////////////////////////////////////
short SortFromTop::codeGen(Generator * generator)
{
  ExpGenerator * exp_gen = generator->getExpGenerator();
  Space * space = generator->getSpace();

  MapTable * last_map_table = generator->getLastMapTable();

  ex_cri_desc * given_desc
    = generator->getCriDesc(Generator::DOWN);

  // no tuples returned from this operator
  ex_cri_desc * returned_desc = given_desc;

  // child gets one sorted row created in this operator.
  ex_cri_desc * child_desc
    = new(space) ex_cri_desc(given_desc->noTuples() + 1, space);

  Int32 work_atp = 1; // temps
  Int32 work_atp_index = 2;  // where the result row will be
  ex_cri_desc * work_cri_desc = new(space) ex_cri_desc(3, space);

  //All the records in the table will not be processed by a single sort 
  //instance if multiple sort instances are involved within ESPs.
  Lng32 saveNumEsps = generator->getNumESPs();

  generator->setCriDesc(child_desc, Generator::DOWN);

  // Before generating any expression for this node, set the
  // the expression generation flag not to generate float
  // validation PCode. This is to speed up PCode evaluation
  generator->setGenNoFloatValidatePCode(TRUE);

  MapTable *myMapTable = generator->appendAtEnd();
  
  ULng32 sort_rec_len = 0;
  ULng32 sort_key_len = 0;
  ex_expr * sort_rec_expr = 0;
  ex_expr * sort_key_expr = 0;
  ExpTupleDesc * tuple_desc = 0;

  ValueIdList sortRecVIDlist;
  ValueIdList sortKeyVIDlist;
  CollIndex ii = 0;
  for (ii = 0; ii < getSortKey().entries(); ii++)
    {
      ItemExpr * skey_node =
        ((getSortKey()[ii]).getValueDesc())->getItemExpr();

      if (skey_node->getOperatorType() != ITM_INDEXCOLUMN)
	GenAssert(0, "Must be IndexColumn");

      IndexColumn * ic = (IndexColumn*)skey_node;
      NABoolean found = FALSE;
      CollIndex jj = 0;
      while ((NOT found) && (jj < getSortRecExpr().entries()))
	{
	  const ItemExpr *assignExpr = 
	    getSortRecExpr()[jj].getItemExpr();

	  ItemExpr * tgtCol = assignExpr->child(0)->castToItemExpr();
	  if (tgtCol->getOperatorType() != ITM_BASECOLUMN)
	    GenAssert(0, "Must be BaseColumn");

	  ValueId tgtValueId = tgtCol->getValueId();

	  ValueId srcValueId = 
	    assignExpr->child(1)->castToItemExpr()->getValueId();

	  ItemExpr * srcVal = assignExpr->child(1)->castToItemExpr();

	  if (ic->getNAColumn()->getColName() == 
	      ((BaseColumn*)tgtCol)->getNAColumn()->getColName())
	    {
	      found = TRUE;

	      //***TBD*** need to handle descnding. Get that from index desc.
	      short desc_flag = FALSE;
	      if (ic->getNAColumn()->getClusteringKeyOrdering() == DESCENDING)
		{
		  desc_flag = TRUE;
		}

	      if (skey_node->getValueId().getType().getVarLenHdrSize() > 0)
		{
		  // Explode varchars by moving them to a fixed field
		  // whose length is equal to the max length of varchar.
		  
		  const CharType& char_type =
		    (CharType&)(skey_node->getValueId().getType());
		  
		  //no cast to fixed char in the case of collation (Czech) 
		  if (!CollationInfo::isSystemCollation(char_type.getCollation()))
		    {
		      skey_node =
			new(generator->wHeap())
			Cast (srcVal,
			      (new(generator->wHeap())
			       SQLChar(generator->wHeap(),
                                    CharLenInfo(char_type.getStrCharLimit(), char_type.getDataStorageSize()),
				    char_type.supportsSQLnull(),
				    FALSE, FALSE, FALSE,
				    char_type.getCharSet(),
				    char_type.getCollation(),
				    char_type.getCoercibility()
				    )
			       )
			      );
		    }
		}
	      else
		{
		  skey_node = new(generator->wHeap()) 
		    Cast(srcVal, &tgtValueId.getType());
		}

	      CompEncode * enode
		= new(generator->wHeap()) CompEncode(skey_node, desc_flag);
	      
	      enode->bindNode(generator->getBindWA());
	      
	      sort_key_len += enode->getValueId().getType().getTotalSize();
	      
	      sortKeyVIDlist.insert(enode->getValueId()); 
	    } // if
	  
	  jj++;
	} // while
      
      if (NOT found)
	{
	  GenAssert(0, "Key not found in newRecExprArray");
	}
    } // for
  // genearate sort key expr
  //ex_expr * sort_key_expr = 0;
  if (sortKeyVIDlist.entries() > 0)
  {
    exp_gen->generateContiguousMoveExpr(sortKeyVIDlist,
                                      0,     // no conv nodes
                                      work_atp, work_atp_index,
                                      ExpTupleDesc::SQLMX_KEY_FORMAT,
                                      sort_key_len, &sort_key_expr,
                                      0,  // no tupp descr
                                      ExpTupleDesc::SHORT_FORMAT);
  
  }
  //sortRecVIDlist = sortKeyVIDlist;

  for (ii = 0; ii < getSortRecExpr().entries(); ii++)
    {
      const ItemExpr *assignExpr = 
	getSortRecExpr()[ii].getItemExpr();
      
      ValueId tgtValueId = 
	assignExpr->child(0)->castToItemExpr()->getValueId();
      ValueId srcValueId = 
	assignExpr->child(1)->castToItemExpr()->getValueId();
      
      ItemExpr * ie = NULL;
      ie = new(generator->wHeap())
	Cast(assignExpr->child(1), 
	     &tgtValueId.getType());
      
      ie->bindNode(generator->getBindWA());
      sortRecVIDlist.insert(ie->getValueId());
    } // for

  ExpTupleDesc::TupleDataFormat tupleFormat = generator->getInternalFormat();
  NABoolean resizeCifRecord = FALSE;
  NABoolean considerBufferDefrag = FALSE;

  if (sortRecVIDlist.entries()>0)
  {
    tupleFormat = determineInternalFormat( sortRecVIDlist,
                                           this,
                                           resizeCifRecord,
                                           generator,
                                           FALSE,
                                           considerBufferDefrag);

    exp_gen->generateContiguousMoveExpr(sortRecVIDlist, 
				      0 /*don't add conv nodes*/,
				      work_atp, work_atp_index,
				      tupleFormat,
				      sort_rec_len, &sort_rec_expr,
				      &tuple_desc, ExpTupleDesc::SHORT_FORMAT);
  }
  //sort_key_len = ROUND8(sort_key_len); ?????????

  sort_rec_len += sort_key_len;

  if (resizeCifRecord)
  {
    // with CIF if we need to resize the rows then we need to keep track of the length
    // of the row with the row itself
    // in this case the allocated space for the row will be as folows
    // |row size --(4 bytes)|sort key (sortkeyLen)| data (data length --may be variable)  |
    // ------------------------------------
    sort_rec_len += sizeof(UInt32);
  }


  for (CollIndex i = 0; i < (CollIndex) sortRecVIDlist.entries(); i++)
    {
      ItemExpr * cn = (sortRecVIDlist[i]).getItemExpr();
      
      Attributes *attrib =
	generator->getMapInfo(cn->getValueId())->getAttr();
      
      MapInfo * mi =
	generator->
	addMapInfoToThis(myMapTable, 
			 cn->child(0)->castToItemExpr()->getValueId(), 
			 attrib);
      
      // All reference to the sorted values from this point on
      // will be at atp = 0, atp_index = last entry in child desc.
      // Offset will be the same as in the workAtp.
      mi->getAttr()->setAtp(0);
      mi->getAttr()->setAtpIndex(child_desc->noTuples() - 1);

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

  // generate code for child tree
  child(0)->codeGen(generator);
  
  //This value is set inside generator by my parent exchange node,
  //as a global variable. Reset the saveNumEsps value back into
  //generator since codegen of my children exchange nodes may have
  //changed it. Resetting is performed here so the codegen of right
  //child nodes of my parent gets the proper value.  
  generator->setNumESPs(saveNumEsps);
  
  ComTdb * child_tdb = (ComTdb *)(generator->getGenObj());
  ExplainTuple *childExplainTuple = generator->getExplainTuple();

  // remove all appended map tables. No values are returned by
  // this node.
  generator->removeAll(last_map_table);

  short rc =
    generateTdb(generator,
		child_tdb,
                sort_key_expr,
		sort_rec_expr,
		sort_key_len,
		sort_rec_len,
		0, //sort_prefix_key_len,
		given_desc,
		child_desc,
		work_cri_desc,
		saveNumEsps,
		childExplainTuple,
		resizeCifRecord,
		considerBufferDefrag);

  return rc;
}

CostScalar Sort::getEstimatedRunTimeMemoryUsage(Generator *generator, NABoolean perNode, Lng32 *numStreams)
{
  GroupAttributes * childGroupAttr = child(0).getGroupAttr();
  Lng32 childRecordSize = 
      childGroupAttr->getCharacteristicOutputs().getRowLength();
  CostScalar rowsUsed;
  if (sortNRows() && (topNRows_ > 0)
            && (topNRows_ <= getDefault(GEN_SORT_TOPN_THRESHOLD)))
     rowsUsed = topNRows_; 
  else
     rowsUsed = getEstRowsUsed();
  CostScalar totalMemory = rowsUsed * childRecordSize;
  CostScalar estMemPerNode;
  CostScalar estMemPerInst;
 
  //TODO: Line below dumps core at times 
  //const CostScalar maxCard = childGroupAttr->getResultMaxCardinalityForEmptyInput();
  const CostScalar maxCard = 0;

  Lng32 numOfStreams = 1;
  const PhysicalProperty* const phyProp = getPhysicalProperty();
  if (phyProp != NULL)
  {
     PartitioningFunction * partFunc = phyProp -> getPartitioningFunction() ;
     numOfStreams = partFunc->getCountOfPartitions();
     if (numOfStreams <= 0)
        numOfStreams = 1;
  }
  if (numStreams != NULL)
     *numStreams = numOfStreams;
  estMemPerNode = totalMemory / MINOF(MAXOF(gpClusterInfo->getTotalNumberOfCPUs(), 1), numOfStreams);
  estMemPerInst = totalMemory / numOfStreams;
  OperBMOQuota *operBMOQuota = new (generator->wHeap()) OperBMOQuota(getKey(), numOfStreams,
                                                  estMemPerNode, estMemPerInst, rowsUsed, maxCard);
  generator->getBMOQuotaMap()->insert(operBMOQuota);
  if (perNode)
     return estMemPerNode;
  else
     return estMemPerInst; 
}

/////////////////////////////////////////////////////////
//
// Tuple::codeGen()
//
/////////////////////////////////////////////////////////
short Tuple::codeGen(Generator * generator)
{
  // code generation for this node doesn't do anything.
  // A Tuple node returns one tuple of expression of constants. This
  // expression is evaluated where it is used. Since this node doesn't
  // produce anything, the returned cri desc is same as the input cri desc.
  // We could do away with generating something here but the
  // parent node expects a child node to return 'something' before it
  // can continue.
  Queue * qList = new(generator->getSpace()) Queue(generator->getSpace());
  ExpGenerator *expGen = generator->getExpGenerator();

  // expression to conditionally return 0 or more rows.
  ex_expr *predExpr = NULL;

  // generate tuple selection expression, if present
  if(NOT selectionPred().isEmpty())
  {
    ItemExpr* pred = selectionPred().rebuildExprTree(ITM_AND,TRUE,TRUE);
    expGen->generateExpr(pred->getValueId(),ex_expr::exp_SCAN_PRED,&predExpr);
  }

  ComTdbTupleLeaf *tuple_tdb = new(generator->getSpace())
    ComTdbTupleLeaf(qList,
		    0, // no tuple returned. Length = 0.
		    0, // no tupp index
		    predExpr,
                    generator->getCriDesc(Generator::DOWN),
		    generator->getCriDesc(Generator::DOWN),
		    (queue_index)getDefault(GEN_TUPL_SIZE_DOWN),
		    (queue_index)getDefault(GEN_TUPL_SIZE_UP),
		    (Cardinality) (getInputCardinality() * getEstRowsUsed()).getValue(),
		    getDefault(GEN_TUPL_NUM_BUFFERS),
		    getDefault(GEN_TUPL_BUFFER_SIZE));
  generator->initTdbFields(tuple_tdb);

  if(!generator->explainDisabled()) {
    generator->setExplainTuple(
	 addExplainInfo(tuple_tdb, 0, 0, generator));
  }

  generator->setGenObj(this, tuple_tdb);
  generator->setCriDesc(generator->getCriDesc(Generator::DOWN),
			Generator::UP);

  return 0;
}

/////////////////////////////////////////////////////////
//
// TupleList::codeGen()
//
/////////////////////////////////////////////////////////
short TupleList::codeGen(Generator * generator)
{
  Space * space          = generator->getSpace();
  ExpGenerator * expGen  = generator->getExpGenerator();
  ex_cri_desc * givenDesc
    = generator->getCriDesc(Generator::DOWN);
  ex_cri_desc * returnedDesc
    = new(space) ex_cri_desc(givenDesc->noTuples() + 1, space);
  Int32 tuppIndex = returnedDesc->noTuples() - 1;

  // disable common subexpression elimination for now.
  // There is a problem which shows up due to common subexpression
  // elimination. See case 10-040402-2209.
  // After the problem is diagnosed and fixed in tuple list,
  // we won't need to disable subexp elimination.
  generator->getExpGenerator()->setEnableCommonSubexpressionElimination(FALSE);

  Queue * qList = new(generator->getSpace()) Queue(generator->getSpace());
  ULng32 tupleLen = 0;
  ExpTupleDesc * tupleDesc = 0;
  ExprValueId eVid(tupleExprTree());
  ItemExprTreeAsList tupleList(&eVid, ITM_ITEM_LIST);
  CollIndex nTupEntries = (CollIndex) tupleList.entries();
  for (CollIndex i = 0; i < nTupEntries; i++)
    {
      ex_expr * moveExpr = NULL;

      ItemExpr * tuple =
	((ItemExpr *) tupleList[i])->child(0)->castToItemExpr();

      ExprValueId tVid(tuple);
      ItemExprTreeAsList tupleTree(&tVid, ITM_ITEM_LIST);

      ValueIdList convVIDlist;
      BindWA *bindWA = generator->getBindWA();

      NABoolean castTo = castToList().entries() > 0;
      for (CollIndex j = 0; j < tupleExpr().entries(); j++)
	{
	  ItemExpr * castNode = tupleExpr()[j].getItemExpr();
	  ItemExpr * childNode = (ItemExpr *) tupleTree[j];
          if (castTo)
          {
            const NAType &srcType = childNode->getValueId().getType();
            const NAType &tgtType = castNode->getValueId().getType();

            if ((hiveTextInsert()) &&
                (DFS2REC::isBinaryString(tgtType.getFSDatatype())) &&
                (NOT DFS2REC::isAnyCharacter(srcType.getFSDatatype())))
              {
                childNode = new(bindWA->wHeap()) 
                  ZZZBinderFunction(ITM_TO_CHAR, childNode);
                childNode = childNode->bindNode(bindWA);
                if (bindWA->errStatus())
                  return -1;            
              }

	    // When we have ins/upd target cols which are
	    // MP NCHAR in MX-NSK-Rel1 (i.e., SINGLE-byte),
	    // and the source was from a Tuple/TupleList,
	    // then we must do some magic Assign binding
	    // to ensure that the single-byte even-num-of-bytes
	    // "constraint" is not violated.
	    //
	    // Build + copy this "constraint" --
	    // NOTE:  tmpAssign MUST BE ON HEAP -- see TupleList::bindNode() !

	    Assign *tmpAssign = new(bindWA->wHeap())
	      Assign(castToList()[j].getItemExpr(), childNode);

            //***************************************************************
            // 10-0414-2428: Note that this assign is for inserts or updates
            // (1) castTo is set only when insert DMLs
            // (2) Assign constructor argument UserSpecified is set to TRUE
            //***************************************************************
            setInUpdateOrInsert(bindWA, NULL, REL_INSERT);
	    tmpAssign = (Assign *)tmpAssign->bindNode(bindWA);
            setInUpdateOrInsert(bindWA, NULL);
	    childNode = tmpAssign->getSource().getItemExpr();
            //don't allow LOB insert in a tuple list
            if (childNode->getOperatorType() == ITM_LOBINSERT)
              {                                                          
                // cannot have this function in a values list with
                // multiple tuples. Use a single tuple.
                *CmpCommon::diags() << DgSqlCode(-4483);
                GenExit();
                return -1;
                        
              }
            castNode->child(0) = childNode;
          }
          else
          {
            childNode = childNode->bindNode(bindWA);

            if ( (castNode->child(0)) &&
                (castNode->child(0)->getOperatorType() == ITM_INSTANTIATE_NULL) )
            {
              // if this tuplelist is part of a subquery an additional node
              // of type ITM_INSTANTIATE_NULL is placed in the binder; check if
              // that is the case
              castNode->child(0)->child(0) = childNode; // need to fix this
            }
            else
            {
              castNode->child(0) = childNode;
            }
          }

          castNode->bindNode(bindWA);

	  // if any unknown type in the tuple,
	  // coerce it to the target type.
	  childNode->bindNode(bindWA);
	  childNode->getValueId().coerceType(castNode->getValueId().getType());

	  MapInfo * mInfo = generator->getMapInfoAsIs(castNode->getValueId());
	  if (mInfo)
	    mInfo->resetCodeGenerated();
	  castNode->unmarkAsPreCodeGenned();
	  convVIDlist.insert(castNode->getValueId());
	}

      GenAssert(!bindWA->errStatus(), "bindWA");
      expGen->generateContiguousMoveExpr(convVIDlist,
					 0 /*don't add conv nodes*/,
					 0 /*atp*/,
					 tuppIndex,
					 generator->getInternalFormat(),
					 tupleLen,
					 &moveExpr,
					 &tupleDesc,
					 ExpTupleDesc::SHORT_FORMAT);
      qList->insert(moveExpr);
    }

  returnedDesc->setTupleDescriptor(tuppIndex, tupleDesc);

  // generate expression for selection predicate, if it exists
  ex_expr *predExpr = NULL;
  if(NOT selectionPred().isEmpty())
  {
    ItemExpr* pred = selectionPred().rebuildExprTree(ITM_AND,TRUE,TRUE);
    expGen->generateExpr(pred->getValueId(),ex_expr::exp_SCAN_PRED,
             &predExpr);
  }

  // Compute the buffer size based on upqueue size and row size.
  // Try to get enough buffer space to hold twice as many records
  // as the up queue.
  ULng32 buffersize = getDefault(GEN_TUPL_BUFFER_SIZE);
  Int32 numBuffers = getDefault(GEN_TUPL_NUM_BUFFERS);
  queue_index upqueuelength = (queue_index)getDefault(GEN_TUPL_SIZE_UP);
  ULng32 cbuffersize =
    ((tupleLen + sizeof(tupp_descriptor))
     * (upqueuelength * 2/numBuffers)) +
    SqlBufferNeededSize(0,0);
  buffersize = buffersize > cbuffersize ? buffersize : cbuffersize;

  ComTdbTupleLeaf *tupleTdb = new(generator->getSpace())
    ComTdbTupleLeaf(qList,
		    tupleLen,
		    tuppIndex,
		    predExpr,
                    givenDesc,
		    returnedDesc,
		    (queue_index)getDefault(GEN_TUPL_SIZE_DOWN),
		    (queue_index)upqueuelength,
		    (Cardinality) (getInputCardinality() * getEstRowsUsed()).getValue(),
		    getDefault(GEN_TUPL_NUM_BUFFERS),
		    buffersize);
  generator->initTdbFields(tupleTdb);

  if(!generator->explainDisabled())
    {
      generator->setExplainTuple(
	   addExplainInfo(tupleTdb, 0, 0, generator));
    }

  generator->setGenObj(this, tupleTdb);
  generator->setCriDesc(givenDesc, Generator::DOWN);
  generator->setCriDesc(returnedDesc, Generator::UP);

  return 0;
}

/////////////////////////////////////////////////////////
//
// ExplainFunc::codeGen()
//
/////////////////////////////////////////////////////////
short ExplainFunc::codeGen(Generator * generator)
{
  ExpGenerator * expGen = generator->getExpGenerator();
  Space * space = generator->getSpace();

  // allocate a map table for the retrieved columns
  generator->appendAtEnd();

  ex_expr *explainExpr = 0;

  ex_cri_desc * givenDesc
    = generator->getCriDesc(Generator::DOWN);

  ex_cri_desc * returnedDesc
    = new(space) ex_cri_desc(givenDesc->noTuples() + 1, space);

  ex_cri_desc * paramsDesc
    = new(space) ex_cri_desc(givenDesc->noTuples() + 1, space);


  // Assumption (for now): retrievedCols contains ALL columns from
  // the table/index. This is because this operator does
  // not support projection of columns. Add all columns from this table
  // to the map table.
  //
  // The row retrieved from filesystem is returned as the last entry in
  // the returned atp.

  const ValueIdList & columnList = getTableDesc()->getColumnList();
  const CollIndex numColumns = columnList.entries();

  Attributes ** attrs = new(generator->wHeap()) Attributes * [numColumns];

  for (CollIndex i = 0; i < numColumns; i++)
    {
     ItemExpr * col_node = ((columnList[i]).getValueDesc())->getItemExpr();

      attrs[i] = (generator->addMapInfo(col_node->getValueId(), 0))->
	getAttr();
    }

  ExpTupleDesc *explTupleDesc = 0;
  ULng32 explTupleLength = 0;
  expGen->processAttributes(numColumns,
			    attrs, ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
			    explTupleLength,
			    0, returnedDesc->noTuples() - 1,
			    &explTupleDesc, ExpTupleDesc::SHORT_FORMAT);

  // delete [] attrs;
  // NADELETEBASIC is used because compiler does not support delete[]
  // operator yet. Should be changed back later when compiler supports
  // it.
  NADELETEBASIC(attrs, generator->wHeap());

  // add this descriptor to the work cri descriptor.
  returnedDesc->setTupleDescriptor(returnedDesc->noTuples()-1, explTupleDesc);

  // generate explain selection expression, if present
  if (! selectionPred().isEmpty())
   {
     ItemExpr * newPredTree = selectionPred().rebuildExprTree(ITM_AND,TRUE,TRUE);
     expGen->generateExpr(newPredTree->getValueId(), ex_expr::exp_SCAN_PRED,
			   &explainExpr);
   }

  // generate move expression for the parameter list
  ex_expr *moveExpr = 0;

  ExpTupleDesc *tupleDesc = 0;
  ULng32 tupleLength = 0;
  if (! getProcInputParamsVids().isEmpty())
    {

      expGen->generateContiguousMoveExpr(getProcInputParamsVids(),
					 -1,
					 0,
					 paramsDesc->noTuples()-1,
					 ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
					 tupleLength,
					 &moveExpr,
					 &tupleDesc,
					 ExpTupleDesc::LONG_FORMAT);

      // add this descriptor to the work cri descriptor.
      paramsDesc->setTupleDescriptor(paramsDesc->noTuples()-1, tupleDesc);
    }

  // allocate buffer space to contain atleast 2 rows.
  ULng32 bufferSize = (explTupleLength+100/*padding*/) * 2/*rows*/;
  bufferSize = MAXOF(bufferSize, 30000); // min buf size 30000
  Int32 numBuffers = 3; // allocate 3 buffers

  ComTdbExplain *explainTdb
    = new(space)
      ComTdbExplain(givenDesc,	                 // given_cri_desc
		    returnedDesc,		 // returned cri desc
		    8,				 // Down queue size
		    16,				 // Up queue size0
		    returnedDesc->noTuples() - 1, // Index in atp of return
		    // tuple.
		    explainExpr,			 // predicate
		    paramsDesc,			 // Descriptor of params Atp
		    tupleLength,			 // Length of params Tuple
		    moveExpr,			 // expression to calculate
						 // the explain parameters
		    numBuffers,			 // Number of buffers to allocate
                    bufferSize);			 // Size of each buffer
  generator->initTdbFields(explainTdb);

  // Add the explain Information for this node to the EXPLAIN
  // Fragment.  Set the explainTuple pointer in the generator so
  // the parent of this node can get a handle on this explainTuple.
  if(!generator->explainDisabled()) {
    generator->setExplainTuple(
       addExplainInfo(explainTdb, 0, 0, generator));
  }
  generator->setCriDesc(givenDesc, Generator::DOWN);
  generator->setCriDesc(returnedDesc, Generator::UP);
  generator->setGenObj(this, explainTdb);

  return 0;
}

// PhysTranspose::codeGen() ------------------------------------------
// Generate code (a TDB node with corresponding Expr expressions) for
// the PhysTranspose node.  This node implements the TRANSPOSE operator.
//
// Parameters:
//
// Generator *generator
//    IN/OUT : A pointer to the generator object which contains the state,
//             and tools (e.g. expression generator) to generate code for
//             this node.
//
// Side Effects: Generates an ComTdbTranspose along with all the required
//               expressions for the transpose node.
//
//               Generates explain info.
//
//               Alters the state of the generator, including modifing
//               the map table, setting references to the generated Tdb
//               and explain info. etc.
//
short
PhysTranspose::codeGen(Generator *generator)
{
  // Get handles on expression generator, map table, and heap allocator
  //
  ExpGenerator *expGen = generator->getExpGenerator();
  Space *space = generator->getSpace();

  // Allocate a new map table for this operation
  //
  MapTable *localMapTable = generator->appendAtEnd();

  // Generate the child and capture the task definition block and a description
  // of the reply composite row layout and the explain information.
  //
  child(0)->codeGen(generator);

  ComTdb *childTdb = (ComTdb*)(generator->getGenObj());

  ex_cri_desc *childCriDesc = generator->getCriDesc(Generator::UP);

  ExplainTuple *childExplainTuple = generator->getExplainTuple();


  // Generate the given and returned composite row descriptors
  // Transpose adds a tupp to the row returned by the *child*
  // or the Given row, if no columns of the child are outputs of
  // this node.
  //
  ex_cri_desc *givenCriDesc = generator->getCriDesc(Generator::DOWN);


  // Determine if any of the childs outputs are also outputs of the node.
  // (if not, then don't pass them up the queue, later we will remove them
  // from the map table.)
  //

  // Get the outputs of this node.
  //
  ValueIdSet transOutputs = getGroupAttr()->getCharacteristicOutputs();

  // Get all the ValueIds that this node generates.
  //
  ValueIdSet transVals;

  for(CollIndex v = 0; v < transUnionVectorSize(); v++) {
    transVals.insertList(transUnionVector()[v]);
  }

  // Remove from the outputs, those values that are generated by this
  // node. (if none are left, then the child's outputs are not needed
  // above, otherwise they are.)
  //
  transOutputs -= transVals;

  ex_cri_desc *returnedCriDesc = 0;

  if (transOutputs.isEmpty()) {

    // The child's outputs are not needed above, so do not pass them
    // along.
    //
    returnedCriDesc =
      new(space) ex_cri_desc(givenCriDesc->noTuples() + 1, space);

    // Make all of my child's outputs map to ATP 1. Since they are
    // not needed above, they will not be in the work ATP (0).
    // (Later, they will be reomved from the map table)
    //
    localMapTable->setAllAtp(1);

  } else {

    // The child's outputs are needed above, so must pass them along.
    //
    returnedCriDesc =
      new(space) ex_cri_desc(childCriDesc->noTuples() + 1, space);
  }

  // transposeCols is the last Tp in Atp 0.
  //
  const Int32 transColsAtpIndex = returnedCriDesc->noTuples() - 1;
  const Int32 transColsAtp = 0;

  // The length of the new tuple which will contain the columns
  // generated by transpose.
  //
  ULng32 transColsTupleLen;

  // The Transpose node contains a vector of ValueIdLists. There is
  // one entry for each transpose set, plus one entry for the key
  // values. Each entry contains a list of ValueIdUnion Nodes. The
  // first entry contains a list with one ValueIdUnion node. This node
  // is for the Const. Values (1 - N) representing the Key Values. The
  // other entries contain lists of ValueIdUnion nodes for the
  // Transposed Values. Each of these entries of the vector represent
  // a transpose set.  If the transpose set contains a list of values,
  // then there will be only one ValueIdUnion node in the list.  If
  // the transpose set contains a list of lists of values, then there
  // will be as many ValueIdUnion nodes as there are items in the
  // sublists. Each ValueIdUnion within a list must contain the same
  // number of elements.
  //

  // The cardinality of an entry in the vector is the number of entries
  // in each of its ValueIdUnion nodes.  The cardinality of the first
  // entry (the key values) is equal to the sum of the cardinalities of
  // the subsequent entries (the transpose values).

  // In order to generate the expressions for the transpose node the
  // ValueIdUnion nodes for the values expressions (entries 1 - 3 below)
  // have to be  indexed from 0 - N (0 - 6 in the example below).
  // In order to translate from an index from 0 - N to an index of the
  // vector and an index within the ValueIdUnion, numExprs contains the
  // number of ValExprs for each ValueIdUnion. Eg. if the transUnionVector
  // contains these entries:
  //
  // Vector Num
  // Entry  Entries Card.
  //   0     1       7      ValueIdUnion(1,2,3,4,5,6,7)
  //   1     1       2      ValueIdUnion(A,B)
  //   2     1       3      ValueIdUnion(X,Y,Z)
  //   3     2       2      ValueIdUnion(1,2) , ValueIdUnion('hello', 'world')
  //
  // Then numUnionLists would be 4
  //
  // The numKeyExprs would be 7 (the cardinality of the Key Values, see below)
  //
  // The total cardinality of the rest of the ValueIdUnions also equals 7.
  //
  // numExprs will have 4 (numUnionLists) entries with values 7, 2, 3 and 2.
  //
  // The number of entries in the transUnionVector.
  //
  CollIndex numUnionLists = transUnionVectorSize();

  // Allocate a vector of size numUnionLists to hold the cardinality of each
  // entry in the vector.
  //
  CollIndex *numExprs = new(space) CollIndex[numUnionLists];

  // The Tuple Desc describing the tuple containing the new transpose columns
  // It is generated when the expressions are generated.
  //
  ExpTupleDesc *transColsTupleDesc = 0;

  // Loop index used throughout
  //
  CollIndex unionListNum;

  // Used below for a sanity check (assert).
  //
  CollIndex totNumExprs = 0;

  // Populate the numExprs array.
  //
  for(unionListNum = 0; unionListNum < numUnionLists; unionListNum++) {

    // If the entry of the vector has at least one ValueIdUnion ...
    // (All ValueIdUnions in an entry of the vector should have the
    // same number of enties, so use the first entry)
    //
    if(transUnionVector()[unionListNum].entries() > 0)
      numExprs[unionListNum] =
	((ValueIdUnion *)(transUnionVector()[unionListNum])[0].
	 getValueDesc()->getItemExpr())->entries();
    else
      // If the keyCol was not specified, then the first entry of the
      // vector may contain no ValueIdUnion nodes.
      //
      numExprs[unionListNum] = 0;

    // Used in an assert below.
    //
    totNumExprs += numExprs[unionListNum];
  }

  // The number of Key Exprs. The item expressions should be the Constants
  // 1 -> numKeyExprs or non-existant. The Key Exprs are the first entry.
  //
  const CollIndex numKeyExprs = numExprs[0];

  // If there are no key expressions, the the number of expressions
  // to generate is the totNumExprs.
  //
  const CollIndex numMovExprs = (numKeyExprs == 0 ? totNumExprs : numKeyExprs);

  // The total number of item expressions in the value unions should equal
  // the number of key values in the first ValueIdUnion.
  //
  GenAssert(totNumExprs == numKeyExprs * 2 || numKeyExprs == 0,
	    "Transpose: Internal Error");

  // Allocate space to hold numMovExprs expressions. Each expression will
  // compute one value for each of the ValueIdUnions.
  // A constant Key Value will be computed in each expression,
  // but only value expressions from one vector entry will be computed.
  // All other value expressions will be NULL.
  //
  ex_expr ** transExprs = new(space)ex_expr*[numMovExprs];

  // A list of the ValueIds will be constructed and used to generate
  // the expressions
  //
  ValueIdList ValueIds;

  // A new item expression which casts the result to the proper type
  // will be constructed.
  //
  Cast *castExpr = 0;

  // Loop index
  //
  CollIndex exprNum;

  // For each transpose value expression (also equal to the number of key
  // values if they exist)
  //
  for(exprNum = 0; exprNum < numMovExprs; exprNum++) {

    // Clear the list of value Ids (used in the previous iteration
    // through this loop).
    //
    ValueIds.clear();

    // Contruct Key Expression with Cast node if they exist.
    // The key ValueIdUnion is in position 0.
    //
    if(numKeyExprs != 0) {

      // Get the key ValueIdUnion.
      //
      ValueIdUnion *keyValIdUnion =
	(ValueIdUnion *)((transUnionVector()[0])[0].
			 getValueDesc()->getItemExpr());

      // Extract one (exprNum) entry from the ValueIdUnion and add a
      // Cast to cast it to the proper type.
      //
      castExpr = new(generator->wHeap())
	Cast(keyValIdUnion->getSource(exprNum).getValueDesc()->getItemExpr(),
	     &(keyValIdUnion->getResult().getType()));

      // Bind this new item expression.
      //
      castExpr->bindNode(generator->getBindWA());

      // This should never fail at this point !!!
      //
      GenAssert(! generator->getBindWA()->errStatus(),
		"Transpose: Internal Error");

      // Insert the Value Id for this item expression into the list of
      // Value Ids that will be used to generate the final expression.
      //
      ValueIds.insert(castExpr->getValueId());
    }

    // ValueIds may now contains one ValueId representing the key value.
    //

    // Translate the expression number (exprNum) from 0 -> numKeyExprs - 1
    // to vector entry number (vectorEntryNum) and expression number
    // (valExprNum)
    //

    // Binary expression indexes.
    //
    CollIndex vectorEntryNum, valExprNum;

    // Keep track of how many expressions are covered by the current
    // ValueIdUnion and those previous.
    //
    CollIndex numCoveredExprs;

    // Translate the Unary expression index (exprNum) into a binary
    // index (vectorEntryNum, valExprNum)
    // (A for-loop with no body)
    //
    for((vectorEntryNum = 1,
	 numCoveredExprs = numExprs[1],
	 valExprNum = exprNum);

	// Does this ValueIdUnion cover this expression number
	//
	numCoveredExprs <= exprNum;

	// If not, adjust the indexes and try the next one.
	(numCoveredExprs += numExprs[vectorEntryNum + 1],
	 valExprNum -= numExprs[vectorEntryNum],
	 vectorEntryNum++));

    // At this point:
    // vectorEntryNum is index of the transUnionVector for this exprNum.
    // valExprNum is index into the ValueIdUnion.

    GenAssert(vectorEntryNum > 0 && vectorEntryNum < numUnionLists,
	      "Transpose: Internal Error");

    GenAssert(valExprNum < numExprs[vectorEntryNum],
	      "Transpose: Internal Error");

    // Generate all Value Expressions.
    // One will be all of the value expressions indexed by vectorEntryNum
    // and valExprNum and the others will be NULL.
    //
    for(unionListNum = 1; unionListNum < numUnionLists; unionListNum++) {

      // For Each ValueIdUnion in an entry of the vector.
      //
      for(CollIndex numValUnions = 0;
	  numValUnions < transUnionVector()[unionListNum].entries();
	  numValUnions++) {

	ValueIdUnion *valValIdUnion =
	  (ValueIdUnion *)((transUnionVector()[unionListNum])[numValUnions].
			   getValueDesc()->getItemExpr());

	if(unionListNum == vectorEntryNum){

	  // Construct the value expression cast to the proper type.
	  //
	  castExpr = new(generator->wHeap())
	    Cast(valValIdUnion->
		 getSource(valExprNum).getValueDesc()->getItemExpr(),
		 &(valValIdUnion->getResult().getType()));
	} else {

	  // Construct NULL expression cast to the proper type.
	  //
	  castExpr = new(generator->wHeap())
	    Cast(new (space) ConstValue(),
		 &(valValIdUnion->getResult().getType()));
	}

	// Bind the CASTed itemed expression.
	//
	castExpr->bindNode(generator->getBindWA());

	// This should never fail at this point !!!
	//
	GenAssert(! generator->getBindWA()->errStatus(),
		  "Transpose: Internal Error");

	// Add the ValueId to the list of value ids which will be used
	// to generate the final expression.
	//
	ValueIds.insert(castExpr->getValueId());
      }
    }

    // Generate the expression.

    // Initialize the pointer to the expression to be generated
    // to be NULL.
    //
    transExprs[exprNum] = 0;

    // Generate the expressions.
    //
    // ValueIds - refers to the expressions for 1 key value, and N
    // transpose values, all but one will be NULL.
    //
    // 0 - Do not add conv. nodes.
    //
    // transColsAtp - this expression will be evaluated on the
    // transColsAtp (0) ATP.
    //
    // transColsAtpIndex - within the transColsAtp (0) ATP, the destination
    // for this move expression will be the transColsAtpIndex TP. This should
    // be the last TP of the ATP.
    //
    // SQLARK_EXPLODED_FORMAT - generate the move expression to construct
    // the destination tuple in EXPLODED FORMAT.
    //
    // transColsTupleLen - This is an output which will contain the length
    // of the destination Tuple.  This better return the same value for each
    // interation of this loop.
    //
    // &transExprs[exprNum] - The address of the pointer to the expression
    // which will be generated.
    //
    // &transColsTupleDesc - The address of the tuple descriptor which is
    // generated.  This describes the destination tuple of the move expression.
    // This will be generated only the first time through the loop. The tuple
    // better have the same format each time. A NULL value inticates that
    // the descriptor should not be generated.
    //
    // SHORT_FORMAT - generate the transColsTupleDesc in the SHORT FORMAT.
    //
    expGen->generateContiguousMoveExpr(ValueIds,
				       0,
				       transColsAtp,
				       transColsAtpIndex,
				       generator->getInternalFormat(),
				       transColsTupleLen,
				       &transExprs[exprNum],
				       (exprNum == 0
					? &transColsTupleDesc
					: 0),
				       ExpTupleDesc::SHORT_FORMAT);
    // Set the tuple descriptor in the returned CRI descriptor.
    // This will be set only the first time through the loop.
    //
    if(exprNum == 0) {
      returnedCriDesc->setTupleDescriptor(transColsAtpIndex,
					  transColsTupleDesc);

      // Take the result (ie. the Cast nodes) of generateContiguousMove
      // and set the mapInfo for the ValueIdUnion nodes to be the same so
      // that our parent can access the computed expressions
      // This code is executed only the first time through the loop.
      // The info generated from the expression generator should be the
      // same each time through the loop.
      //

      // An index into the ValueIds that we just generated.
      // (It is assumed that the above code inserts the value Ids into
      // ValueIds in the same order as the loops below).
      //
      CollIndex valIdNum = 0;

      // For each entry in the transUnionVector...
      //
      for(unionListNum = 0; unionListNum < numUnionLists; unionListNum++) {

	// For each ValueIdUnion in the entry...
	//
	for(CollIndex numValUnions = 0;
	    numValUnions < transUnionVector()[unionListNum].entries();
	    numValUnions++) {

	  // Get the ValueId of the ValueIdUnion node.
	  //
	  ValueId valId =
	    (transUnionVector()[unionListNum])[numValUnions];

	  // Add a map entry to the map table for this ValueIdUnion node.
	  // The mapInfo is the same as the mapInfo of the result of
	  // generating an expression for the corresponding Cast expression.
	  //
	  MapInfo * mapInfo =
	    generator->addMapInfoToThis(localMapTable,
                valId,
                generator->getMapInfo(ValueIds[valIdNum])->getAttr());

	  // Indicate that code was generated for this map table entry.
	  //
	  mapInfo->codeGenerated();

	  // Advance the index to the ValueIds.
	  //
	  valIdNum++;
	}
      }
    }

    //localMapTable->removeLast();
    generator->removeLast();
  }

  // Generate expression to evaluate predicate on the transposed row
  //
  ex_expr *afterTransPred = 0;

  if (! selectionPred().isEmpty()) {
    ItemExpr * newPredTree =
      selectionPred().rebuildExprTree(ITM_AND,TRUE,TRUE);

    expGen->generateExpr(newPredTree->getValueId(), ex_expr::exp_SCAN_PRED,
			 &afterTransPred);
  }

  // Allocate the Transpose TDB
  //
  queue_index upQ = (queue_index)getDefault(GEN_TRSP_SIZE_UP);

  ComTdbTranspose *transTdb =
    new (space) ComTdbTranspose(childTdb,
				transExprs,
				numMovExprs,
				afterTransPred,
				transColsTupleLen,
				transColsAtpIndex,
				givenCriDesc,
				returnedCriDesc,
				(queue_index)getDefault(GEN_TRSP_SIZE_DOWN),
				//(queue_index)getDefault(GEN_TRSP_SIZE_UP),
				upQ,
				(Cardinality) (getInputCardinality() * getEstRowsUsed()).getValue(),
				getDefault(GEN_TRSP_NUM_BUFFERS),
				getDefault(GEN_TRSP_BUFFER_SIZE),
                                space);
  generator->initTdbFields(transTdb);
  // If the child's outputs are not needed above this node,
  // remove the entries from the map table.
  //
  if (transOutputs.isEmpty()) {

    // Remove child's outputs from mapTable, They are not needed
    // above.
    //
    generator->removeAll(localMapTable);
    NADELETEARRAY(numExprs,numUnionLists,CollIndex,space);
    numExprs = NULL;

  }


  // Add the explain Information for this node to the EXPLAIN
  // Fragment.  Set the explainTuple pointer in the generator so
  // the parent of this node can get a handle on this explainTuple.
  //
  if(!generator->explainDisabled()) {
    generator->setExplainTuple(addExplainInfo(transTdb,
					      childExplainTuple,
					      0,
					      generator));
  }

  // Restore the Cri Desc's and set the return object.
  //
  generator->setCriDesc(givenCriDesc, Generator::DOWN);
  generator->setCriDesc(returnedCriDesc, Generator::UP);
  generator->setGenObj(this, transTdb);

  return 0;
}

// -----------------------------------------------------------------------
// PhyPack::codeGen()
// -----------------------------------------------------------------------
short PhyPack::codeGen(Generator* generator)
{
  // Get handles on expression generator, map table, and heap allocator.
  ExpGenerator* expGen = generator->getExpGenerator();
  Space* space = generator->getSpace();

  // Allocate a new map table for this operation.
  MapTable* localMapTable =
    generator->appendAtEnd();

  // Get a description of what kind of tuple my parent gives me.
  ex_cri_desc* givenCriDesc = generator->getCriDesc(Generator::DOWN);

  // PhyPack adds one tupp to what its parent gives in its return tuple.
  unsigned short returnedNoOfTuples = givenCriDesc->noTuples() + 1;
  ex_cri_desc* returnedCriDesc =
                        new (space) ex_cri_desc(returnedNoOfTuples,space);

  // Get a handle of the last map table before allowing child to code gen.
  MapTable* lastMapTable = generator->getLastMapTable();

  // Create new attributes for the packed columns.
  CollIndex noOfPackedCols = packingExpr().entries();
  Attributes** attrs =
                   new (generator->wHeap()) Attributes * [noOfPackedCols];

  // Add the packed columns to the map table. (using ATP0)
  for(CollIndex i = 0; i < noOfPackedCols; i++)
      attrs[i] = (generator->addMapInfo(packingExpr().at(i),0))->getAttr();

  // PhyPack adds one tupp to the tail of its parent's ATP (stored as ATP0)
  const Int32 atpIndex = returnedNoOfTuples - 1;
  const Int32 atp = 0;

  // To store length of the last tupp introduced by PhyPack.
  ULng32 tupleLen = 0;

  // Will be generated to describe the last tupp introduced by PhyPack.
  ExpTupleDesc* tupleDesc = 0;

  // From here up we go back into Exploded Internal format (if not there
  // already) since it doesn't make sense for column wise rowsets to
  // be in Compressed Internal format yet.
  generator->setExplodedInternalFormat();

  // Fill in offsets and other info in the attributes list and computes the
  // length and descriptor of the resulting tuple generated.
  // The format of packed rows in rowsets is always Exploded Internal format.
  expGen->processAttributes(noOfPackedCols,
                            attrs,
                            ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
                            tupleLen,
                            atp,
                            atpIndex,
                            &tupleDesc,
                            ExpTupleDesc::SHORT_FORMAT);

  // Copies of Attributes have been made to store in the tuple descriptor.
  NADELETEBASIC(attrs,generator->wHeap());

  // Store the computed tuple desc for the new tuple added by PhyPack.
  returnedCriDesc->setTupleDescriptor(returnedNoOfTuples - 1,tupleDesc);

  // Set the DOWN descriptor in the generator to what my child gets from me.
  generator->setCriDesc(returnedCriDesc,Generator::DOWN);

  // Get the child code generated and retrieve useful stuffs from it.
  child(0)->codeGen(generator);
  ComTdb* childTdb = (ComTdb*)(generator->getGenObj());

  // Generate an expression to pack the rows.
  ex_expr* packExpr = 0;
  expGen->generateListExpr(packingExpr(),ex_expr::exp_ARITH_EXPR,&packExpr);

  // Generate selection predicate on the packed cols if there are any.
  ex_expr* predExpr = 0;
  if(NOT selectionPred().isEmpty())
  {
    ItemExpr* pred = selectionPred().rebuildExprTree(ITM_AND,TRUE,TRUE);
    expGen->generateExpr(pred->getValueId(),ex_expr::exp_SCAN_PRED,
                         &predExpr);
  }

  //????????? Generate an expression to copy result row to result buffer.
  // ex_expr* copyExpr = 0;
  // expGen->generateContiguousMoveExpr(packingExpr(),
  //                                 -1,                       // add conv
  //                                 1,                        // copy to ATP1
  //                                 returnedNoOfTuples - 1,   // ATP index
  //                                 ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
  //                                 tupleLen,
  //                                 &copyExpr);
  //
  // Note that my parent is gonna find the non-copied version of attributes
  // information in my map table, since it is refering to the vid's of the
  // originals but not the copies. Coincidentally this is good for us since:
  // 1. My parent is expected to see things at ATP0 rather than ATP1.
  // 2. The format (or order) of the tuple doesn't get changed after copying
  //    so that the old attributes are refering to the right offsets.
  //
  // $$$ Seems copyExpr_ is no longer needed after ComTdbPackRows code were written.

  // Values at the child's context as well as the intermediates during expr
  // generation are no longer visible any more from this point.
  generator->removeAll(lastMapTable);

  // Create the Pack node's TDB.
  ComTdbPackRows* packTdb = new (space) ComTdbPackRows (childTdb,
                                              packExpr,
                                              predExpr,
                                              returnedNoOfTuples - 1,
                                              tupleLen,
                                              givenCriDesc,
                                              returnedCriDesc,
                                              (queue_index) 8,
                                              (queue_index) 8);
  generator->initTdbFields(packTdb);

  // Add explain info of this node to the EXPLAIN fragment. Set explainTuple
  // pointer in the generator so the parent of this node can get a handle on
  // this explainTuple.
  //
  if(NOT generator->explainDisabled())
  {
    // Child's explain tuple.
    ExplainTuple* childExplainTuple = generator->getExplainTuple();

    generator->setExplainTuple(addExplainInfo(packTdb,
                                              childExplainTuple,
                                              0,
                                              generator));
  }

  // Set up the new up CRI desc.
  generator->setCriDesc(returnedCriDesc,Generator::UP);

  // Restore original down CRI desc since this node changed it.
  generator->setCriDesc(givenCriDesc,Generator::DOWN);

  // Return generated object (the TDB) to the generator.
  generator->setGenObj(this, packTdb);

  return 0;

}

// -----------------------------------------------------------------------
// TableValuedFunction methods
// -----------------------------------------------------------------------
const char * TableValuedFunction::getVirtualTableName()
{ return "??TableValuedFunction??"; }

TrafDesc *TableValuedFunction::createVirtualTableDesc()
{ return NULL; }

void TableValuedFunction::deleteVirtualTableDesc(TrafDesc *vtd)
{
}

// -----------------------------------------------------------------------
// StatisticsFunc methods
// -----------------------------------------------------------------------
const char * StatisticsFunc::getVirtualTableName()
//{ return "STATISTICS__"; }
{return getVirtualTableNameStr();}

TrafDesc *StatisticsFunc::createVirtualTableDesc()
{
  TrafDesc * table_desc =
    Generator::createVirtualTableDesc(getVirtualTableName(),
				      NULL, // let it decide what heap to use    
				      ComTdbStats::getVirtTableNumCols(),
				      ComTdbStats::getVirtTableColumnInfo(),
				      ComTdbStats::getVirtTableNumKeys(),
				      ComTdbStats::getVirtTableKeyInfo());
  return table_desc;
}


short StatisticsFunc::codeGen(Generator* generator)
{
  ExpGenerator * expGen = generator->getExpGenerator();
  Space * space = generator->getSpace();

  // allocate a map table for the retrieved columns
  generator->appendAtEnd();

  ex_expr *scanExpr = 0;
  ex_expr *projExpr = 0;

  ex_cri_desc * givenDesc
    = generator->getCriDesc(Generator::DOWN);

  ex_cri_desc * returnedDesc
    = new(space) ex_cri_desc(givenDesc->noTuples() + 1, space);

  // cri descriptor for work atp has 4 entries:
  // first two entries for consts and temps.
  // Entry 1(index #2) is
  // where the stats row will be moved to evaluate
  // the 'where' predicate.
  // Entry 2(index #3) is where the input row will be built.

  ex_cri_desc * workCriDesc = new(space) ex_cri_desc(4, space);
  const Int32 work_atp = 1;
  const Int32 stats_row_atp_index = 2;
  const Int32 input_row_atp_index = 3;

  // Assumption (for now): retrievedCols contains ALL columns from
  // the table/index. This is because this operator does
  // not support projection of columns. Add all columns from this table
  // to the map table.
  //
  // The row retrieved from filesystem is returned as the last entry in
  // the returned atp.

  Attributes ** attrs =
    new(generator->wHeap())
    Attributes * [getTableDesc()->getColumnList().entries()];

  for (CollIndex i = 0; i < getTableDesc()->getColumnList().entries(); i++)
    {
      ItemExpr * col_node
	= (((getTableDesc()->getColumnList())[i]).getValueDesc())->
	  getItemExpr();

      attrs[i] = (generator->addMapInfo(col_node->getValueId(), 0))->
	getAttr();
    }

  ExpTupleDesc *tupleDesc = 0;
  ULng32 tupleLength = 0;

  // StatisticsFunc must use Exploded Format for now.
  ExpTupleDesc::TupleDataFormat tupleFormat = ExpTupleDesc::SQLARK_EXPLODED_FORMAT;

  expGen->processAttributes(getTableDesc()->getColumnList().entries(),
			    attrs, tupleFormat,
			    tupleLength,
			    work_atp, stats_row_atp_index,
			    &tupleDesc, ExpTupleDesc::LONG_FORMAT);

  // delete [] attrs;
  // NADELETEBASIC is used because compiler does not support delete[]
  // operator yet. Should be changed back later when compiler supports
  // it.
  NADELETEBASIC(attrs, generator->wHeap());

  // add this descriptor to the work cri descriptor.
  workCriDesc->setTupleDescriptor(stats_row_atp_index, tupleDesc);

  // generate stats selection expression, if present
  if (! selectionPred().isEmpty())
   {
     ItemExpr * newPredTree = selectionPred().rebuildExprTree(ITM_AND,TRUE,TRUE);
     expGen->generateExpr(newPredTree->getValueId(), ex_expr::exp_SCAN_PRED,
			  &scanExpr);
   }

  // generate move expression for the parameter list
  ex_expr *inputExpr = 0;
  ExpTupleDesc *inputTupleDesc = 0;
  ULng32 inputTupleLength = 0;

  if (! getProcInputParamsVids().isEmpty())
    {

      expGen->generateContiguousMoveExpr(getProcInputParamsVids(),
					 -1,
					 work_atp,
					 input_row_atp_index,
					 tupleFormat,
					 inputTupleLength,
					 &inputExpr,
					 &inputTupleDesc,
					 ExpTupleDesc::LONG_FORMAT);

      // add this descriptor to the work cri descriptor.
      workCriDesc->setTupleDescriptor(input_row_atp_index, inputTupleDesc);
    }

  // The stats row will be returned as the last entry of the returned atp.
  // Change the atp and atpindex of the returned values to indicate that.
  expGen->assignAtpAndAtpIndex(getTableDesc()->getColumnList(),
			       0, returnedDesc->noTuples()-1);

  Lng32 numBuffers = 3;
  Lng32 bufferSize = 10 * tupleLength;
  ComTdbStats *statsTdb = new(space) ComTdbStats
    (
	 tupleLength,			 // Length of stats Tuple
	 tupleLength,                    // Length of returned tuple
	 inputTupleLength,               // length of input tuple
	 givenDesc,	                 // given_cri_desc
	 returnedDesc,		         // returned cri desc
	 8,				 // Down queue size
	 16,				 // Up queue size
	 numBuffers,			 // Number of buffers to
					 // allocate
	 bufferSize,			 // Size of each buffer
	 scanExpr,			 // predicate
	 inputExpr,
	 projExpr,
	 workCriDesc,			 // Descriptor of work Atp
	 stats_row_atp_index,
	 input_row_atp_index);

  generator->initTdbFields(statsTdb);

  // Add the explain Information for this node to the EXPLAIN
  // Fragment.  Set the explainTuple pointer in the generator so
  // the parent of this node can get a handle on this explainTuple.
  if(!generator->explainDisabled()) {
    generator->setExplainTuple(
       addExplainInfo(statsTdb, 0, 0, generator));
  }
  generator->setCriDesc(givenDesc, Generator::DOWN);
  generator->setCriDesc(returnedDesc, Generator::UP);
  generator->setGenObj(this, statsTdb);

  return 0;
}

// -----------------------------------------------------------------------
// ProxyFunc methods
// -----------------------------------------------------------------------

static void initProxyKeyDescStruct(TrafKeysDesc *tgt, ComUInt32& src)
{
  tgt->keyseqnumber = 1;
  tgt->tablecolnumber = 0;
  tgt->setDescending(FALSE);
}

static Lng32 createDescStructsForProxy(const ProxyFunc &proxy,
                                        char *tableName,
                                        TrafDesc *&colDescs,
                                        TrafDesc *&keyDescs)
{
  colDescs = NULL;
  keyDescs = NULL;
  Lng32 reclen = 0;
  TrafDesc *prev_desc = NULL;
  ComUInt32 numCols = proxy.getNumColumns();

  // Creates and populates column descs
  proxy.populateColumnDesc(tableName, colDescs, reclen);

  // Create key descs
  prev_desc = NULL;
  numCols = 1; 
  for (ComUInt32 keyNum = 0; keyNum < numCols; keyNum++)
  {
    TrafDesc *key_desc = TrafAllocateDDLdesc(DESC_KEYS_TYPE, NULL);
    if (prev_desc)
      prev_desc->next = key_desc;
    else
      keyDescs = key_desc;      
    
    prev_desc = key_desc;
    
    initProxyKeyDescStruct(key_desc->keysDesc(), keyNum);
  }
  
  return reclen;
}

TrafDesc *ProxyFunc::createVirtualTableDesc()
{
  // TrafAllocateDDLdesc() requires that HEAP (STMTHEAP) 
  // be used for operator new herein

  TrafDesc *table_desc = TrafAllocateDDLdesc(DESC_TABLE_TYPE, NULL);
  const char *tableName = getVirtualTableName();
  table_desc->tableDesc()->tablename = new HEAP char[strlen(tableName)+1];
  strcpy(table_desc->tableDesc()->tablename, tableName);

  table_desc->tableDesc()->setSystemTableCode(TRUE);

  TrafDesc *files_desc = TrafAllocateDDLdesc(DESC_FILES_TYPE, NULL);
  files_desc->filesDesc()->setAudited(TRUE); // audited table
  table_desc->tableDesc()->files_desc = files_desc;
  
  TrafDesc *cols_descs = NULL;
  TrafDesc *keys_descs = NULL;

  table_desc->tableDesc()->colcount = (Int32) getNumColumns();

  table_desc->tableDesc()->record_length =
    createDescStructsForProxy(*this,
                                table_desc->tableDesc()->tablename,
                                cols_descs,
                                keys_descs);
  
  TrafDesc *index_desc = TrafAllocateDDLdesc(DESC_INDEXES_TYPE, NULL);
  index_desc->indexesDesc()->tablename =
    table_desc->tableDesc()->tablename;
  index_desc->indexesDesc()->indexname =
    table_desc->tableDesc()->tablename;
  index_desc->indexesDesc()->keytag = 0; // primary index
  index_desc->indexesDesc()->record_length =
    table_desc->tableDesc()->record_length;
  index_desc->indexesDesc()->colcount =
    table_desc->tableDesc()->colcount;
  index_desc->indexesDesc()->blocksize = 4096; // doesn't matter.

  TrafDesc *i_files_desc = TrafAllocateDDLdesc(DESC_FILES_TYPE, NULL);
  i_files_desc->filesDesc()->setAudited(TRUE); // audited table
  index_desc->indexesDesc()->files_desc = i_files_desc;

  index_desc->indexesDesc()->keys_desc  = keys_descs;
  table_desc->tableDesc()->columns_desc = cols_descs;
  table_desc->tableDesc()->indexes_desc = index_desc;
 
  return table_desc;
}

short PhysicalExtractSource::codeGen(Generator *)
{
  GenAssert(0, "PhysicalExtractSource::codeGen() should never be called");
  return 0;
}

/////////////////////////////////////////////////////////
//
// ControlRunningQuery::codeGen()
//
/////////////////////////////////////////////////////////
short ControlRunningQuery::codeGen(Generator * generator)
{
  Space * space = generator->getSpace();

  GenAssert((child(0) == NULL) && (child(1) == NULL),
    "ControlRunningQuery does not expect any child.");

  char *qid =
    space->allocateAndCopyToAlignedSpace(queryId_, str_len(queryId_), 0);

  char *pname =
     space->allocateAndCopyToAlignedSpace(pname_, str_len(pname_), 0);

  char *comment =
    space->allocateAndCopyToAlignedSpace(comment_, str_len(comment_), 0);

  ComTdbCancel::Action a = ComTdbCancel::InvalidAction;
  switch (action_)
  {
    case Cancel:
    {
      switch (qs_)
      {
        case ControlQid:    
          a = ComTdbCancel::CancelByQid;    
          break;
        case ControlPname:  
        case ControlNidPid:
          break;
        default: 
          GenAssert(0, "Invalid ControlRunningQuery::qs_"); break;
      }
      break;
    }
   case Suspend: 
   case Activate:
     break;
   default: GenAssert(0, "Invalid ControlRunningQuery::action_");
  }

  if (a == ComTdbCancel::InvalidAction)
  {
    *CmpCommon::diags() << DgSqlCode(-1010);
    GenExit();
    return -1;
  }

  ComTdbCancel * exe_cancel_tdb = new(space)
    ComTdbCancel(qid, pname, nid_, pid_,
                 getDefault(CANCEL_MINIMUM_BLOCKING_INTERVAL),
                 a,  forced_, comment,
                 generator->getCriDesc(Generator::DOWN),
                 generator->getCriDesc(Generator::DOWN),
                 (queue_index)getDefault(GEN_DDL_SIZE_DOWN),
                 (queue_index)getDefault(GEN_DDL_SIZE_UP)
                );

  generator->initTdbFields(exe_cancel_tdb);

  // no tupps are returned
  generator->setCriDesc((ex_cri_desc *)
    (generator->getCriDesc(Generator::DOWN)),
                           Generator::UP);
  generator->setGenObj(this, exe_cancel_tdb);

  if(!generator->explainDisabled()) {
    generator->setExplainTuple(
       addExplainInfo(exe_cancel_tdb, 0, 0, generator));
  }

  return 0;
}