/**********************************************************************
// @@@ 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 @@@
**********************************************************************/
#ifndef ITEMFUNC_H
#define ITEMFUNC_H
/* -*-C++-*-
******************************************************************************
*
* File:         ItemFunc.h
* Description:  Functions and Aggregate item expressions
*		Aggregates to be used in groupby rel. operators.
*               Functions (and aggregates?) may be built-ins or user-defined.
* Created:      11/04/94
* Language:     C++
*
*
*
*
******************************************************************************
*/

// -----------------------------------------------------------------------
// When adding new BuiltinFunctions herein,
// take heed of the problem documented at Abs::preCodeGen() ...
// -----------------------------------------------------------------------
#include "IntervalType.h"
#include "CharType.h"
#include "DatetimeType.h"
#include "ItemExpr.h"
#include "NATable.h"
#include "exp_like.h"
#include "QRExprElement.h"
#include "ExpLOBenums.h"

// -----------------------------------------------------------------------
// forward references
// -----------------------------------------------------------------------
class CharType;
class DisjunctArray;
class Generator;
class RangePartitioningFunction;
class IntegerList;
class NARoutine;
class ItemList;
class RoutineDesc;

// -----------------------------------------------------------------------
// aggregate functions
//
// The aggregate functions designed for subquery transformations are:
// ITM_ONE_ROW  :
//   Used for transforming a scalar or a row subquery.
//   Its argument is the select list of the subquery.
//   It returns the first group formed by these values.
//   It returns a null if there are no groups.
//   It issues an error if there is more than one group.
// ITM_ONE_TRUE:
//   Used for transforming an exists subquery
//   Its argument is the select list of the subquery.
//   It returns TRUE if the result of the subquery is not empty
//   It returns FALSE, otherwise.
// ITM_ANY_TRUE:
//   Used in for IN, = ANY, <> ANY, = ALL, <> ALL subqueries.
//   Its argument is a boolean predicate that expresses
//   the original predicate without the quantifier.
//   This aggregate function returns a boolean value.
//   It returns TRUE  its argument evaluates to TRUE for any row in
//                    the group,
//   It returns NULL  if its argument evaluates to NULL for at least one
//                    row in the group and if for no row the argument
//                    evaluates to TRUE,
//   It returns FALSE if its argument evaluates to FALSE for each row in
//                    the group or if the group is empty.
//   In other words, it returns an indication whether it is provable that
//   for any row in the group its boolean argument evaluates to TRUE.
//   For > ANY, < ANY, ... subqueries, more specialized functions can be
//   used that allow MIN/MAX optimizations (see class QuantifiedAggregate).
// -----------------------------------------------------------------------
class Aggregate : public ItemExpr
{
  // ITM_AVG, ITM_MAX, ITM_MIN, ITM_SUM, ITM_COUNT,
  // ITM_ONE_ROW, ITM_ONEROW, ITM_ONE_TRUE, ITM_ANY_TRUE
public:
  Aggregate(OperatorTypeEnum otype,
	    ItemExpr *child0,
	    NABoolean isDistinct,
	    OperatorTypeEnum otypeSpecifiedByUser,
	    char /*just to disambiguate from next ctor!*/)
    : ItemExpr(otype, child0),
      origChild_(child0),
      isDistinct_(isDistinct),
      inScalarGroupBy_(FALSE),
      distinctId_(NULL_VALUE_ID),
      treatAsACount_(FALSE),
      amTopPartOfAggr_(FALSE),
      isOLAP_(FALSE),
      olapPartitionBy_(NULL),
      olapOrderBy_(NULL),
      frameStart_(-INT_MAX),
      frameEnd_(INT_MAX),
      rollupGroupIndex_(-1)
    { setOrigOpType(otypeSpecifiedByUser); }
  Aggregate(OperatorTypeEnum otype,
	    ItemExpr *child0 = NULL,
	    NABoolean isDistinct = FALSE,
	    ValueId distinctId = NULL_VALUE_ID)
    : ItemExpr(otype, child0),
      origChild_(child0),
      isDistinct_(isDistinct),
      inScalarGroupBy_(FALSE),
      distinctId_(distinctId),
      treatAsACount_(FALSE),
      amTopPartOfAggr_(FALSE),
      isOLAP_(FALSE),
      olapPartitionBy_(NULL),
      olapOrderBy_(NULL),
      frameStart_(-INT_MAX),
      frameEnd_(INT_MAX),
      rollupGroupIndex_(-1)
    {}
  Aggregate(OperatorTypeEnum otype,
	    ItemExpr *child0,
	    ItemExpr *child1,
	    NABoolean isDistinct = FALSE,
	    ValueId distinctId = NULL_VALUE_ID)
    : ItemExpr(otype, child0, child1),
      origChild_(child0),
      isDistinct_(isDistinct),
      inScalarGroupBy_(FALSE),
      distinctId_(distinctId),
      treatAsACount_(FALSE),
      amTopPartOfAggr_(FALSE),
      isOLAP_(FALSE),
      olapPartitionBy_(NULL),
      olapOrderBy_(NULL),
      frameStart_(-INT_MAX),
      frameEnd_(INT_MAX),
      rollupGroupIndex_(-1)
    {}

  // virtual destructor
  virtual ~Aggregate();

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

  // get the degree of this node (it is a unary op).
  virtual Int32 getArity() const;

  virtual NABoolean isAnAggregate() const;
  virtual NABoolean containsAnAggregate() const;

  // Are two Aggregates equivalent?
  virtual NABoolean operator == (const ItemExpr& other) const;

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  NABoolean isRelaxCharTypeMatchRulesPossible() {return TRUE;};

  // a method for initializing the result
  void setAggrResult(ValueId vid) 		{ result_ = vid; }
  ValueId getAggrResult() 			{ return result_; }

  inline NABoolean isDistinct() const   	{ return isDistinct_; }
  void setDistinct(NABoolean dist = TRUE)
  {
    isDistinct_ = dist;
    distinctId_ = dist ? child(0)->getValueId() : NULL_VALUE_ID;
  }
  inline void setDistinctValueId(ValueId vid)   { distinctId_ = vid; }
  ValueId getDistinctValueId() const	        { return distinctId_; }

  // Agregates in non-Scalar GroupBy cannot evaluate to null
  // if their argument is not nullable
  inline NABoolean inScalarGroupBy() const         { return inScalarGroupBy_;}
  inline void setInScalarGroupBy()                 { inScalarGroupBy_ = TRUE;}

  NABoolean treatAsACount() const { return treatAsACount_;}
  void setTreatAsACount() { treatAsACount_ = TRUE;}

  const OperatorTypeEnum getEffectiveOperatorType() const {
    if(treatAsACount()) {
      return ITM_COUNT_NONULL;
    } 
    return getOperatorType();
  }

  NABoolean topPartOfAggr() const { return amTopPartOfAggr_;}
  void setTopPartOfAggr() { amTopPartOfAggr_ = TRUE;}

  virtual NABoolean isSensitiveToDuplicates() const;

  // Each operator supports a (virtual) method for transforming its
  // scalar expressions to a canonical form
  virtual void transformNode(NormWA & normWARef,
			     ExprValueId & locationOfPointerToMe,
                             ExprGroupId & introduceSemiJoinHere,
			     const ValueIdSet & externalInputs);

  // Each operator supports a (virtual) method for transforming its
  // query tree to a canonical form.
  virtual ItemExpr * normalizeNode(NormWA & normWARef);

  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	              ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const;

  // --------------------------------------------------------------------
  // Walk through an ItemExpr tree and gather the ValueIds of those
  // expressions that behave as if they are "leaves" for the sake of
  // the coverage test, e.g., expressions that have no children, or
  // aggregate functions, or instantiate null. These are usually values
  // that are produced in one "scope" and referenced above that "scope"
  // in the dataflow tree for the query.
  // --------------------------------------------------------------------
  virtual void getLeafValuesForCoverTest(ValueIdSet & leafValues, 
                                         const GroupAttributes& coveringGA,
                                         const ValueIdSet & newExternalInputs) const;

  // method to do code generation
  virtual short codeGen(Generator*);
  virtual void codegen_and_set_attributes(Generator *, Attributes **, Lng32);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // A method for determining whether the evaluation of this aggregate
  // function can be staged.
  virtual NABoolean evaluationCanBeStaged() const;

  // rewriting aggregate functions for elimination, parallelization
  virtual ItemExpr * rewriteForElimination();
  virtual ItemExpr * rewriteForStagedEvaluation(
       ValueIdList &initialAggrs,
       ValueIdList &finalAggrs,
       NABoolean sameFormat = FALSE);

  NABoolean isEquivalentForBinding(const ItemExpr * other);

  virtual ValueId mapAndRewrite(ValueIdMap &map,
				NABoolean mapDownwards = FALSE);

  virtual NABoolean duplicateMatch(const ItemExpr & other) const;

  // get a printable string that identifies the operator
  virtual const NAString getText() const;

  // produce an ascii-version of the object (for display or saving into a file)
  virtual void unparse(NAString &result,
		       PhaseEnum phase = DEFAULT_PHASE,
		       UnparseFormatEnum form = USER_FORMAT,
		       TableDesc * tabId = NULL) const;

  #define ITM_COUNT_STAR__ORIGINALLY	REL_AGGREGATE
  ItemExpr *getOriginalChild() const		   { return origChild_; }
  void setOriginalChild(ItemExpr *c)		   { origChild_ = c; }

  NABoolean isOneRowTransformed_;

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}
  NABoolean isOLAP() { return isOLAP_; };

  void setOLAPInfo(ItemExpr *partBy, 
                   ItemExpr *orderBy,
                   Lng32 rowsStart,
                   Lng32 rowsEnd)
  {
    olapPartitionBy_ = partBy;
    olapOrderBy_ = orderBy;
    frameStart_ = rowsStart;
    frameEnd_ = rowsEnd;
    isOLAP_ = TRUE;
  };
  /*
  ItemExpr *getOlapPartitionBy() { return olapPartitionBy_; };
  ItemExpr *getOlapOrderBy() { return olapOrderBy_; };
  */

  Lng32 getframeStart()
  {
    return frameStart_;
  }

  Lng32 getframeEnd()
  {
    return frameEnd_;
  }

    NABoolean isFrameStartUnboundedPreceding() const
  {
    return (frameStart_ == -INT_MAX);
  }

   NABoolean isFrameStartUnboundedFollowing() const
  {
    return (frameStart_ == INT_MAX);
  }
  NABoolean isFrameEndUnboundedPreceding() const
  {
    return (frameEnd_ == -INT_MAX);
  }

  NABoolean isFrameEndUnboundedFollowing() const
  {
    return (frameEnd_ == INT_MAX);
  }

  virtual QR::ExprElement getQRExprElem() const;

  void setRollupGroupIndex(Int16 v) { rollupGroupIndex_ = v; }
  Int16 getRollupGroupIndex() { return rollupGroupIndex_; }

private:

  // The ValueId of the Item Expression that represents the result.
  // For example, if T(a int not null, b int not null), then the
  // result of sum(a,b) are the expressions a', b' where a' and b'
  // are both nullable.
  ValueId  result_;

  // indicate whether this is a DISTINCT aggregate
  NABoolean isDistinct_;

  // indicate whether this aggregate is for a scalar group by
  NABoolean inScalarGroupBy_;

  // ValueId of the distinct expression. usually, this is the
  // valueId of the child itemExpr, but in cases such as Variance,
  // it could be something different.
  ValueId distinctId_;

  // The original child specified by the user, before Parser and/or Binder
  // transformed it to something else.
  ItemExpr *origChild_;


  void setOlapOrderBy(ItemExpr *orderBy) { olapOrderBy_ = orderBy;};

  ItemExpr *removeOlapOrderBy()
  {
    ItemExpr *orderBy = olapOrderBy_;
    olapOrderBy_ = NULL;
    return orderBy;
  };

  ItemExpr *transformOlapFunction( BindWA *bindWA );
  OperatorTypeEnum mapOperTypeToRunning() const;
  OperatorTypeEnum mapOperTypeToOlap() const;
  OperatorTypeEnum mapOperTypeToMoving() const;

  // OLAP Info
  NABoolean isOLAP_;

  ItemExpr *olapPartitionBy_;
  ItemExpr *olapOrderBy_;

  Lng32 frameStart_;
  Lng32 frameEnd_;

  // true iff am top part of a rewritten COUNT aggregate
  NABoolean treatAsACount_;

  // true iff am top part of a rewritten aggregate
  NABoolean amTopPartOfAggr_;

  // this field indicates the index into rollupGroupExprList of GroupByAgg
  // that corresponds to the child of GROUPING aggr.
  Int16 rollupGroupIndex_;
}; // class Aggregate


// Variance -  Variance is an aggregate itemExpr derived from the
// Aggregate class.  This class implements the compiler side of the Variance
// and Stddev aggregates. This new class redefines the {con,de}structor, the
// bindNode method, and the getText method.  The other methods are NEVER called
// for this class and have (for now) been redefined to ASSERT if called.
//
// This node will be replaced during binding by an ItemExpr tree rooted
// by a ScalarVariance node. This new tree is bound and returned as the
// result of Variance::bindNode(). Because of this, the Variance node
// should never appear after binding.
//
class Variance : public Aggregate
{
public:
  // Variance implements the Item types ITM_VARIANCE, ITM_STDDEV
  // These Item types are also used by the ScalarVariance node and the
  // ExFunctionVariance and ExFunctionStddev builtin functions.

  // Constructor. - This aggregate can have one or two children.
  // The optional second parameter (child) is the weighting factor.
  //
  Variance(OperatorTypeEnum otype,
		  ItemExpr *child0 = NULL,
		  ItemExpr *child1 = NULL,
		  NABoolean isDistinct = FALSE)
    : Aggregate(otype, child0, child1, isDistinct)
  {}

  // virtual destructor
  virtual ~Variance();

  // a virtual function for performing name binding within the query tree.
  // This method will replace the Variance node with a tree of nodes rooted
  // by a ScalarVariance node. This new tree is bound and returned as the
  // result of bindNode of Variance. Because of this, the Variance node
  // should never appear after binding.
  //
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // MV --
  // In multi-delta refresh, copyTopNode() is called to dulicate the
  // unbound expression.
  virtual ItemExpr * copyTopNode(ItemExpr * = NULL, CollHeap* = 0);

  // The following virtual methods should never be called on the Variance
  // node.  They have been redefined to ASSERT if called.
  //
  virtual void transformNode(NormWA & normWARef,
			     ExprValueId & locationOfPointerToMe,
                             ExprGroupId & introduceSemiJoinHere,
			     const ValueIdSet & externalInputs)  {CMPASSERT(0)}
  virtual ItemExpr * normalizeNode(NormWA & normWARef){CMPASSERT(0); return 0;}
  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	              ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const
  						  {CMPASSERT(0); return TRUE;}
  virtual void getLeafValuesForCoverTest(ValueIdSet & leafValues, 
                      const GroupAttributes& coveringGA, const ValueIdSet & newExternalInputs
		      ) const {CMPASSERT(0);}
  virtual short codeGen(Generator*)		  {CMPASSERT(0); return 0;}
  virtual NABoolean evaluationCanBeStaged() const {CMPASSERT(0); return TRUE;}
  virtual ItemExpr * rewriteForElimination()	  {CMPASSERT(0); return 0;}
  virtual ItemExpr * rewriteForStagedEvaluation(
       ValueIdList &initialAggrs,
       ValueIdList &finalAggrs,
       NABoolean sameFormat = FALSE)		  {CMPASSERT(0); return 0;}


private:
}; // class Variance

class PivotGroup : public Aggregate
{
public:
  enum PivotOptionType
  {
    DELIMITER_,
    ORDER_BY_,
    MAX_LENGTH_
  };

  enum {
    DEFAULT_MAX_LEN = 1024
  };

  class PivotOption
  {
    friend class PivotGroup;
  public:
  PivotOption(PivotOptionType option, 
              void * optionNode = NULL,
              char * stringVal = NULL,
              Long numericVal = 0)
    : option_(option), 
      optionNode_(optionNode),
      stringVal_(stringVal),
      numericVal_(numericVal)
    {}
    
  private:
    PivotOptionType option_;
    void * optionNode_;
    Long   numericVal_;
    char * stringVal_;
  };

  // PivotGroup implements the Item ITM_PIVOT_GROUP.
  // This is used to implement pivot groups.

  // Constructor. - This aggregate can have one or two children.
  // The optional second parameter (child) is the weighting factor.
  //
  PivotGroup(OperatorTypeEnum otype,
             ItemExpr *child0,
             NAList<PivotOption*> * pivotOptionsList,
             NABoolean isDistinct = FALSE);

  PivotGroup(OperatorTypeEnum otype,
             ItemExpr *child0,
             NAString &delim,
             NABoolean orderBy,
             ValueIdList &reqdOrder,
             Lng32 maxLen,
             NABoolean isDistinct = FALSE)
  : Aggregate(otype, child0, NULL, isDistinct),
    delim_(delim),
    orderBy_(orderBy),
    reqdOrder_(reqdOrder),
    maxLen_(maxLen)
    {}
  
  // virtual destructor
  virtual ~PivotGroup();

  const NAType *synthesizeType();

  // a virtual function for performing name binding within the query tree.
  virtual ItemExpr * bindNode(BindWA *bindWA);

  virtual ItemExpr * copyTopNode(ItemExpr * = NULL, CollHeap* = 0);

  virtual ItemExpr * preCodeGen(Generator * generator);

  virtual short codeGen(Generator*);

  // append an ascii-version of BETWEEN into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

  virtual NABoolean evaluationCanBeStaged() const {return TRUE;}
  virtual ItemExpr * rewriteForStagedEvaluation(
       ValueIdList &initialAggrs,
       ValueIdList &finalAggrs,
       NABoolean sameFormat = FALSE);

  NAString &delim() { return delim_; }
  NABoolean orderBy() { return orderBy_;}
  ValueIdList &reqdOrder() { return reqdOrder_; }
  Lng32 maxLen() { return maxLen_; }
  ItemExpr *getOrderbyItemExpr() { return orgReqOrder_; } 
private:
  NAList<PivotOption*> * pivotOptionsList_;

  NAString delim_;

  NABoolean orderBy_;
  ValueIdList reqdOrder_;   	// ORDER BY list
  ItemExpr *orgReqOrder_;
  
  Lng32 maxLen_;
}; // class PivotGroup

// -----------------------------------------------------------------------
// Function operators supporting a variable number of children
// -----------------------------------------------------------------------
class Function : public ItemExpr
{
  // ITM_BETWEEN, ITM_LIKE, ITM_USER_DEF_FUNCTION
public:

  Function(OperatorTypeEnum otype = ITM_USER_DEF_FUNCTION,
           NAMemory *h = CmpCommon::statementHeap(),
	   Lng32 argumentCount = 0,
	   ItemExpr *child0 = NULL,
	   ItemExpr *child1 = NULL,
	   ItemExpr *child2 = NULL,
	   ItemExpr *child3 = NULL,
	   ItemExpr *child4 = NULL,
	   ItemExpr *child5 = NULL);
  
  Function(OperatorTypeEnum otype,
           const LIST(ItemExpr *) &children,
           CollHeap *h=CmpCommon::statementHeap());
  
  //Function(OperatorTypeEnum otype, NABoolean isLeaf)
  //  : ItemExpr(otype),
  //    children_(CmpCommon::statementHeap()),
  //    allowsSQLnullArg_(TRUE)
  //{};
  
  // virtual destructor
  virtual ~Function();

  // ## This should be moved to ExprNode.h.
  // ## See how Aggregate::getArity() duplicates its logic...
  Lng32 getNumChildren() const;

  NABoolean &allowsSQLnullArg()		     	{ return allowsSQLnullArg_; }

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual NABoolean duplicateMatch(const ItemExpr & other) const;

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // since this operator may have variable arity, the access operators
  // to its children are overloaded and use a private child list
  virtual ExprValueId & operator[] (Lng32 ix);
  virtual const ExprValueId & operator[] (Lng32 ix) const;

  // for cases where a named method is more convenient than operator []
  ExprValueId & child(Lng32 index)      		{ return operator[](index); }
  const ExprValueId & child(Lng32 index) const	{ return operator[](index); }

  ARRAY(ExprValueId) &children()  { return children_; }

  virtual NABoolean isOrderPreserving() const;

  // by default, we do NOT want Function itemexprs to be cacheable as a
  // guard against false cache hits. However, we selectively override this
  // in derived classes after guarding against false cache hits there.
  virtual NABoolean isCacheableExpr(CacheWA& cwa) { return FALSE; }

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const
    { ItemExpr::generateCacheKey(cwa); }

  virtual QR::ExprElement getQRExprElem() const;

private:

  // Whether the SQL NULL keyword (our NULL ConstValue) may appear
  // in the argument list of this function.
  NABoolean allowsSQLnullArg_;

  ARRAY(ExprValueId) children_;

};

// -----------------------------------------------------------------------
// Built-in functions
// -----------------------------------------------------------------------
class BuiltinFunction : public Function
{
  // ITM_BETWEEN, ITM_LIKE, ITM_CURRENT and more
public:
  BuiltinFunction(OperatorTypeEnum otype,
                  NAMemory *h = CmpCommon::statementHeap(),
		  Lng32  argumentCount = 0,
		  ItemExpr *child0 = NULL,
		  ItemExpr *child1 = NULL,
		  ItemExpr *child2 = NULL,
		  ItemExpr *child3 = NULL,
		  ItemExpr *child4 = NULL,
		  ItemExpr *child5 = NULL);
  
  BuiltinFunction(OperatorTypeEnum otype,
                  NAMemory *h,
		  const LIST(ItemExpr *) &children)
       : Function(otype,children,h) {}
  
  // virtual destructor
  virtual ~BuiltinFunction();

  // get the degree of this node (it depends on the type of the operator)
  virtual Int32 getArity() const;

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // Each operator supports a (virtual) method for transforming its
  // scalar expressions to a canonical form
  virtual void transformNode(NormWA & normWARef,
			     ExprValueId & locationOfPointerToMe,
                             ExprGroupId & introduceSemiJoinHere,
			     const ValueIdSet & externalInputs);

  // Each operator supports a (virtual) method for transforming its
  // query tree to a canonical form.
  virtual ItemExpr * normalizeNode(NormWA & normWARef);

  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	              ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const;

  virtual NABoolean isCacheableExpr(CacheWA& cwa);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // get a printable string that identifies the operator
  virtual const NAString getText() const;

  // see ExprNode.h for explanation.
  virtual const NAString getTextForError() const;

  // This method tells if a VEG transformation can potentially
  // change the result of this function.
  // For ex., a query "select char_length(a) from t where a = 'v'"
  // where column 'a' is 2 bytes, will return 1 if column 'a' in
  // char_length function is replaced by constant "v".
  // This method must be redefined to return TRUE for
  // any function that can get changed by a VEG transformation.
  // See BuiltinFunction::bindNode in BindItemExpr.cpp on
  // how these functions are protected.
  virtual NABoolean protectFromVEGs()
  {
    return FALSE;
  }

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const
    { Function::generateCacheKey(cwa); }

  virtual NABoolean calculateMinMaxUecs(ColStatDescList & histograms,
					       CostScalar & minUec,
					       CostScalar & maxUec);

private:

}; // class BuiltinFunction

class CacheableBuiltinFunction : public BuiltinFunction
{
public:
  CacheableBuiltinFunction
    (OperatorTypeEnum otype,
     Lng32  argumentCount = 0,
     ItemExpr *child0 = NULL,
     ItemExpr *child1 = NULL,
     ItemExpr *child2 = NULL,
     ItemExpr *child3 = NULL,
     ItemExpr *child4 = NULL,
     ItemExpr *child5 = NULL)
    : BuiltinFunction
      (otype,CmpCommon::statementHeap(),
       argumentCount,child0,child1,child2,child3,child4,child5) {}

  // classes derived from CacheableBuiltinFunction are cacheable
  virtual NABoolean isCacheableExpr(CacheWA& cwa)
    { return ItemExpr::isCacheableExpr(cwa); }

  // -----------------------------------------------------------------
  // NB: By default, we want to parameterize us and our children. This 
  // is accomplished by inheriting our base class' normalizeForCache.
  // If it is unsafe to parameterize, we (the derived class)
  // must supply its own implementation of normalizeForCache.
  // -----------------------------------------------------------------

  // -----------------------------------------------------------------------
  // NB: If derived class has its own data member(s), we must make its data
  // member(s) contribute to its cache key via our own generateCacheKey here.
  // ------------------------------------------------------------------------
}; // class CacheableBuiltinFunction

//++Triggers,
//
// Built in function that should be evaluate only once
class EvaluateOnceBuiltinFunction : public BuiltinFunction
{
public:
  EvaluateOnceBuiltinFunction(OperatorTypeEnum otype,
			 Lng32  argumentCount = 0,
			 ItemExpr *child0 = NULL,
			 ItemExpr *child1 = NULL,
			 ItemExpr *child2 = NULL,
			 ItemExpr *child3 = NULL,
			 ItemExpr *child4 = NULL,
			 ItemExpr *child5 = NULL)
    : BuiltinFunction(otype,CmpCommon::statementHeap(),argumentCount,
                      child0,child1,child2,child3,child4,child5)
     {}

  inline EvaluateOnceBuiltinFunction(OperatorTypeEnum otype,
			 const LIST(ItemExpr *) &children)
			 : BuiltinFunction(otype,
                                           CmpCommon::statementHeap(),
                                           children) {}

  // virtual destructor
  virtual ~EvaluateOnceBuiltinFunction();

  // should return always true
  virtual NABoolean isAUserSuppliedInput() const;

  // should return always false
  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	          ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const;

}; // class EvaluateOnceBuiltinFunction


class UniqueExecuteId : public EvaluateOnceBuiltinFunction
{
public:
  UniqueExecuteId()
	: EvaluateOnceBuiltinFunction(ITM_UNIQUE_EXECUTE_ID) {}

  // virtual destructor
  virtual ~UniqueExecuteId();

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);


  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class UniqueExecuteId

class GetTriggersStatus : public EvaluateOnceBuiltinFunction
{
public:
  GetTriggersStatus()
	: EvaluateOnceBuiltinFunction(ITM_GET_TRIGGERS_STATUS) {}

  // virtual destructor
  virtual ~GetTriggersStatus();

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);


  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class GetTriggersStatus

class GetBitValueAt : public BuiltinFunction
{
public:
  GetBitValueAt(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
       : BuiltinFunction(ITM_GET_BIT_VALUE_AT, CmpCommon::statementHeap(), 
                         2, val1Ptr, val2Ptr)
	 { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~GetBitValueAt();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class GetBitValueAt
//--Triggers,

// MV,
// Functions that are additional outputs of GenericUpdate nodes.
// Used for MV Inlining.
// Supported functions: ITM_CURRENTEPOCH, ITM_VSBBROWTYPE, ITM_VSBBROWCOUNT.
class GenericUpdateOutputFunction : public BuiltinFunction
{
public:
  GenericUpdateOutputFunction(OperatorTypeEnum otype,
			 Lng32  argumentCount = 0,
			 ItemExpr *child0 = NULL,
			 ItemExpr *child1 = NULL,
			 ItemExpr *child2 = NULL,
			 ItemExpr *child3 = NULL,
			 ItemExpr *child4 = NULL,
			 ItemExpr *child5 = NULL)
    : BuiltinFunction(otype,CmpCommon::statementHeap(),
                      argumentCount,child0,child1,child2,child3,child4,child5)
     {}

  inline GenericUpdateOutputFunction(OperatorTypeEnum otype,
			 const LIST(ItemExpr *) &children)
			 : BuiltinFunction(otype,
                                           CmpCommon::statementHeap(),
                                           children) {}

  // virtual destructor
  virtual ~GenericUpdateOutputFunction() {}

  // should return always false
  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	          ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const
  { return FALSE; }

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // Is this a subclass of GenericUpdateOutput BuildinFunction?
  virtual NABoolean isAGenericUpdateOutputFunction() const
  { return TRUE; }

}; // class GenericUpdateOutputFunction

//++MV
class IsBitwiseAndTrue : public BuiltinFunction
{
public:
  IsBitwiseAndTrue(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
       : BuiltinFunction(ITM_IS_BITWISE_AND_TRUE, CmpCommon::statementHeap(),
                         2, val1Ptr, val2Ptr)
	 { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~IsBitwiseAndTrue();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class GetBitValueAt
//--MV

class CodeVal : public CacheableBuiltinFunction
{
public:
  CodeVal(OperatorTypeEnum op, ItemExpr *val1Ptr)
    : CacheableBuiltinFunction(op, 1, val1Ptr)
    { allowsSQLnullArg() = FALSE; }

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  ItemExpr* tryToRelaxCharTypeMatchRules(BindWA *bindWA);
  NABoolean isRelaxCharTypeMatchRulesPossible() {return TRUE;};

  // special version of getText() that can handle NO_OPERATOR_TYPE opertor type.
  const NAString getText() const;

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class CodeVal

/////////////////////////////////////////////////////////////////
// This function is created by generator and is used to
// evaluate MIN and MAX aggr functions. It is created based
// on the original Aggregate node created by the parser.
// The first child points to
// the child of original Aggregate node. The second child points
// to an expression whose result, if TRUE, indicates that the first
// child is the new aggregate value.
// For MIN, the second child is:   "child1 < min-aggr"
// For MAX, the second child is:   "child1 > max-aggr".
// See generateAggrExpr in GenExpGenerator.C for details.
/////////////////////////////////////////////////////////////////
class AggrMinMax : public BuiltinFunction
{
public:
  AggrMinMax(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
    : BuiltinFunction(ITM_AGGR_MIN_MAX, CmpCommon::statementHeap(),
                      2, val1Ptr, val2Ptr) {}

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class AggrMinMax

/////////////////////////////////////////////////////////////////
// This function is created by generator and is used to
// evaluate GROUPING function.
/////////////////////////////////////////////////////////////////
class AggrGrouping : public BuiltinFunction
{
public:
  AggrGrouping(Int16 rollupGroupIndex = -1)
       : BuiltinFunction(ITM_AGGR_GROUPING_FUNC, CmpCommon::statementHeap()),
         rollupGroupIndex_(rollupGroupIndex)
  {}

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

private:
  // this field indicates the index into rollupGroupExprList of GroupByAgg
  // that corresponds to the child of GROUPING aggr.
  Int16 rollupGroupIndex_;

}; // class AggrGrouping

class AnsiUSERFunction : public BuiltinFunction
{
public:
  AnsiUSERFunction(OperatorTypeEnum oper)
         : BuiltinFunction(oper) {}

  // virtual destructor
  virtual ~AnsiUSERFunction();

  virtual NABoolean isAUserSuppliedInput() const;

  virtual ItemExpr * bindNode(BindWA *bindWA);
  virtual const NAType * synthesizeType();
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class AnsiUSERFunction

// Tandem extension, USER(stringArg),
// as opposed to the Ansi USER keyword (no parens).
class MonadicUSERFunction : public BuiltinFunction
{
public:
  MonadicUSERFunction(ItemExpr *val1Ptr,OperatorTypeEnum otype = ITM_USER)
       : BuiltinFunction(otype, CmpCommon::statementHeap(),
                         1, val1Ptr) {}

  // virtual destructor
  virtual ~MonadicUSERFunction();

  virtual NABoolean isAUserSuppliedInput() const;

  virtual ItemExpr * bindNode(BindWA *bindWA);
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	              ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const;


}; // class MonadicUSERFunction

// Tandem extension, OS_USERID(stringArg),
class MonadicUSERIDFunction : public BuiltinFunction
{
public:
  MonadicUSERIDFunction(ItemExpr *val1Ptr)
       : BuiltinFunction(ITM_USERID, CmpCommon::statementHeap(),
                         1, val1Ptr) {}

  // virtual destructor
  virtual ~MonadicUSERIDFunction();

  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class MonadicUSERIDFunction

class Between : public CacheableBuiltinFunction
{
public:

  // boundriesIncluded for values L,R meens [L,R]. not meens (L,R).
  // the direction vector is for the ASC/DESC attributes of the values item
  Between(ItemExpr *colPtr,
	  ItemExpr *val1Ptr,
	  ItemExpr *val2Ptr,
	  NABoolean leftBoundryIncluded = TRUE, //++ MV OZ
	  NABoolean rightBoundryIncluded = TRUE //++ MV OZ
	  )
         : leftBoundryIncluded_(leftBoundryIncluded),
	   rightBoundryIncluded_(rightBoundryIncluded),
	   pDirectionVector_(NULL),
	   CacheableBuiltinFunction(ITM_BETWEEN, 3, colPtr, val1Ptr, val2Ptr)
  {
    allowsSQLnullArg() = FALSE;
  }

  // virtual destructor
  virtual ~Between();

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA * bindWA);

  // if we are allowing certain incompatible comparisons handle them.
  // currently the following incompatible comparisons are supported:
  // 1. Date and Character literal
  // This returns a pointer to itself if everything goes fine
  // otherwise it returns NULL
  Between * handleIncompatibleComparison(BindWA *bindWA);

  //++ MV OZ
  void setDirectionVector(const IntegerList & directionVector,
			  CollHeap* heap);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  NABoolean isRelaxCharTypeMatchRulesPossible() {return TRUE;};

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean isAPredicate() const { return TRUE; }

  // check and apply substr transformation
  ItemExpr* checkAndApplySubstrTransformation();

  // Each operator supports a (virtual) method for transforming its
  // scalar expressions to a canonical form
  virtual void transformNode(NormWA & normWARef,
			     ExprValueId & locationOfPointerToMe,
                             ExprGroupId & introduceSemiJoinHere,
			     const ValueIdSet & externalInputs);

  // A method for inverting (finding the inverse of) the operators
  // in a subtree that is rooted in a NOT.
  virtual ItemExpr * transformSubtreeOfNot(NormWA & normWARef,
                                           OperatorTypeEnum falseOrNot);

  // A virtual method for transforming this predicate
  // if all children (by default; can be any one child) are ItemList.
  // Returns NULL if no transformation was necessary.
  virtual ItemExpr * transformMultiValuePredicate(
				    NABoolean flattenSubqueries = TRUE,
				    ChildCondition condBiRelat = ANY_CHILD);

  ItemExpr * transformIntoTwoComparisons();

  // produce an ascii-version of the object (for display or saving into a file)
  virtual void unparse(NAString &result,
		       PhaseEnum phase = DEFAULT_PHASE,
		       UnparseFormatEnum form = USER_FORMAT,
		       TableDesc * tabId = NULL) const;

  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);

  // for now, do NOT change literals of BETWEEN into constant parameters
  virtual ItemExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA)
    { return this; } 

  // append an ascii-version of BETWEEN into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

  virtual NABoolean hasEquivalentProperties(ItemExpr * other);

private:

  NABoolean    leftBoundryIncluded_;
  NABoolean    rightBoundryIncluded_;
  IntegerList *pDirectionVector_;

}; // class Between

class BoolResult : public BuiltinFunction
{
  // Evaluates the final boolean result value for a predicate.
  // A NULL or FALSE final result becomes FALSE.
  // TRUE final result remains TRUE.
public:
  BoolResult(ItemExpr *val1Ptr)
       : BuiltinFunction(ITM_BOOL_RESULT, CmpCommon::statementHeap(),
                         1, val1Ptr)
      {}

  // virtual destructor
  virtual ~BoolResult();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class BoolResult

class CharFunc : public BuiltinFunction
{
public:
  CharFunc(CharInfo::CharSet cs, ItemExpr *val1Ptr)
    : BuiltinFunction((cs == CharInfo::UNICODE) ? ITM_UNICODE_CHAR : ITM_CHAR,
                      CmpCommon::statementHeap(),
                      1, val1Ptr),
      charSet_(cs)
    { allowsSQLnullArg() = FALSE; }

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * preCodeGen(Generator*);

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

private:
  CharInfo::CharSet charSet_;

  virtual NABoolean protectFromVEGs() { return TRUE; };

}; // class CharFunc


class PatternMatchingFunction : public CacheableBuiltinFunction
{
public:
  PatternMatchingFunction(OperatorTypeEnum optype, ItemExpr *matchValue, ItemExpr *pattern)
  : CacheableBuiltinFunction(optype, 2, matchValue, pattern),
   numberOfNonWildcardChars_(-1), patternAStringLiteral_(FALSE),
   bytesInNonWildcardChars_(-1),
   oldDefaultSelForLikeWildCardUsed_(FALSE), beginEndKeysApplied_(FALSE)
  { 
    allowsSQLnullArg() = FALSE;
    setCollation(CharInfo::DefaultCollation);
  }

  PatternMatchingFunction(OperatorTypeEnum optype, ItemExpr *matchValue, ItemExpr *pattern, ItemExpr *escapeChar)
  : CacheableBuiltinFunction(optype, 3, matchValue, pattern, escapeChar),
   numberOfNonWildcardChars_(-1), patternAStringLiteral_(FALSE),
   bytesInNonWildcardChars_(-1),
   oldDefaultSelForLikeWildCardUsed_(FALSE), beginEndKeysApplied_(FALSE)
  { 
    allowsSQLnullArg() = FALSE; 
    setCollation(CharInfo::DefaultCollation);
  }

  PatternMatchingFunction(OperatorTypeEnum optype,ItemExpr *matchValue, ItemExpr *pattern, Int32 numNonWild, Int32 bytesInNonWild,
    NABoolean stringPattern, NABoolean oldDefaultUsed, 
    NABoolean beginEndKeysApplied)
  : CacheableBuiltinFunction(optype, 2, matchValue, pattern),
   numberOfNonWildcardChars_(numNonWild), 
   bytesInNonWildcardChars_(bytesInNonWild),
   patternAStringLiteral_(stringPattern),
   oldDefaultSelForLikeWildCardUsed_(oldDefaultUsed),
   beginEndKeysApplied_(beginEndKeysApplied)
  { 
    allowsSQLnullArg() = FALSE;
    setCollation(CharInfo::DefaultCollation);
  }

  PatternMatchingFunction(OperatorTypeEnum optype,ItemExpr *matchValue, ItemExpr *pattern, ItemExpr *escapeChar,  
    Int32 numNonWild, Int32 bytesInNonWild,NABoolean stringPattern, NABoolean oldDefaultUsed,
    NABoolean beginEndKeysApplied)
  : CacheableBuiltinFunction(optype, 3, matchValue, pattern, escapeChar),
   numberOfNonWildcardChars_(numNonWild), 
   bytesInNonWildcardChars_(bytesInNonWild),
   patternAStringLiteral_(stringPattern),
   oldDefaultSelForLikeWildCardUsed_(oldDefaultUsed),
   beginEndKeysApplied_(beginEndKeysApplied)
  { 
    allowsSQLnullArg() = FALSE; 
    setCollation(CharInfo::DefaultCollation);
  }

  // virtual destructor
  virtual ~PatternMatchingFunction();

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // change only constant matchValue of a PatternMatchingFunction into ConstantParameter
  virtual ItemExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA);

  // append an ascii-version of PatternMatchingFunction into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  NABoolean isRelaxCharTypeMatchRulesPossible() {return TRUE;};

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0) { return NULL; }

  // predicateEliminatesNullAugmentedRows() determines whether the
  // the predicate is capable of discarding null augmented rows 
  // produced by a left join.

  virtual NABoolean predicateEliminatesNullAugmentedRows(NormWA &, ValueIdSet &);

  virtual NABoolean isAPredicate() const { return TRUE; }

  // The 'LIKE' builtin function doesn't override the virtual function
  // synthSupportedOp, because it doesn't have shape-changing impact on
  // histograms.  But, it does override the virtual function defaultSel,
  // because a LIKE's default selectivity varies based on the pattern
  // being matched.
  virtual double defaultSel();

  NABoolean beginEndKeysApplied(CollHeap *outHeap);
  Int32 getNoOfNonWildcardChars()    { return numberOfNonWildcardChars_ ; };
  Int32 getBytesInNonWildcardChars()    { return bytesInNonWildcardChars_ ; };

  virtual NABoolean protectFromVEGs() { return TRUE; };

  double computeSelForNonWildcardChars();

  NABoolean isPatternAStringLiteral() { return patternAStringLiteral_ ;}
  void setPatternAStringLiteral(NABoolean flag = TRUE) 
      { patternAStringLiteral_ = flag; }

  CharInfo::Collation getCollation()
  {
    return collation_;
  }

  void setCollation(CharInfo::Collation c)
  {
    collation_ = c;
  }
  virtual NABoolean hasEquivalentProperties(ItemExpr * other);

   virtual void unparse(NAString &result,
     PhaseEnum phase = DEFAULT_PHASE,
     UnparseFormatEnum form = USER_FORMAT,
     TableDesc * tabId = NULL) const;


  virtual ItemExpr *applyBeginEndKeys(BindWA *bindWA, ItemExpr *boundExpr, CollHeap *h) { return NULL; }
protected:
  void setNumberOfNonWildcardChars(const LikePatternString &pattern);

  Int32 numberOfNonWildcardChars_;
  Int32 bytesInNonWildcardChars_;

  NABoolean patternAStringLiteral_;

  NABoolean oldDefaultSelForLikeWildCardUsed_;

  NABoolean beginEndKeysApplied_;

  CharInfo::Collation collation_;
  
}; // class PatternMatchingFunction


class Like : public PatternMatchingFunction
{
public:
  Like(ItemExpr *matchValue, ItemExpr *pattern)
  : PatternMatchingFunction(ITM_LIKE, matchValue, pattern)
  { 
    allowsSQLnullArg() = FALSE;
    setCollation(CharInfo::DefaultCollation);
  }

  Like(ItemExpr *matchValue, ItemExpr *pattern, ItemExpr *escapeChar)
  : PatternMatchingFunction(ITM_LIKE, matchValue, pattern, escapeChar)
  { 
    allowsSQLnullArg() = FALSE; 
    setCollation(CharInfo::DefaultCollation);
  }

  Like(ItemExpr *matchValue, ItemExpr *pattern, Int32 numNonWild, Int32 bytesInNonWild,
    NABoolean stringPattern, NABoolean oldDefaultUsed, 
    NABoolean beginEndKeysApplied)
  : PatternMatchingFunction(ITM_LIKE, matchValue, pattern,numNonWild,bytesInNonWild,
     stringPattern,oldDefaultUsed, beginEndKeysApplied)
  { 
    allowsSQLnullArg() = FALSE;
    setCollation(CharInfo::DefaultCollation);
  }

  Like(ItemExpr *matchValue, ItemExpr *pattern, ItemExpr *escapeChar,  
    Int32 numNonWild, Int32 bytesInNonWild,NABoolean stringPattern, NABoolean oldDefaultUsed,
    NABoolean beginEndKeysApplied)
  : PatternMatchingFunction(ITM_LIKE, matchValue, pattern, escapeChar,numNonWild,bytesInNonWild,
     stringPattern,oldDefaultUsed,beginEndKeysApplied) 
  { 
    allowsSQLnullArg() = FALSE; 
    setCollation(CharInfo::DefaultCollation);
  }

  // virtual destructor
  virtual ~Like();
  ItemExpr *applyBeginEndKeys(BindWA *bindWA, ItemExpr *boundExpr, CollHeap *h);
  ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
}; // class Like

class Regexp : public PatternMatchingFunction
{
public:
  Regexp(ItemExpr *matchValue, ItemExpr *pattern)
  : PatternMatchingFunction(ITM_REGEXP, matchValue, pattern)
  { 
    allowsSQLnullArg() = FALSE;
    setCollation(CharInfo::DefaultCollation);
  }

  Regexp(ItemExpr *matchValue, ItemExpr *pattern, Int32 numNonWild, Int32 bytesInNonWild,
    NABoolean stringPattern, NABoolean oldDefaultUsed, 
    NABoolean beginEndKeysApplied)
  : PatternMatchingFunction(ITM_REGEXP, matchValue, pattern,numNonWild,bytesInNonWild,
     stringPattern,oldDefaultUsed, beginEndKeysApplied)
  { 
    allowsSQLnullArg() = FALSE;
    setCollation(CharInfo::DefaultCollation);
  }

  // virtual destructor
  virtual ~Regexp();
  ItemExpr *applyBeginEndKeys(BindWA *bindWA, ItemExpr *boundExpr, CollHeap *h);
  ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
}; // class Regexp
 
class NoOp : public BuiltinFunction
{
  // Does nothing. An ItemExpr place holder. Used by
  // generator to indicate the end of genrated clauses.
public:
  NoOp(ItemExpr *val1Ptr)
       : BuiltinFunction(ITM_NO_OP, CmpCommon::statementHeap(),
                         1, val1Ptr)
      {};

  // virtual destructor
  virtual ~NoOp();

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class NoOp

// this class return the specified boolean value (TRUE, FALSE, or NULL).
class BoolVal : public BuiltinFunction
{
public:
  BoolVal(OperatorTypeEnum bool_type)
         : BuiltinFunction(bool_type) {}
  BoolVal(OperatorTypeEnum bool_type, ItemExpr *val1Ptr)
         : BuiltinFunction(bool_type,  CmpCommon::statementHeap(),
                           1, val1Ptr) {}

  // virtual destructor
  virtual ~BoolVal();

  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	              ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const;

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  
  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}
  // MDAM related methods
  // Performs the MDAM tree walk.  See ItemExpr.h for a detailed description.
  DisjunctArray * mdamTreeWalk();

private:

}; // class BoolVal

class In : public CacheableBuiltinFunction
{
public:
  In(ItemExpr *leftPtr, ItemExpr *rightPtr)
         : CacheableBuiltinFunction(ITM_IN, 2, leftPtr, rightPtr) {}

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  NABoolean isRelaxCharTypeMatchRulesPossible() {return TRUE;};

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class In


class Concat : public CacheableBuiltinFunction
{
public:
  Concat(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
         : CacheableBuiltinFunction(ITM_CONCAT, 2, val1Ptr, val2Ptr)
	 { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~Concat();

  // do not change literals of a cacheable query into constant parameters
  virtual ItemExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA)
    { return this; }

  // The following method enables expressions such as
  // iso88591_column = :ucs2_hv1 || :ucs2_hv2
  NABoolean isCharTypeMatchRulesRelaxable()
  { return child(0)->isCharTypeMatchRulesRelaxable() &&
           child(1)->isCharTypeMatchRulesRelaxable();
  } ;

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  NABoolean isRelaxCharTypeMatchRulesPossible() {return TRUE;};

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean protectFromVEGs() { return TRUE; };

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class Concat

class ConvertHex : public CacheableBuiltinFunction
{
public:
  ConvertHex(OperatorTypeEnum op, ItemExpr *val1Ptr)
         : CacheableBuiltinFunction(op, 1, val1Ptr)
	 { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~ConvertHex();

  // do not change literals of a cacheable query into constant parameters
  virtual ItemExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA)
    { return this; }

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual NABoolean protectFromVEGs() { return TRUE; };

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class ConvertHex

class CharLength : public CacheableBuiltinFunction
{
public:
  CharLength(ItemExpr *val1Ptr)
         : CacheableBuiltinFunction(ITM_CHAR_LENGTH, 1, val1Ptr)
	 { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~CharLength();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean protectFromVEGs() { return TRUE; };

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class CharLength

class OctetLength : public CacheableBuiltinFunction
{
public:
  OctetLength(ItemExpr *val1Ptr)
         : CacheableBuiltinFunction(ITM_OCTET_LENGTH, 1, val1Ptr)
	 { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~OctetLength();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  virtual NABoolean protectFromVEGs() { return TRUE; };

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class OctetLength

class PositionFunc : public CacheableBuiltinFunction
{
public:
  PositionFunc(ItemExpr *val1Ptr, ItemExpr *val2Ptr, ItemExpr *val3Ptr,
               ItemExpr *val4Ptr)
         : CacheableBuiltinFunction(ITM_POSITION, 4, 
                                    val1Ptr, val2Ptr, val3Ptr, val4Ptr)
	 { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~PositionFunc();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  virtual ItemExpr * preCodeGen(Generator*);


  virtual NABoolean protectFromVEGs() { return TRUE; };

  NABoolean isRelaxCharTypeMatchRulesPossible() {return TRUE;};

  void setCollation(CharInfo::Collation  v) 
  {
    collation_= v;
  }
  
  CharInfo::Collation getCollation() 
  { 
    return collation_;
  }


private:
  CharInfo::Collation collation_;

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

  
}; // class PositionFunc

class Substring : public CacheableBuiltinFunction
{
public:
  Substring(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
         : CacheableBuiltinFunction(ITM_SUBSTR, 2, val1Ptr, val2Ptr)
	 { allowsSQLnullArg() = FALSE; }
  Substring(ItemExpr *val1Ptr, ItemExpr *val2Ptr, ItemExpr *val3Ptr)
         : CacheableBuiltinFunction(ITM_SUBSTR, 3, val1Ptr, val2Ptr, val3Ptr)
	 { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~Substring();

  // change literals of a cacheable query into constant parameters
  virtual ItemExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA);

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  NABoolean isCharTypeMatchRulesRelaxable()
  { return child(0)->isCharTypeMatchRulesRelaxable(); } ;

  virtual ItemExpr * preCodeGen(Generator*);

  virtual NABoolean protectFromVEGs() { return TRUE; };
  virtual NABoolean calculateMinMaxUecs(ColStatDescList & histograms,
					       CostScalar & minUec,
					       CostScalar & maxUec);

  
  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}
  

}; // class Substring

class ConvertTimestamp : public CacheableBuiltinFunction
{
public:
  ConvertTimestamp(ItemExpr *val1Ptr)
	: CacheableBuiltinFunction(ITM_CONVERTTIMESTAMP, 1, val1Ptr)
	{ allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~ConvertTimestamp();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual ItemExpr * preCodeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}
}; // class ConvertTimestamp

class SleepFunction : public CacheableBuiltinFunction
{
public:

  SleepFunction( ItemExpr *val1Ptr )
   : CacheableBuiltinFunction(ITM_SLEEP, 1, val1Ptr)
  {}
  // virtual destructor
  virtual ~SleepFunction();

  // A method that returns for "user-given" input values.
  // These are values that are either constants, host variables, parameters,
  // or even values that are sensed from the environment such as
  // current time, the user name, etcetera.
  virtual NABoolean isAUserSuppliedInput() const;

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class SleepFunction 

class UnixTimestamp : public CacheableBuiltinFunction
{
public:
  UnixTimestamp()
   : CacheableBuiltinFunction(ITM_UNIX_TIMESTAMP)
  {}

  UnixTimestamp( ItemExpr *val1Ptr )
   : CacheableBuiltinFunction(ITM_UNIX_TIMESTAMP, 1, val1Ptr)
  {}
  // virtual destructor
  virtual ~UnixTimestamp();

  // A method that returns for "user-given" input values.
  // These are values that are either constants, host variables, parameters,
  // or even values that are sensed from the environment such as
  // current time, the user name, etcetera.
  virtual NABoolean isAUserSuppliedInput() const;

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class UnixTimestamp

class CurrentTimestamp : public CacheableBuiltinFunction
{
public:
 CurrentTimestamp(DatetimeType::Subtype dtCode = DatetimeType::SUBTYPE_SQLTimestamp,
                  Lng32 fractPrec = SQLTimestamp::DEFAULT_FRACTION_PRECISION)
   : CacheableBuiltinFunction(ITM_CURRENT_TIMESTAMP),
    dtCode_(dtCode),
    fractPrec_(fractPrec)
  {}

  // virtual destructor
  virtual ~CurrentTimestamp();

  // A method that returns for "user-given" input values.
  // These are values that are either constants, host variables, parameters,
  // or even values that are sensed from the environment such as
  // current time, the user name, etcetera.
  virtual NABoolean isAUserSuppliedInput() const;

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

  static ItemExpr * construct
    (CollHeap * heap, 
     DatetimeType::Subtype dtCode = DatetimeType::SUBTYPE_SQLTimestamp,
     Lng32 fractPrec = SQLTimestamp::DEFAULT_FRACTION_PRECISION);

 private:
  DatetimeType::Subtype dtCode_;
  Lng32 fractPrec_;
}; // class CurrentTimestamp

class CurrentTimestampRunning : public CacheableBuiltinFunction
{
public:
  CurrentTimestampRunning()
	: CacheableBuiltinFunction(ITM_CURRENT_TIMESTAMP_RUNNING) {}

  // virtual destructor
  virtual ~CurrentTimestampRunning();

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  
  
  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}
}; // class CurrentTimestampRunning

class DateFormat : public CacheableBuiltinFunction
{
public:
  enum FormatType
  {
    FORMAT_GENERIC = 0,
    FORMAT_TO_DATE,
    FORMAT_TO_TIME,
    FORMAT_TO_CHAR
  };

  enum 
  { 
    DATE_FORMAT_NONE = 0,
    DATE_FORMAT_STR,       // formatStr_ contains date format    
    TIME_FORMAT_STR,       // formatStr_ contains time format
    TIMESTAMP_FORMAT_STR   // formatStr_ contains timestamp format
  };

  DateFormat(ItemExpr *val1Ptr, const NAString &formatStr,
             Lng32 formatType, NABoolean wasDateformat = FALSE);

  // virtual destructor
  virtual ~DateFormat();

  // accessor functions
  Int32 getDateFormat() const { return dateFormat_; }

  Int32 getExpDatetimeFormat() const { return frmt_; }

  // do not change format literals of DateFormat into constant parameters
  virtual ItemExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA)
    { return this; } 

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

  NABoolean errorChecks(Lng32 frmt, BindWA *bindWA, const NAType* opType);

  ItemExpr * quickDateFormatOpt(BindWA * bindWA);

  ItemExpr * bindNode(BindWA * bindWA);

  void setOriginalString(NAString &s) {origString_ = s; }
  const NAString & getOriginalString() const { return origString_; }

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  
  void unparse(NAString &result,
               PhaseEnum phase,
               UnparseFormatEnum form,
               TableDesc * tabId) const;
    
  virtual NABoolean hasEquivalentProperties(ItemExpr * other);

  virtual QR::ExprElement getQRExprElem() const
  { 
    return QR::QRFunctionWithParameters; 
  }

private:
  // string contains user specified format string
  NAString formatStr_;

  // TO_DATE or TO_CHAR
  Lng32 formatType_;

  // DATE, TIME or TIMESTAMP
  Int32 dateFormat_;

  // original function was DATEFORMAT
  NABoolean wasDateformat_; 

  // actual datetime format (defined in class ExpDatetime in exp_datetime.h)
  Lng32 frmt_;

  //original string
  NAString origString_;
}; // class DateFormat

class DayOfWeek : public CacheableBuiltinFunction
{
public:
  DayOfWeek(ItemExpr *val1Ptr)
	: CacheableBuiltinFunction(ITM_DAYOFWEEK, 1, val1Ptr)
	{ allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~DayOfWeek();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

  virtual NABoolean calculateMinMaxUecs(ColStatDescList & histograms,
					       CostScalar & minUec,
					       CostScalar & maxUec);

}; // class DayOfWeek

///////////////////////////////////////////////////////////////////
// This class explodes or fixes up a varchar for insert or updates.
// It does the following:
//   If forInsert is TRUE, then:
//      -- if the source is a NULL value, then the null indicator
//         is set and the length bytes of varchar are set to 0.
//      -- if the source is non-null, then they are moved as packed
//         format and the length bytes contain the actual length.
//
//  If forInsert is FALSE, then:
//     -- if the source is NULL, then null indicator bytes are set
//        to non-zero, the length bytes are set to the max length.
//     -- if source is non-null, then the source is blankpadded to
//        max value and then moved in. Length bytes are set to max.
////////////////////////////////////////////////////////////////////
class ExplodeVarchar : public BuiltinFunction
{
public:
  ExplodeVarchar(ItemExpr *val1Ptr, const NAType * type,
		 NABoolean forInsert = FALSE)
        : BuiltinFunction(ITM_EXPLODE_VARCHAR,  CmpCommon::statementHeap(),
                          1, val1Ptr),
          type_(type), forInsert_(forInsert)
  {}

  // virtual destructor
  virtual ~ExplodeVarchar();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();
  const NAType *getType() const { return type_; }

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual NABoolean protectFromVEGs() { return TRUE; };

private:
  const NAType *type_;

  NABoolean forInsert_;
}; // class ExplodeVarchar

class Extract : public CacheableBuiltinFunction
{
public:
  Extract(rec_datetime_field extractField, ItemExpr *val1Ptr,
	  NABoolean fieldFunction)
	: CacheableBuiltinFunction(ITM_EXTRACT, 1, val1Ptr),
	  extractField_(extractField),
	  fieldFunction_(fieldFunction)
	  { allowsSQLnullArg() = FALSE; }

  Extract(OperatorTypeEnum op,
	  rec_datetime_field extractField, ItemExpr *val1Ptr,
	  NABoolean fieldFunction)
       : CacheableBuiltinFunction(op, 1, val1Ptr),
	 extractField_(extractField),
	 fieldFunction_(fieldFunction)
         { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~Extract();

  // accessor functions
  rec_datetime_field getExtractField() const	{ return extractField_; }

  NABoolean getFieldFunction() const { return fieldFunction_; }

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual ItemExpr * preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  // returns TRUE for Extract(cast(CurrentTimeStamp))) otherwise FALSE.
  virtual NABoolean isAUserSuppliedInput() const;

  // --------------------------------------------------------------------
  // Walk through an ItemExpr tree and gather the ValueIds of those
  // expressions that behave as if they are "leaves" for the sake of
  // the coverage test. In this case expressions of the type
  // extract(cast(current_timestamp))  will be treated like a leaf.
  // --------------------------------------------------------------------
  virtual void getLeafValuesForCoverTest(ValueIdSet & leafValues, 
                                         const GroupAttributes& coveringGA,
                                         const ValueIdSet & newExternalInputs) const;

  virtual NABoolean duplicateMatch(const ItemExpr & other) const;
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean hasEquivalentProperties(ItemExpr * other);

  virtual NABoolean calculateMinMaxUecs(ColStatDescList & histograms,
					       CostScalar & minUec,
					       CostScalar & maxUec);

  virtual QR::ExprElement getQRExprElem() const;
  

private:

  rec_datetime_field extractField_;

  // set to TRUE if the original function specified was a datetime
  // field function that was translated to an EXTRACT function.
  // Ex.  DAY(<value>)  gets translated to EXTRACT(DAY from <value>).
  // Used for correct error reporting.
  NABoolean fieldFunction_;
}; // class Extract

class ExtractOdbc : public Extract
{
public:
  ExtractOdbc(rec_datetime_field extractField, ItemExpr *val1Ptr,
	      NABoolean fieldFunction)
       : Extract(ITM_EXTRACT_ODBC, extractField, val1Ptr, fieldFunction)
  { allowsSQLnullArg() = FALSE; }

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
}; // class ExtractOdbc

class JulianTimestamp : public CacheableBuiltinFunction
{
public:
  JulianTimestamp(ItemExpr *val1Ptr)
	: CacheableBuiltinFunction(ITM_JULIANTIMESTAMP, 1, val1Ptr)
	{ allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~JulianTimestamp();

  // A method that returns for "user-given" input values.
  // These are values that are either constants, host variables, parameters,
  // or even values that are sensed from the environment such as
  // current time, the user name, etcetera.
  // Fix for cr 10-010718-3967
  // don't need this method since this method is hardcoded to return TRUE
  // and JulianTimestamp is not a user supplied input, therefore we should
  // just be fine calling ItemExpr::isAUserSuppliedInput which always returns
  // FALSE
  // virtual NABoolean isAUserSuppliedInput() const;

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual ItemExpr * preCodeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  
  
  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}
  
}; // class JulianTimestamp

// supplied by the root node, a count of statement executions
class StatementExecutionCount : public BuiltinFunction
{
public:
  StatementExecutionCount() : BuiltinFunction(ITM_EXEC_COUNT) {}

  virtual NABoolean isAUserSuppliedInput() const;
  virtual const NAType * synthesizeType();
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
};

// supplied by the root node, the current transaction id, if any
class CurrentTransId : public BuiltinFunction
{
public:
  CurrentTransId() : BuiltinFunction(ITM_CURR_TRANSID) {}

  virtual NABoolean isAUserSuppliedInput() const;
  virtual const NAType * synthesizeType();
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
};

class Upper : public CacheableBuiltinFunction
{
public:
  Upper(ItemExpr *val1Ptr)
         : CacheableBuiltinFunction(ITM_UPPER, 1, val1Ptr)
	 { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~Upper();

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // do not change literals of a cacheable query into constant parameters
  virtual ItemExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA)
    { return this; }

  NABoolean isCharTypeMatchRulesRelaxable()
  { return child(0)->isCharTypeMatchRulesRelaxable(); } ;

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean protectFromVEGs() { return TRUE; };

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class Upper

class Lower : public CacheableBuiltinFunction
{
public:
  Lower(ItemExpr *val1Ptr)
         : CacheableBuiltinFunction(ITM_LOWER, 1, val1Ptr)
	 { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~Lower();

  // do not change literals of a cacheable query into constant parameters
  virtual ItemExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA)
    { return this; }

  NABoolean isCharTypeMatchRulesRelaxable()
  { return child(0)->isCharTypeMatchRulesRelaxable(); } ;

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean protectFromVEGs() { return TRUE; };

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class Lower

class Trim : public CacheableBuiltinFunction
{
public:
  enum    { TRAILING, LEADING, BOTH};

  Trim(Int32  mode, ItemExpr *val1Ptr, ItemExpr *val2Ptr)
         : CacheableBuiltinFunction(ITM_TRIM, 2, val1Ptr, val2Ptr),
           mode_(mode)
	   { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~Trim();

  // for now, do NOT change literals of Trim into constant parameters
  virtual ItemExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA)
    { return this; } 

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

  inline Int32 getTrimMode() const { return mode_; }

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * preCodeGen(Generator*);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  NABoolean isRelaxCharTypeMatchRulesPossible() {return TRUE;};

  // The following method enables expressions such as
  // iso88591_column = trim(BOTH :ucs2_hv1 FROM :ucs2_hv2)
  NABoolean isCharTypeMatchRulesRelaxable()
  { return child(0)->isCharTypeMatchRulesRelaxable() &&
           child(1)->isCharTypeMatchRulesRelaxable();
  } ;

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  virtual NABoolean protectFromVEGs() { return TRUE; };

  void setCollation(CharInfo::Collation  v) 
  {
    collation_= v;
  }
  
  CharInfo::Collation getCollation() 
  { 
    return collation_;
  }
  virtual NABoolean hasEquivalentProperties(ItemExpr * other);

  virtual QR::ExprElement getQRExprElem() const
  { 
    return QR::QRFunctionWithParameters; 
  }

private:
  Int32    mode_;  // holds a value from one of the enum members shown above.
  CharInfo::Collation collation_;

}; // class Trim

class Translate: public CacheableBuiltinFunction
{
public:
  enum {/*UCS2*/UNICODE_TO_SJIS, /*UCS2*/UNICODE_TO_ISO88591,
        ISO88591_TO_UNICODE/*UCS2*/, SJIS_TO_UNICODE/*UCS2*/,
        UCS2_TO_SJIS, SJIS_TO_UCS2,
        UCS2_TO_UTF8, UTF8_TO_UCS2,
        UTF8_TO_SJIS, SJIS_TO_UTF8, UTF8_TO_ISO88591,
        ISO88591_TO_UTF8,
        KANJI_MP_TO_ISO88591, KSC5601_MP_TO_ISO88591,
        GBK_TO_UTF8,
        UNKNOWN_TRANSLATION};

  Translate(ItemExpr *valPtr, NAString* map_table_name);
  Translate(ItemExpr *valPtr, Int32 map_table_id);

  // virtual destructor
  virtual ~Translate() {};

  // for now, do NOT change literals of Translate into constant parameters
  virtual ItemExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA)
    { return this; } 

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

  inline Int32 getTranslateMapTableId() const { return map_table_id_; }

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  NABoolean isRelaxCharTypeMatchRulesPossible() {return TRUE;}
  ItemExpr* tryToRelaxCharTypeMatchRules(BindWA *bindWA);

  NABoolean  isCharTypeMatchRulesRelaxable();

  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  virtual NABoolean protectFromVEGs() { return TRUE; };

  virtual QR::ExprElement getQRExprElem() const
   { return QR::QRFunctionWithParameters; }

  virtual void unparse(NAString &result,
		       PhaseEnum phase = DEFAULT_PHASE,
		       UnparseFormatEnum form = USER_FORMAT,
		       TableDesc * tabId = NULL) const;
private:
  Int32 map_table_id_;  // holds a value from one of the enum members shown above.

}; // class Translate

Int32 find_translate_type( CharInfo::CharSet src_cs,   // Source charset
                           CharInfo::CharSet dest_cs ); // Destination charset


// The CASE statement has an operand which is not one of its children,
// which introduces a few special cases in Binder and in Codegen type-synth...
class Case : public CacheableBuiltinFunction
{
public:
  Case(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
  : CacheableBuiltinFunction(ITM_CASE, 1, val2Ptr),
    caseOperand_(val1Ptr),
    caseOperandWasNullable_(FALSE)
    {}

  // virtual destructor
  virtual ~Case();

  // accessor functions
  ItemExpr *removeCaseOperand()
  {
    ItemExpr *caseOperand = caseOperand_;
    caseOperand_ = NULL;
    return caseOperand;
  }

  ItemExpr *getCaseOperand()		     { return caseOperand_; }

  void setCaseOperand(ItemExpr *newOperand)  { caseOperand_ = newOperand; }

  NABoolean &caseOperandWasNullable()	     { return caseOperandWasNullable_; }

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // A transformation method for protecting sequence functions from not
  // being evaluated due to short-circuit evaluation.
  //
  virtual void protectiveSequenceFunctionTransformation(Generator *generator);

  // method to do code generation
  virtual short codeGen(Generator*);

  // we want Case to be cacheable
  virtual NABoolean isCacheableExpr(CacheWA& cwa);

  // change literals of a cacheable query into input parameters
  virtual ItemExpr* normalizeForCache(CacheWA& cachewa, BindWA& bindWA);

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cachewa) const;

  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	              ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const;

  // This method recursively removes from coveredSubExpr,
  // all IfThenElse nodes that are part of 'expr' and for those IfThenElse
  // nodes, adds its children to coveredSubExpr.
  // input: expr, a non-null IfThenElse node.
  void fixIfThenElse(ItemExpr * expr, ValueIdSet& coveredSubExpr, NABoolean ifThenElseExists = FALSE) const;

  virtual void unparse(NAString &result,
		       PhaseEnum phase = DEFAULT_PHASE,
		       UnparseFormatEnum form = USER_FORMAT,
		       TableDesc * tabId = NULL) const;

  virtual void getLeafValuesForCoverTest(ValueIdSet & leafValues, 
                                         const GroupAttributes& coveringGA,
                                         const ValueIdSet & newExternalInputs) const;

  virtual NABoolean hasEquivalentProperties(ItemExpr * other);

  virtual NABoolean calculateMinMaxUecs(ColStatDescList & histograms,
					       CostScalar & minUec,
					       CostScalar & maxUec);
private:
  ItemExpr *caseOperand_;
  NABoolean caseOperandWasNullable_;
}; // class Case

class IfThenElse : public CacheableBuiltinFunction
{
public:
  IfThenElse(ItemExpr *val1Ptr, ItemExpr *val2Ptr, ItemExpr *val3Ptr)
  : CacheableBuiltinFunction(ITM_IF_THEN_ELSE, 3, val1Ptr, val2Ptr, val3Ptr) {}

  // virtual destructor
  virtual ~IfThenElse();

  // for now, do NOT change literals of IfThenElse into constant parameters
  virtual ItemExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA)
    { return this; } 

  // set else clause
  void setElse(ItemExpr *elseClause) { child(2) = elseClause; }

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  NABoolean isRelaxCharTypeMatchRulesPossible() {return TRUE;};

  NABoolean isCharTypeMatchRulesRelaxable();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  short codeGen(Generator*);

  virtual void unparse(NAString &result,
		       PhaseEnum phase = DEFAULT_PHASE,
		       UnparseFormatEnum form = USER_FORMAT,
		       TableDesc * tabId = NULL) const;

  virtual NABoolean calculateMinMaxUecs(ColStatDescList & histograms,
					       CostScalar & minUec,
					       CostScalar & maxUec);

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}
}; // class IfThenElse


// The RaiseError class is introduced to raise an error
// given the errorCode and the message. This expression
// will create an error in the Diagnostics area and
// return EXPR_ERROR. Currently this ItemExpr is used
// to raise errors for constraint failures.
//
class RaiseError : public BuiltinFunction
{
public:
  // -- Triggers
  // This Ctor is used for SIGNAL statements with a string expression.
  RaiseError (Lng32 sqlcode,
	      NAString SqlState,
		  ItemExpr *messageExpr,
          CollHeap * h=0)
    : BuiltinFunction(ITM_RAISE_ERROR,  CmpCommon::statementHeap(),
                      1, messageExpr),
      theSQLCODE_(sqlcode),
      constraintName_(SqlState, h),
      tableName_("", h)
    {};

  RaiseError (Lng32 sqlcode = 0,
	      const NAString & constraintName = "",
	      const NAString & tableName = "",
              CollHeap * h=0)
    : BuiltinFunction(ITM_RAISE_ERROR),
      theSQLCODE_(sqlcode),
      constraintName_(constraintName, h),
      tableName_(tableName, h)
    {};

  // copy ctor
  RaiseError (const RaiseError &, CollHeap * h=0) ; // not written

  virtual ~RaiseError();

  const NAType *synthesizeType();
  short codeGen (Generator*);
  ItemExpr *copyTopNode (ItemExpr *derivedNode = NULL, CollHeap *outHeap =NULL);
  virtual const NAString getText() const;

  const NAString &getConstraintName() const	{ return constraintName_; }
  const NAString &getTableName() const		{ return tableName_; }
  Int32 getSQLCODE() const			{ return theSQLCODE_; }
  void setSQLCODE(Lng32 sqlcode) 		{ theSQLCODE_ = sqlcode; }

private:
  Lng32     theSQLCODE_;
  NAString constraintName_;
  NAString tableName_;

}; // class RaiseError


class Cast : public CacheableBuiltinFunction
{
public:
  Cast(ItemExpr *val1Ptr, const NAType *type,
       OperatorTypeEnum otype = ITM_CAST, NABoolean checkForTrunc = FALSE,
       NABoolean noStringTruncationWarnings = FALSE);

  Cast(ItemExpr *val1Ptr, ItemExpr *errorOutPtr, const NAType *type,
       OperatorTypeEnum otype /* today, should be ITM_NARROW always */,
       NABoolean checkForTrunc = FALSE,
       NABoolean reverseDataErrorConversionFlag = FALSE,
       NABoolean noStringTruncationWarnings = FALSE);

  // virtual destructor
  virtual ~Cast();

  // accessor functions
  ItemExpr * getExpr() const { return child(0).getPtr(); }

  const NAType *getType() const { return type_; }
  void changeType(NAType * newType) { type_ = newType; }

  virtual NABoolean isEquivalentForCodeGeneration(const ItemExpr * other);

  virtual ConstValue *castToConstValue(NABoolean & negate);

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // determine whether the output of the cast can be type relaxed
  NABoolean isCharTypeMatchRulesRelaxable()
  { return child(0)->isCharTypeMatchRulesRelaxable(); } ;

  // convert a cast on top of a constant into a new constant with
  // the correct type
  virtual ItemExpr *foldConstants(ComDiagsArea *diagsArea,
				  NABoolean newTypeSynthesis = FALSE);

  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	              ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const;

  // is any literal in this expr safely coercible to its target type?
  virtual NABoolean isSafelyCoercible(CacheWA& cwa) const;

  // MVs --
  virtual void getLeafValuesForCoverTest(ValueIdSet & leafValues, 
                                         const GroupAttributes& coveringGA,
                                         const ValueIdSet & newExternalInputs) const;

  // Is this a subclass of GenericUpdateOutputFunction BuildinFunction?
  virtual NABoolean isAGenericUpdateOutputFunction() const
    { return child(0)->isAGenericUpdateOutputFunction(); }

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // method to do code generation
  virtual ItemExpr * preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  NABoolean checkTruncationError()	{ return checkForTruncation_; }
  void setCheckTruncationError(NABoolean v) { checkForTruncation_ = v; }

  // get and set for flags_. See enum Flags.
  NABoolean matchChildType()   { return (flags_ & MATCH_CHILD_TYPE) != 0; }
  void setMatchChildType(NABoolean v)
  { (v ? flags_ |= MATCH_CHILD_TYPE : flags_ &= ~MATCH_CHILD_TYPE); }

  NABoolean treatAllSpacesAsZero()
  { return ((flags_ & TREAT_ALL_SPACES_AS_ZERO) != 0); };
  
  void setTreatAllSpacesAsZero(NABoolean v)
  { (v) ? flags_ |= TREAT_ALL_SPACES_AS_ZERO : flags_ &= ~TREAT_ALL_SPACES_AS_ZERO; }

  NABoolean tgtCharSetSpecified()   { return (flags_ & TGT_CHAR_SET_SPECIFIED) != 0; }
  void setTgtCSSpecified(NABoolean v)
       { (v ? flags_ |= TGT_CHAR_SET_SPECIFIED : flags_ &= ~TGT_CHAR_SET_SPECIFIED); }

  NABoolean srcIsVarcharPtr()   { return (flags_ & SRC_IS_VARCHAR_PTR) != 0; }
  void setSrcIsVarcharPtr(NABoolean v)
       { (v ? flags_ |= SRC_IS_VARCHAR_PTR : flags_ &= ~SRC_IS_VARCHAR_PTR); }

  NABoolean allowSignInInterval()
    { return ((flags_ & ALLOW_SIGN_IN_INTERVAL) != 0); };

  void setAllowSignInInterval(NABoolean v)
    { (v) ? flags_ |= ALLOW_SIGN_IN_INTERVAL : flags_ &= ~ALLOW_SIGN_IN_INTERVAL; }

  NABoolean convertNullWhenError() 
  { return (flags_ & CONV_NULL_WHEN_ERROR) != 0; }
  void setConvertNullWhenError(NABoolean v)
  { (v ? flags_ |= CONV_NULL_WHEN_ERROR : flags_ &= ~CONV_NULL_WHEN_ERROR); }

  NABoolean noStringTruncationWarnings() 
  { return (flags_ & NO_STRING_TRUNC_WARNINGS) != 0; }
  void setNoStringTruncationWarnings(NABoolean v)
  { (v ? flags_ |= NO_STRING_TRUNC_WARNINGS: flags_ &= ~NO_STRING_TRUNC_WARNINGS); }

  const NAType * pushDownType(NAType& desiredType,
                      enum NABuiltInTypeEnum defaultQualifier);

  virtual NABoolean hasEquivalentProperties(ItemExpr * other);

  UInt16 getFlags() { return flags_; }
  void setFlags(UInt16 f) { flags_ = f; }

private:

  enum Flags
  {
    // if set, then do not generate code if child's type attributes match
    // my type attributes.
    MATCH_CHILD_TYPE = 0x0001,

    // when converting string to numeric, if input string contains only
    // spaces or is a null string(length of zero), then the result becomes
    // zero(numeric value of 0).
    TREAT_ALL_SPACES_AS_ZERO  = 0x0002,

    // Did user specify the target character set?  0=No, 1=Yes
    TGT_CHAR_SET_SPECIFIED = 0x0004,

    // source is a varchar value which is a pointer to the actual data.
    SRC_IS_VARCHAR_PTR = 0x0008,

    ALLOW_SIGN_IN_INTERVAL             = 0x0010,

    // convert error will not be returned, null will be moved into target
    CONV_NULL_WHEN_ERROR               = 0x0020,

    // string truncation warnings are not to be returned
    NO_STRING_TRUNC_WARNINGS           = 0x0040
  
  };

  const NAType *type_;

  // Does the ex_conv_clause generated by this cast node need to
  // check for truncation error?
  NABoolean checkForTruncation_;

  // If true, the run-time data error conversion flag must be reversed.
  // This is a Narrow-only issue.
  NABoolean reverseDataErrorConversionFlag_;

  UInt32 flags_;

}; // class Cast

class CastConvert : public Cast
{
public:
  CastConvert(ItemExpr *val1Ptr, const NAType *type)
    : Cast(val1Ptr, type, ITM_CAST_CONVERT)
  {}

  // copyTopNode method
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // CastConvert

class CastType : public Cast
{
public:
  CastType(ItemExpr *val1Ptr, const NAType *type)
       : Cast(val1Ptr, type, ITM_CAST_TYPE),
         makeNullable_(FALSE)
  {}

  CastType(ItemExpr *val1Ptr, NABoolean makeNullable)
       : Cast(val1Ptr, NULL, ITM_CAST_TYPE),
         makeNullable_(makeNullable)
  {}

  // copyTopNode method
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual short codeGen(Generator*);

private:
  // if set, then cast child to nullable type
  NABoolean makeNullable_;
}; // CastType

class Narrow : public Cast
{
public:
  // Begin_Fix 10-040114-2431
  // 02/18/2004
  // Add initialization for matchChildNullability_
  Narrow(ItemExpr * val1Ptr, ItemExpr * errorOutPtr, const NAType * type,
       OperatorTypeEnum otype = ITM_NARROW,
       NABoolean reverseDataErrorConversionFlag = FALSE,
       NABoolean matchChildNullability = FALSE)
         : Cast(val1Ptr, errorOutPtr, type, otype, FALSE,
                reverseDataErrorConversionFlag),
           matchChildNullability_(matchChildNullability){}
  // End_Fix 10-040114-2431

  // virtual destructor
  virtual ~Narrow();

  // copyTopNode method
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // a virtual function for type propagating the node
  virtual const NAType *synthesizeType();

  // method to do code generation
  // virtual ItemExpr * preCodeGen(Generator*); -- we use Cast::preCodeGen
  virtual short codeGen(Generator*);

  virtual NABoolean hasEquivalentProperties(ItemExpr * other);

private:

  // Begin_Fix 10-040114-2431
  // 02/18/2004
  //Force by nullability to be the same as my child's nullability
  NABoolean matchChildNullability_;
  // End_Fix 10-040114-2431
}; // class Narrow

class InstantiateNull : public Cast
{
public:
  InstantiateNull(ItemExpr * valuePtr, const NAType * typePtr)
               : Cast(valuePtr, typePtr, ITM_INSTANTIATE_NULL),
                 beginLOJTransform_(FALSE),
                 NoCheckforLeftToInnerJoin(FALSE){}

  virtual ~InstantiateNull();

  // Each operator supports a (virtual) method for transforming its
  // scalar expressions to a canonical form
  virtual void transformNode(NormWA & normWARef,
			     ExprValueId & locationOfPointerToMe,
                             ExprGroupId & introduceSemiJoinHere,
			     const ValueIdSet & externalInputs);

  // initiateInnerToLeftJoinTransformation() is invoked when
  // a predicateEliminatesNullAugmentedRows().
  virtual ItemExpr * initiateLeftToInnerJoinTransformation(NormWA &);

  // Each operator supports a (virtual) method for transforming its
  // query tree to a canonical form.
  virtual ItemExpr * normalizeNode(NormWA & normWARef);

  virtual ItemExpr * getReplacementExpr() const;

  //10-060105-3714-Begin
  virtual ItemExpr * getReplacementExpr(NABoolean forceNavigate) const; 
  //10-060105-3714-End
  // --------------------------------------------------------------------
  // Walk through an ItemExpr tree and gather the ValueIds of those
  // expressions that behave as if they are "leaves" for the sake of
  // the coverage test, e.g., expressions that have no children, or
  // aggregate functions, or instantiate null. These are usually values
  // that are produced in one "scope" and referenced above that "scope"
  // in the dataflow tree for the query.
  // --------------------------------------------------------------------
  virtual void getLeafValuesForCoverTest(ValueIdSet & leafValues, 
                                         const GroupAttributes& coveringGA,
                                         const ValueIdSet & newExternalInputs) const;

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  NABoolean NoCheckforLeftToInnerJoin;
  NABoolean lojTransformInProgress() {return beginLOJTransform_;}
  void setLOJTransformComplete() {beginLOJTransform_ = FALSE;}
  virtual NABoolean isAColumnReference( );

  virtual NABoolean hasEquivalentProperties(ItemExpr * other);
  virtual NABoolean isEquivalentForCodeGeneration(const ItemExpr * other);

private:
  NABoolean beginLOJTransform_;
}; // class InstantiateNull

// used to format source values to ascii representation.
//
// And source ascii values to specified target datatype.
// This is only suppported to convert to DATE datatype and if
// 'formatCharToDate' parameter is set to TRUE. 
class Format : public BuiltinFunction
{
  NAString formatStr_;
public:
  enum FormatType
  {
    FORMAT_GENERIC = 0,
    FORMAT_TO_DATE,
    FORMAT_TO_CHAR
  };

  Format(ItemExpr *val1Ptr, const NAString &formatStr, 
	 NABoolean formatCharToDate, Lng32 formatType = FORMAT_GENERIC)
       : BuiltinFunction(ITM_FORMAT,  CmpCommon::statementHeap(),
                         1, val1Ptr),
	 formatStr_(formatStr),
	 formatType_(formatType),
	 formatCharToDate_(formatCharToDate)
  {
    formatStr_.strip(NAString::leading);
    formatStr_.strip(NAString::trailing);
    formatStr_.toUpper();
  }
  
  // virtual destructor
  virtual ~Format();

  // method to do precode generation
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  ItemExpr * quickDateFormatOpt(BindWA * bindWA);

  const NAString& getFormatStr() const
  {
    return formatStr_;
  }

  Lng32 getFormatType() const
  {
    return formatType_;
  }

  NABoolean getFormatCharToDate() const
  {
    return formatCharToDate_;
  }

  virtual QR::ExprElement getQRExprElem() const
  { 
    return QR::QRFunctionWithParameters; 
  }

private:
  Lng32 formatType_;
  NABoolean formatCharToDate_;
}; // class Format


class LOBoper : public BuiltinFunction
{
public:

 enum ObjectType
 {
   STRING_, FILE_, BUFFER_, CHUNK_, STREAM_, LOB_, LOAD_, EXTERNAL_, 
   EXTRACT_, EMPTY_LOB_,NOOP_
 };

 LOBoper(OperatorTypeEnum otype,
	 ItemExpr *val1Ptr=NULL, ItemExpr *val2Ptr = NULL,ItemExpr *val3Ptr = NULL, 
	 ObjectType obj = NOOP_)
   : BuiltinFunction(otype,  CmpCommon::statementHeap(),
                     3, val1Ptr, val2Ptr,val3Ptr),
   obj_(obj),
   lobNum_(-1),
   lobStorageType_(Lob_Invalid_Storage),
     lobMaxSize_((Int64)CmpCommon::getDefaultNumeric(LOB_MAX_SIZE)*1024*1024),
     lobMaxChunkMemSize_((Int64)CmpCommon::getDefaultNumeric(LOB_MAX_CHUNK_MEM_SIZE)*1024*1024),
     lobGCLimit_((Int64) CmpCommon::getDefaultNumeric(LOB_GC_LIMIT_SIZE)*1024*1024),
     hdfsPort_((Lng32)CmpCommon::getDefaultNumeric(LOB_HDFS_PORT)),
     hdfsServer_( CmpCommon::getDefaultString(LOB_HDFS_SERVER))
   {
     if ((obj == STRING_) || (obj == BUFFER_) || (obj == FILE_) || (obj ==LOB_) )
       lobStorageType_ = Lob_HDFS_File;
     else if (obj == EXTERNAL_)
       lobStorageType_ = Lob_External_HDFS_File;
     else if (obj == EMPTY_LOB_)
       lobStorageType_ = Lob_Empty;
     else
       lobStorageType_ = Lob_Invalid_Storage;
    
   }

 // copyTopNode method
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

  virtual NABoolean isCovered
    (const ValueIdSet& newExternalInputs,
     const GroupAttributes& coveringGA,
     ValueIdSet& referencedInputs,
     ValueIdSet& coveredSubExpr,
     ValueIdSet& unCoveredExpr) const;
  
  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);

  ObjectType getObj() { return obj_; }

  short &lobNum() {return lobNum_; }
  LobsStorage &lobStorageType() { return lobStorageType_; }
  NAString &lobStorageLocation() { return lobStorageLocation_; }
  Int64 getLobMaxSize() {return lobMaxSize_; }
  Int64 getLobMaxChunkMemSize() { return lobMaxChunkMemSize_;}
  Int64 getLobGCLimit() 
  { 
    if (lobGCLimit_>0) 
      return (Int64)lobGCLimit_;
    else
      return -1;
  }
  Int32 getLobHdfsPort() { return hdfsPort_;}
  NAString &getLobHdfsServer(){return hdfsServer_;}
 protected:
  ObjectType obj_;

  short lobNum_;
  LobsStorage lobStorageType_;
  NAString lobStorageLocation_;
  Int64 lobMaxSize_; // In byte units
  Int64 lobMaxChunkMemSize_; //In MB Units
  Int64 lobGCLimit_ ;//In MB Units
  Int32 hdfsPort_;
  NAString hdfsServer_;
  
}; // LOBoper

class LOBinsert : public LOBoper
{
 public:
  
 LOBinsert(ItemExpr *val1Ptr, 
	   ItemExpr *val2Ptr,
	   ObjectType fromObj, 
	   NABoolean isAppend = FALSE,
           NABoolean treatLobAsVarchar =FALSE,
	   OperatorTypeEnum otype = ITM_LOBINSERT)
   : LOBoper(otype, val1Ptr, val2Ptr,NULL,fromObj),
    objectUID_(-1),
    append_(isAppend),
    lobAsVarchar_(treatLobAsVarchar),
     lobSize_((Int64)CmpCommon::getDefaultNumeric(LOB_MAX_SIZE)*1024*1024),
    fsType_(REC_BLOB)
    {};
  
  // copyTopNode method
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  ItemExpr *bindNode(BindWA *bindWA);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();
  
  // method to do code generation
  virtual short codeGen(Generator*);

  // returns TRUE so this could be evaluated in master.
  virtual NABoolean isAUserSuppliedInput() const { return TRUE; };

  Int64 & insertedTableObjectUID() { return objectUID_; }
  
  NAString &insertedTableSchemaName() { return schName_; }

  //  Lng32 & lobNum() { return lobNum_; }

  Int64 & lobSize() { return lobSize_; }

  Lng32 & lobFsType() { return fsType_; }
  NABoolean lobAsVarchar() const { return lobAsVarchar_;}
 protected:
  // ---------------------------------------------------------------//
  // ObjectUID of the table this blob is being inserted into
  // -------------------------------------------------------------- //
  Int64 objectUID_;

  // schemaname of the table
  NAString schName_;

  // column this blob is being inserted into.
  //  Lng32 lobNum_;

  Int64 lobSize_;

  Lng32 fsType_;

  NABoolean append_;
  NABoolean lobAsVarchar_;//This means this lob insert will get it's input data 
                          // in varchar format
}; // class LOBinsert

class LOBselect : public LOBoper
{
 public:
  
 LOBselect(ItemExpr *val1Ptr, ItemExpr *val2Ptr, ObjectType toObj)
   : LOBoper(ITM_LOBSELECT, val1Ptr, val2Ptr,NULL,toObj)
    {
    };
  
  // copyTopNode method
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  
  ItemExpr *bindNode(BindWA *bindWA);
 
  // a virtual function for type propagating the node
 
  // method to do code generation
  virtual short codeGen(Generator*);
  
 private:
 
}; // class LOBselect

class LOBdelete : public LOBoper
{
 public:
  
 LOBdelete(ItemExpr *val1Ptr)
   : LOBoper(ITM_LOBDELETE, val1Ptr)
    {};
  
  // copyTopNode method
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  
  // method to do code generation
  virtual short codeGen(Generator*);

 private:
}; // class LOBdelete


class LOBupdate : public LOBoper
{
 public:
  
  LOBupdate(ItemExpr *val1Ptr,
	    ItemExpr *val2Ptr,
	    ItemExpr *val3Ptr,
	    ObjectType fromObj, 
	    NABoolean isAppend = FALSE,
            NABoolean treatLobAsVarchar =FALSE)
    : LOBoper(ITM_LOBUPDATE, val1Ptr, val2Ptr,val3Ptr,fromObj),
      objectUID_(-1),
      lobSize_((Int64)CmpCommon::getDefaultNumeric(LOB_MAX_SIZE)*1024*1024),
      append_(isAppend),
      lobAsVarchar_(treatLobAsVarchar)
    {};
  
  // copyTopNode method
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();
  
  // method to do code generation
  virtual short codeGen(Generator*);
  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);
  // virtual Int32 getArity() const;
  NABoolean isAppend() { return append_; };

  Int64 & updatedTableObjectUID() { return objectUID_; }
  
  NAString &updatedTableSchemaName() { return schName_; }
  Int64 & lobSize() { return lobSize_; }
  NABoolean lobAsVarchar() const { return lobAsVarchar_;}
 private:
  // ---------------------------------------------------------------//
  // ObjectUID of the table this blob is being inserted into
  // -------------------------------------------------------------- //
  Int64 objectUID_;

  // schemaname of the table
  NAString schName_;


  NABoolean append_;
  Int64 lobSize_;
  NABoolean lobAsVarchar_;//This means this lob insert will get it's input data 
                          // in varchar format
}; // class LOBupdate

class LOBconvert : public LOBoper
{
 public:
  
 LOBconvert(ItemExpr *val1Ptr, ObjectType toObj,  Lng32 tgtSize= CmpCommon::getDefaultNumeric(LOB_OUTPUT_SIZE) ) 
   : LOBoper(ITM_LOBCONVERT, val1Ptr, NULL,NULL,toObj),
    tgtSize_(tgtSize)     
    {};
  
  // copyTopNode method
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  
  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);

  // method to do code generation
  virtual short codeGen(Generator*);

  Lng32 getTgtSize() { return tgtSize_; }
 private:
  Lng32 tgtSize_;
 
}; // class LOBconvert

class LOBconvertHandle : public LOBoper
{
 public:
  
 LOBconvertHandle(ItemExpr *val1Ptr, ObjectType toObj)
   : LOBoper(ITM_LOBCONVERTHANDLE, val1Ptr, NULL,NULL,toObj)
    {};
  
  // copyTopNode method
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  
  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual short codeGen(Generator*);

 private:
}; // class LOBconvertHandle


class LOBextract : public LOBoper
{
 public:
  
 LOBextract(ItemExpr *val1Ptr, Lng32 tgtSize = 1000)
   : LOBoper(ITM_LOBEXTRACT, val1Ptr, NULL,NULL,EXTRACT_),
    tgtSize_(tgtSize)
    {};
  
  // copyTopNode method
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  
  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  //virtual short codeGen(Generator*);
  
  Lng32 getTgtSize() { return tgtSize_; }
 private:
  Lng32 tgtSize_;
}; // class LOBext

class CompEncode : public BuiltinFunction
{
protected:

  // Encodes operand so it could be compared using a byte
  // comparison.
  short descFlag_; // if TRUE, encoding to be done for descending comparison.

  // encode so case insensitive comparisons could be done.
  // Valid for char/varchar datatypes only.
  NABoolean caseinsensitiveEncode_;

  CharInfo::Collation encodedCollation_;

  CollationInfo::CollationType collationType_;

  // length of encoded result, if passed in to the constructor.
  // If not passed in, or passed in and is -1, then the total
  // size of child is the length of CompEncode result.
  Lng32 length_;

  // if set, then result is nullable if child is nullable (same as other exprs and function).
  // Only the data bytes are encoded in this case.
  NABoolean regularNullability_;

  // Constructor used by derived class
  CompEncode(ItemExpr *val1Ptr, 
	     short descFlag,
	     Lng32 length,
	     CollationInfo::CollationType collType,
	     NABoolean regularNullability,
	     OperatorTypeEnum operType,
             NAMemory *h)
    : BuiltinFunction(operType, h, 1, val1Ptr),
    descFlag_(descFlag), 
    caseinsensitiveEncode_(FALSE),
    encodedCollation_(CharInfo::DefaultCollation),
    length_(length),
    collationType_(collType),
    regularNullability_(regularNullability)
      {}

public:
  CompEncode(ItemExpr *val1Ptr, 
	     short descFlag = FALSE,
	     Lng32 length = -1,
	     CollationInfo::CollationType collType = CollationInfo::Sort,
	     NABoolean regularNullability = FALSE,
             NAMemory *h = CmpCommon::statementHeap())
    : BuiltinFunction(ITM_COMP_ENCODE, h, 1, val1Ptr),
    descFlag_(descFlag), 
    caseinsensitiveEncode_(FALSE),
    encodedCollation_(CharInfo::DefaultCollation),
    length_(length),
    collationType_(collType),
    regularNullability_(regularNullability)
      {}

  // virtual destructor
  virtual ~CompEncode();

  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);

  // method to do code generation
  virtual short codeGen(Generator*);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  void setCaseinsensitiveEncode(NABoolean v) {caseinsensitiveEncode_ = v;}

  void setEncodedCollation(CharInfo::Collation v) {encodedCollation_ = v;}

  void setCollationType(CollationInfo::CollationType v) { collationType_ = v;}

  short getDescFlag() const { return descFlag_;}

  NABoolean getCaseInsensitiveEncode() const { return caseinsensitiveEncode_;}

  Int32 getEncodedCollation() const { return encodedCollation_;}

  NABoolean getCollationType() const { return collationType_;}

  NABoolean isDecode() const { return getOperatorType() == ITM_COMP_DECODE; }

  static Lng32  getEncodedLength( const CharInfo::Collation collation,
						 const CollationInfo::CollationType ct,
						 const Lng32 srcLength,
						 const NABoolean nullable); 

  virtual QR::ExprElement getQRExprElem() const {return QR::QRFunctionWithParameters;}

}; // class CompEncode

class CompDecode : public CompEncode
{
public:
  CompDecode(ItemExpr *val1Ptr, 
             const NAType *unencodedType,
	     short descFlag = FALSE,
	     Lng32 length = -1,
	     CollationInfo::CollationType collType = CollationInfo::Sort,
	     NABoolean regularNullability = TRUE,
            NAMemory *h = CmpCommon::statementHeap())
    : CompEncode(val1Ptr, descFlag, length, collType, regularNullability, 
		 ITM_COMP_DECODE, h),
    unencodedType_(unencodedType)
    {}

  // virtual destructor
  virtual ~CompDecode();

  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);

  // method to do code generation
  virtual short codeGen(Generator*);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

 private:
  const NAType * unencodedType_;
}; // class CompDecode

// -----------------------------------------------------------------------
// Built-in functions
// -----------------------------------------------------------------------
class HashCommon : public BuiltinFunction
{
  enum
  {
    CASESENSITIVE_HASH_ = 0x0001
  };

public:
  HashCommon(OperatorTypeEnum otype,
	     Lng32  argumentCount = 0,
	     ItemExpr *child0 = NULL,
	     ItemExpr *child1 = NULL,
	     ItemExpr *child2 = NULL,
	     ItemExpr *child3 = NULL,
	     ItemExpr *child4 = NULL,
	     ItemExpr *child5 = NULL)
       : BuiltinFunction(otype, CmpCommon::statementHeap(), argumentCount, 
			 child0, child1, child2, child3, child4, child5),
	 flags_(0)
  {
  }

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  void setCasesensitiveHash(NABoolean v)      
  { (v ? flags_ |= CASESENSITIVE_HASH_ : flags_ &= ~CASESENSITIVE_HASH_); }
  NABoolean casesensitiveHash() {return (flags_ & CASESENSITIVE_HASH_) != 0;}

protected:
  NABoolean areChildrenExactNumeric(Lng32 left, Lng32 right);

private:
  UInt32 flags_;
};

class Hash : public HashCommon
{
  // Defined for all data types, returns a 32 bit non-nullable
  // hash value for the data item.
public:
  Hash(ItemExpr *val1Ptr)
         : HashCommon(ITM_HASH, 1, val1Ptr) {}

  // virtual destructor
  virtual ~Hash();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // generator methods
  virtual ItemExpr * preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean protectFromVEGs() { return TRUE; };

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const { return "Hash"; };
}; // class Hash

class HashComb : public HashCommon
{
  // Defined for two operands of type UNSIGNED INTEGER
  // Returns a value of type UNSIGNED INTEGER
public:
  HashComb(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
    : HashCommon(ITM_HASHCOMB, 2, val1Ptr, val2Ptr) {}

  // virtual destructor
  virtual ~HashComb();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const { return "HashComb"; };
}; // class HashComb

class HiveHashComb : public HashCommon
{
  // Defined for two operands of type UNSIGNED INTEGER
  // Returns a value of type UNSIGNED INTEGER
public:
  HiveHashComb(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
    : HashCommon(ITM_HIVE_HASHCOMB, 2, val1Ptr, val2Ptr) {}

  // virtual destructor
  virtual ~HiveHashComb() {};

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const { return "HiveHashComb"; };
}; // class HiveHashComb


// The following two classes (HashDistPartHash and
// HashDistPartHashComb) are used by the HashDistPartitioningFunction.
// They are isolated from the other general purpose versions of these
// functions so that they won't be inadvertently altered.  Any changes
// these functions that results in a different runtime behavior will
// cause existing hash partitioned tables to be invalid.
//
class HashDistPartHash : public HashCommon
{
  // Hash Function used by Hash Partitioning. This function
  // cannot change once Hash Partitioning is released!
  // Defined for all data types, returns a 32 bit non-nullable
  // hash value for the data item.
public:
  HashDistPartHash(ItemExpr *val1Ptr)
         : HashCommon(ITM_HDPHASH, 1, val1Ptr) {}

  // virtual destructor
  virtual ~HashDistPartHash();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // generator methods
  virtual ItemExpr * preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean protectFromVEGs() { return TRUE; };

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const { return "HashDistPartHash"; };
}; // class HashDistPartHash

class HashDistPartHashComb : public HashCommon
{
  // This function is used to combine two hash values to produce a new
  // hash value. Used by Hash Partitioning. This function cannot
  // change once Hash Partitioning is released!  Defined for all data
  // types, returns a 32 bit non-nullable hash value for the data
  // item.

  // Defined for two operands of type UNSIGNED INTEGER
  // Returns a value of type UNSIGNED INTEGER
public:
  HashDistPartHashComb(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
    : HashCommon(ITM_HDPHASHCOMB, 2, val1Ptr, val2Ptr) {}

  // virtual destructor
  virtual ~HashDistPartHashComb();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean protectFromVEGs() { return TRUE; };

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const { return "HashDistPartHashComb"; };
}; // class HashDistPartHashComb

class HiveHash : public HashCommon
{
  // Defined for all data types, returns a 32 bit non-nullable
  // hash value for the data item.
public:
  HiveHash(ItemExpr *val1Ptr)
         : HashCommon(ITM_HIVE_HASH, 1, val1Ptr) {}

  // virtual destructor
  virtual ~HiveHash() {};

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // generator methods
  virtual ItemExpr * preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  virtual NABoolean protectFromVEGs() { return TRUE; };

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const { return "HiveHash"; };
}; // class HiveHash


////////////////////////////////////////////////////////////////
// Various Math functions are represented by this operator.
// The operatorType() tells which math function it is.
////////////////////////////////////////////////////////////////
class MathFunc : public CacheableBuiltinFunction
{
public:
  MathFunc(OperatorTypeEnum oper,
	   ItemExpr *val1Ptr = NULL, ItemExpr *val2Ptr = NULL)
         : CacheableBuiltinFunction(oper, 2, val1Ptr, val2Ptr)
  { allowsSQLnullArg() = FALSE; }

  // get the degree of this node (it depends on the type of the operator)
  virtual Int32 getArity() const;

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do pre code generation
  virtual ItemExpr * preCodeGen(Generator*);

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // get a printable string that identifies the operator
  virtual const NAString getText() const;

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}
  
  virtual NABoolean calculateMinMaxUecs(ColStatDescList & histograms,
					       CostScalar & minUec,
					       CostScalar & maxUec);

  NAType* findReturnTypeForFloorCeil(NABoolean nullable);
};

class Abs : public MathFunc
{
public:
  Abs(ItemExpr *val1Ptr)
    : MathFunc(ITM_ABS, val1Ptr)
    { allowsSQLnullArg() = FALSE; }

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual ItemExpr * bindNode(BindWA *bindWA);

  // method to do pre code generation
  virtual ItemExpr * preCodeGen(Generator*);

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class Abs

////////////////////////////////////////////////////////////////
// Various bit functions are represented by this operator.
// The operatorType() tells which bit function it is.
////////////////////////////////////////////////////////////////
class BitOperFunc : public CacheableBuiltinFunction
{
public:
  BitOperFunc(OperatorTypeEnum oper,
	      ItemExpr *val1Ptr = NULL, ItemExpr *val2Ptr = NULL,
	      ItemExpr *val3Ptr = NULL)
       : CacheableBuiltinFunction(oper, 3, val1Ptr, val2Ptr, val3Ptr)
  { allowsSQLnullArg() = FALSE; }
  
  // get the degree of this node (it depends on the type of the operator)
  virtual Int32 getArity() const;

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // method to do pre code generation
  virtual ItemExpr * preCodeGen(Generator*);

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // get a printable string that identifies the operator
  virtual const NAString getText() const;

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

};

class Modulus : public CacheableBuiltinFunction
{
  // Defined for two operands of exact numeric data types with scale 0.
  // Returns a value of the data type of the second operand.
public:
  Modulus(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
         : CacheableBuiltinFunction(ITM_MOD, 2, val1Ptr, val2Ptr)
  { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~Modulus();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do pre code generation
  virtual ItemExpr * preCodeGen(Generator*);

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean calculateMinMaxUecs(ColStatDescList & histograms,
					       CostScalar & minUec,
					       CostScalar & maxUec);

}; // class Modulus

/////////////////////////////////////////////////////////////////////
// Returns a string composed of val1ptr repeated val2ptr times.
/////////////////////////////////////////////////////////////////////
class Repeat : public BuiltinFunction
{
public:
  Repeat(ItemExpr *val1Ptr, ItemExpr *val2Ptr, Int32 maxLength = -1)
       : BuiltinFunction(ITM_REPEAT, CmpCommon::statementHeap(),
                         2, val1Ptr, val2Ptr),
         maxLength_(maxLength),
         maxLengthWasExplicitlySet_(FALSE)
  { 
    allowsSQLnullArg() = FALSE; 
    if (maxLength > 0)
      maxLengthWasExplicitlySet_ = TRUE;
  }

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * preCodeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  NABoolean isCharTypeMatchRulesRelaxable()
  { return child(0)->isCharTypeMatchRulesRelaxable(); } ;

  virtual NABoolean protectFromVEGs() { return TRUE; };

  const Int32 getMaxLength() { return maxLength_ ;} ;
  void setMaxLength(Int32 val) {maxLength_ = val;} ;

 private:

  // max length of Repeat expression. 
  // If not passed in during constrtuctor, then it is set only when Repeat
  // is used certain expansions of LPAD and RPAD. 
  // It is initialized to the value -1, which indicates that maxLength 
  // has not been computed or passed in.
  Int32 maxLength_;

  // if max length was specified in REPEAT function 
  // and passed in during constructor.
  NABoolean maxLengthWasExplicitlySet_;

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class Repeat


/////////////////////////////////////////////////////////////////////
// Replaces all occurances of string val2ptr in string val1Ptr with
// string val3Ptr.
/////////////////////////////////////////////////////////////////////
class Replace : public CacheableBuiltinFunction
{
public:
  Replace(ItemExpr *val1Ptr, ItemExpr *val2Ptr, ItemExpr *val3Ptr)
       : CacheableBuiltinFunction(ITM_REPLACE, 3, val1Ptr, val2Ptr, val3Ptr)
  { allowsSQLnullArg() = FALSE; }

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  NABoolean isRelaxCharTypeMatchRulesPossible() {return TRUE;};

  // The following method enables expressions such as
  // iso88591_column = replace(:ucs2_hv1,:ucs2_hv2, :ucs2_hv3)
  NABoolean isCharTypeMatchRulesRelaxable()
  { return child(0)->isCharTypeMatchRulesRelaxable() &&
           child(1)->isCharTypeMatchRulesRelaxable() &&
           child(2)->isCharTypeMatchRulesRelaxable();
  } ;

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean protectFromVEGs() { return TRUE; };

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class Replace


class ReplaceNull : public BuiltinFunction
{
  // Returns third argument if first argument is null,
  // Otherwise returns second argument.
  // Defined for all types.
public:
  ReplaceNull(ItemExpr *val1Ptr, ItemExpr *val2Ptr, ItemExpr *val3Ptr)
         : BuiltinFunction(ITM_REPLACE_NULL, CmpCommon::statementHeap(),
                           3, val1Ptr, val2Ptr, val3Ptr) {}

  // virtual destructor
  virtual ~ReplaceNull();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // generator methods
  virtual ItemExpr * preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class ReplaceNull

class HashDistrib : public HashCommon
{
  // Defined for two operands with scale 0.
  // The first operand is the a arbitrary integer value.
  // The second operand is the number of mapped values.
  // Returns a value of the data type of the second operand.
  // The result is a value in the range 0 - (<number of mapped values> - 1)
  // distributed in a way that is useful for Hash Partitioning.
  //
public:
  HashDistrib(OperatorTypeEnum otype, ItemExpr *val1Ptr, ItemExpr *val2Ptr)
    : HashCommon(otype, 2, val1Ptr, val2Ptr) {}

  // virtual destructor
  virtual ~HashDistrib();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // generator methods
  virtual ItemExpr * preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const { return "HashDistrib"; };

}; // class HashDistrib;

class Hash2Distrib : public HashDistrib
{
  // Defined for two operands with scale 0.
  // The first operand is the a arbitrary integer value.
  // The second operand is the number of mapped values.
  // Returns a value of the data type of the second operand.
  // The result is a value in the range 0 - (<number of mapped values> - 1)
  // distributed in a way that is useful for Hash Partitioning.
  //
public:
  Hash2Distrib(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
    : HashDistrib(ITM_HASH2_DISTRIB, val1Ptr, val2Ptr) {}

  // virtual destructor
  virtual ~Hash2Distrib();

  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const { return "Hash2Distrib"; };

}; // class Hash2Distrib;

class ProgDistrib : public HashDistrib
{
  // Defined for two operands with scale 0.
  // The first operand is the a arbitrary integer value.
  // The second operand is the number of mapped values.
  // Returns a value of the data type of the second operand.
  // The result is a value in the range 0 - (<number of mapped values> - 1)
  // distributed in a way that is useful for Hash Partitioning.
  //
public:
  ProgDistrib(ItemExpr *val1Ptr, ItemExpr *val2Ptr)
    : HashDistrib(ITM_PROGDISTRIB, val1Ptr, val2Ptr) {}

  // virtual destructor
  virtual ~ProgDistrib();

  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const { return "ProgDistrib"; };

}; // class ProgDistrib;

class ProgDistribKey : public BuiltinFunction
{
public:
  ProgDistribKey(ItemExpr *value,
                 ItemExpr *offset,
                 ItemExpr *totalNumValues)
    : BuiltinFunction(ITM_PROGDISTRIBKEY, CmpCommon::statementHeap(),
                      3, value, offset, totalNumValues) {}

  // virtual destructor
  virtual ~ProgDistribKey();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // generator methods
  virtual ItemExpr * preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const { return "ProgDistribKey"; };

}; // class ProgDistribKey;

class PAGroup : public BuiltinFunction
{
  // Defined for three operands with scale 0.  The first operand is
  // the an integer value representing the partition number (before
  // grouping).  The second operand is the number of groups and the
  // third is the number of partitions before grouping.  Returns a
  // value of the data type of the first operand.  The result is a
  // value in the range 0 - (<number of groups> - 1).
  //
public:
  PAGroup(ItemExpr *val1Ptr, ItemExpr *val2Ptr, ItemExpr *val3Ptr)
    : BuiltinFunction(ITM_PAGROUP, CmpCommon::statementHeap(),
                      3, val1Ptr, val2Ptr, val3Ptr) {}

  // virtual destructor
  virtual ~PAGroup();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // generator methods
  virtual ItemExpr * preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const { return "PAGroup"; };

}; // class PAGroup;

class InverseOrder : public BuiltinFunction
{
  // Defined for all data types that can be used in an ORDER BY clause.
  // This function returns a result that has the same data type as its
  // input and has the following property:
  //     if a > b then inverse(a) < inverse(b)
  // (for numeric data types this is similar to the unary "-" operator)
  // This function is not usually needed in the executor, it is mainly
  // for the optimizer to indicate descending order. For example, the
  // SQL syntax "order by t1.a desc" is internally represented as
  // "order by inverse(t1.a)".
public:
  InverseOrder(ItemExpr *val1Ptr)
         : BuiltinFunction(ITM_INVERSE, CmpCommon::statementHeap(),
                           1, val1Ptr) {}

  // virtual destructor
  virtual ~InverseOrder();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual ItemExpr * simplifyOrderExpr(OrderComparison *newOrder = NULL);

  virtual ItemExpr * removeInverseOrder();

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}


}; // class InverseOrder

// Defined for all data types.
// Increments the value that is its operand by one.
// It is used for transforming a > comparison in an index search key
// to a >= comparison.
// Increment(MaxValue for a datatype) causes an overflow.
class Increment : public BuiltinFunction
{
public:
  Increment(ItemExpr *val1Ptr)
         : BuiltinFunction(ITM_INCREMENT, CmpCommon::statementHeap(),
                           1, val1Ptr) {}

  // virtual destructor
  virtual ~Increment();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class Increment

// Defined for all data types.
// Decrements the value that is its operand by one.
// It is used for transforming a < comparison in an index search key
// to a <= comparison.
// Decrement(MinValue for a datatype) causes an underflow.
class Decrement : public BuiltinFunction
{
public:
  Decrement(ItemExpr *val1Ptr)
         : BuiltinFunction(ITM_DECREMENT, CmpCommon::statementHeap(),
                           1, val1Ptr) {}

  // virtual destructor
  virtual ~Decrement();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

}; // class Decrement

// A ternary version of the comparison operator from class BiRelat. The
// first two operands <op1> and <op2> are two values to be compared,
// the boolean third operand <op3>, together with the operator type,
// indicates the type of comparison:
//
//   Operator type          op3 is FALSE             op3 is TRUE
// -----------------   ----------------------  ---------------------
//  ITM_LESS_OR_LE           op1 <= op2               op1 < op2
// ITM_GREATER_OR_GE         op1 >= op2               op1 > op2
//
// ITM_LESS_OR_LE is simply a shortcut for
//            case when op3 then op1 < op2 else op1 <= op2 end
// and ITM_GREATER_OR_GE is a shortcut for
//            case when op3 then op1 > op2 else op1 >= op2 end
//
// The TriRelational operator is used for cases where it is not known
// at compile time whether a greater or less comparison includes or
// excludes the case that both values are equal. In all practical cases,
// this is used for key predicates and is translated into an appropriate
// flag for the file system. In the unlikely case that this has to be
// evaluated for a non-key predicate, it gets transformed into an
// IfThenElse executor predicate: if (op3) then op1 < op2 else op1 <= op2
// or if (op3) then op1 > op2 else op1 >= op2, respectively.
class TriRelational : public BuiltinFunction
{
public:
  TriRelational(OperatorTypeEnum optype,
		ItemExpr *val1Ptr,
		ItemExpr *val2Ptr,
		ItemExpr *val3Ptr);

  // virtual destructor
  virtual ~TriRelational();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual ItemExpr * preCodeGen(Generator*);

  // method to generate Mdam predicates
  short mdamPredGen(Generator * generator,
                    MdamPred ** head,
                    MdamPred ** tail,
                    MdamCodeGenHelper & mdamHelper,
                    ItemExpr * parent);
  inline NABoolean getSpecialNulls()             { return specialNulls_; }
  inline void setSpecialNulls(NABoolean flag)    { specialNulls_ = flag; }

private:

  // the next field, if set, indicates that 'nulls are values'.
  // That means that nulls are equal to other nulls, and they
  // sort higher than other values. Used for groupby, order
  // by, hashing, or any other operation where nulls are NOT
  // to be ignored.
  NABoolean specialNulls_;

}; // class TriRelational

class RangeLookup : public BuiltinFunction
{
public:
  RangeLookup(ItemExpr *val1Ptr,
	      const RangePartitioningFunction *partFunc);

  virtual ~RangeLookup();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

private:

  // private methods to avoid teaching the expression generator about
  // partitioning functions
  Lng32 splitKeysLen();
  void copySplitKeys(char *tgt, Lng32 tgtLen);
  Lng32 getNumOfPartitions();
  Lng32 getEncodedBoundaryKeyLength();

  // private data members

  const RangePartitioningFunction *partFunc_;
}; // class RangeLookup

class ScalarVariance : public CacheableBuiltinFunction
{
public:
  ScalarVariance(OperatorTypeEnum opType,  // ITM_VARIANCE or ITM_STDDEV
		 ItemExpr *SumOfValSquared,
		 ItemExpr *SumOfVal,
		 ItemExpr *CountOfVal)
    : CacheableBuiltinFunction(opType, 3, SumOfValSquared, SumOfVal, CountOfVal) {}

  // virtual destructor
  virtual ~ScalarVariance();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * preCodeGen(Generator*);

  // get a printable string that identifies the operator
  virtual const NAString getText() const
  {
    switch(getOperatorType())
      {
      case ITM_VARIANCE:
	return "Scalar Variance";
      case ITM_STDDEV:
	return "Scalar Stddev";
      default:
	return "Unknown Scalar Variance Function";
      }
  };

  virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}

}; // class ScalarVariance

// Class RowsetArrayScan
// This built in function is used to extract an element of a Rowset array
// Both the Rowset array and the index value are provided at run time.
// Items of type ArrayIndex are attached to an UnpackRows node at compile
// time. When the generator finds an UnpackRows node, it creates an
// PhysUnPackRows, and when it finds an ArrayIndex item, it generates a
// ex_RowsetArrayScan node. At run time, each ExRowsetArrayScan node is
// evaluated and the corresponding array element is returned by the
// PhysUnPackRows node to its parent.
//
// opType == ITM_ROWSETARRAY_SCAN to access the elements of the array
//        == ITM_ROWSETARRAY_INDEX to retrieve the current index

class RowsetArrayScan : public BuiltinFunction
{
public:
  RowsetArrayScan(ItemExpr     *source,
                  ItemExpr     *index,
                  Lng32         maxNumElem,
                  Lng32         elemSize,
                  NABoolean    elemNullInd,
                  const NAType *elemType,
                  OperatorTypeEnum opType = ITM_ROWSETARRAY_SCAN)
    : BuiltinFunction(opType, CmpCommon::statementHeap(), 2, source, index),
    maxNumElem_(maxNumElem),
    elemSize_(elemSize),
    elemNullInd_(elemNullInd),
    elemType_(elemType)
    {
    };

  // virtual destructor
  virtual ~RowsetArrayScan();

  // a virtual function for type propagating the node
  //
  virtual const NAType * synthesizeType();

  // allow relaxation for rowset array scan (similary to a regular hostvar)
  NABoolean isCharTypeMatchRulesRelaxable();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  // RowsetArrayScan behaves as an Aggregate, which is NOT covered even
  // if its children are.
  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
                              const GroupAttributes& newRelExprAnchorGA,
                              ValueIdSet& referencedInputs,
                              ValueIdSet& coveredSubExpr,
                              ValueIdSet& unCoveredExpr) const;

  // RowsetArrayScan is considered a leaf node for cover test.
  virtual void getLeafValuesForCoverTest(ValueIdSet & leafValues, 
                                         const GroupAttributes& coveringGA,
                                         const ValueIdSet & newExternalInputs) const;

  // Return the type of the array elements
  const NAType *getType() const { return elemType_; }

  // method to do code generation
  //
  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const
  {
    return "RowsetArrayScan";
  };

  // This method is used to figure out the type of the array elements in case
  // they were not specified. This may happen in a dynamic rowset query that
  // contains unspecified parameters, like for instance "insert into t values(?)"
  const NAType * pushDownType(NAType& desiredType,
                        enum NABuiltInTypeEnum defaultQualifier);

private:
  Lng32         maxNumElem_;      // Maximum number of elements
  Lng32         elemSize_;        // Element storage length in bytes
  NABoolean    elemNullInd_;     // Null Indicator ?
  const NAType *elemType_;       // The datatype of the array elements

};

class RowsetArrayInto : public BuiltinFunction
{
public:
  RowsetArrayInto(ItemExpr     *source,
                  ItemExpr     *numElemExpr,
                  Lng32         maxNumElem,
                  Lng32         elemSize,
                  NABoolean    elemNullInd,
                  const NAType *hostVarType,
                  OperatorTypeEnum opType = ITM_ROWSETARRAY_INTO)
    : BuiltinFunction(opType, CmpCommon::statementHeap(),
                      2, source, numElemExpr),
      maxNumElem_(maxNumElem),
      elemSize_(elemSize),
      elemNullInd_(elemNullInd),
      hostVarType_(hostVarType)
    {
    };

  // virtual destructor
  virtual ~RowsetArrayInto();

  // a virtual function for type propagating the node
  //
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  // RowsetArrayInto behaves as an Aggregate, which is NOT covered even
  // if its children are.
  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
                              const GroupAttributes& newRelExprAnchorGA,
                              ValueIdSet& referencedInputs,
                              ValueIdSet& coveredSubExpr,
                              ValueIdSet& unCoveredExpr) const;

  // RowsetArrayInto is considered a leaf node for cover test.
  virtual void getLeafValuesForCoverTest(ValueIdSet & leafValues, 
                                         const GroupAttributes& coveringGA,
                                         const ValueIdSet & newExternalInputs) const;

  // Return the type of the array elements
  const NAType *getType() const { return hostVarType_; }

  // method to do code generation
  //
  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const
  {
    return "RowsetArrayInto";
  };

private:
  Lng32         maxNumElem_;      // Maximum number of elements
  Lng32         elemSize_;        // Element storage length in bytes
  NABoolean    elemNullInd_;     // Null Indicator ?
  const NAType *hostVarType_;    // The datatype of the array elements

};


// Class unPackCol ------------------------------------------------
// This built in function is used to 'unpack' the values in a packed
// row.
//
class UnPackCol : public BuiltinFunction
{
public:
  UnPackCol(ItemExpr *source,
	    ItemExpr *index,
	    Lng32 width,
	    Lng32 base,
	    NABoolean nullsPresent,
	    const NAType *type,
	    OperatorTypeEnum opType = ITM_UNPACKCOL)
    : BuiltinFunction(opType, CmpCommon::statementHeap(), 2, source, index),
      width_(width),
      base_(base),
      nullsPresent_(nullsPresent),
      type_(type)
  {
  };

  // virtual destructor
  virtual ~UnPackCol();

  // Return the type of the original unpacked column.
  //
  const NAType *getType() const { return type_; }

  // a virtual function for type propagating the node
  //
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);
  // method to do code generation
  //
  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  //
  virtual const NAString getText() const
  {
    return "UnPackCol";
  };

  // UnPackCol behaves like an Aggregate, which is NOT covered even if its
  // children are.
  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
                              const GroupAttributes& newRelExprAnchorGA,
                              ValueIdSet& referencedInputs,
                              ValueIdSet& coveredSubExpr,
                              ValueIdSet& unCoveredExpr) const;

  // UnPackCol is considered a leaf node for cover test.
  virtual void getLeafValuesForCoverTest(ValueIdSet & leafValues, 
                                         const GroupAttributes& coveringGA,
                                         const ValueIdSet & newExternalInputs) const;

private:
  // The width of the packed column in bits.
  //
  Lng32 width_;

  // The base offset of the packed data in bytes.
  //
  Lng32 base_;

  // If TRUE, then a null bitmap is present in the packed row.
  //
  NABoolean nullsPresent_;

  // The datatype of the original unpacked column.
  //
  const NAType *type_;

}; // class UnPackCol

// Function to generate a random 32 bit unsigned integer.  Each
// instance of this function maintains a seed internally, which gets
// automatically set to a random value the first time the function is
// called.  In the future there may be a requirement to allow the
// caller to manage the seed, but for now this simpler approach of
// having the callee do it is sufficient.
// The future is here: adding support for user specified seed.
//
class RandomNum : public BuiltinFunction
{
public:
  RandomNum(ItemExpr * seed = NULL, NABoolean simpleRandom = FALSE) 
       : BuiltinFunction(ITM_RANDOMNUM, CmpCommon::statementHeap(), 1, seed),
	 simpleRandom_(simpleRandom)
         { allowsSQLnullArg() = FALSE; }

  virtual ~RandomNum();

  virtual Int32 getArity() const { return (child(0) ? 1 : 0); };

  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual ItemExpr * preCodeGen(Generator*);

  virtual short codeGen(Generator*);

  virtual RandomNum *castToRandomNum() { return this; }

private:
  NABoolean simpleRandom_;
}; // class RandomNum

// Function to right/left shift a 32 or 64 bit integer.
//
class Shift : public BuiltinFunction
{
public:
  Shift(OperatorTypeEnum otype, // ITM_SHIFT_RIGHT || ITM_SHIFT_LEFT
        ItemExpr *child0,
        ItemExpr *child1)
    : BuiltinFunction(otype, CmpCommon::statementHeap(), 2, child0, child1) {}

  virtual ~Shift();

  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  virtual const NAString getText() const
  {
    switch(getOperatorType())
      {
      case ITM_SHIFT_RIGHT:
	return "Right Shift";
      case ITM_SHIFT_LEFT:
	return "Left Shift";
      default:
	return "Unknown Shift Operation";
      }
  };

}; // class Shift

// InternalTimestamp is a version of CurrentTimestamp that is evaluated
// again on every call
class InternalTimestamp : public BuiltinFunction
{
public:
  InternalTimestamp(): BuiltinFunction(ITM_INTERNALTIMESTAMP) {}

  // virtual destructor
  virtual ~InternalTimestamp();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	              ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const
  { return TRUE; };

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);


}; // class InternalTimestamp

// Function to mask (clear, set) bits in a 32 or 64 bit integer.
//
class Mask : public BuiltinFunction
{
public:
  Mask(OperatorTypeEnum otype,
       ItemExpr *child0,
       ItemExpr *child1)
    : BuiltinFunction(otype, CmpCommon::statementHeap(), 2, child0, child1) {}

  virtual ~Mask();

  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  virtual const NAString getText() const
  {
    switch(getOperatorType())
      {
      case ITM_MASK_SET:
	return "Mask Set";
      case ITM_MASK_CLEAR:
	return "Mask Clear";
      default:
	return "Unknown Mask Operation";
      }
  };

}; // class Mask

// -----------------------------------------------------------------------
// PackFunc is a built-in function to support packing (of multiple rows
// into one row). It takes two parameters. One is an ItemExpr specifying
// the row to be packed. The other is the packing factor which says how
// many rows are to be packed into one row.
// -----------------------------------------------------------------------
class PackFunc : public BuiltinFunction
{
  // ITM_PACK_FUNC
public:

  // Constructor.
  PackFunc(ItemExpr* val1Ptr, ItemExpr* pf)
   : BuiltinFunction(ITM_PACK_FUNC,CmpCommon::statementHeap(),2,val1Ptr,pf),
     isFormatInfoValid_(FALSE)                                          {}

  // This constructor is used when format is predetermined.
  PackFunc(ItemExpr* val1Ptr,
           ItemExpr* pf,
           Lng32 base,
           Lng32 width,
           NABoolean nullsPresent);

  // The type given is the type of one logical row before packing is done.
  PackFunc(ItemExpr* val1Ptr,
           ItemExpr* pf,
           const NAType* unpackType);

  // Destructor.
  virtual ~PackFunc();

  // Allow setting and clearing of format information after construction.
  void setFormatInfo(Lng32 base,
                     Lng32 width,
                     NABoolean nullsPresent,
                     const NAType* type)
  {
    base_ = base;
    width_ = width;
    nullsPresent_ = nullsPresent,
    type_ = type;
    isFormatInfoValid_ = TRUE;
  }

  void clearFormatInfo()                   { isFormatInfoValid_ = FALSE; }

  // Derive type from base, width and nullsPresent information.
  void deriveTypeFromFormatInfo();

  // Derive type, base, width and nullsPresent information from unpack type.
  void deriveFormatInfoFromUnpackType(const NAType* unpackType);

  // Needn't refine bindNode(). Default suffice. Refine synthesizeType().
  virtual const NAType* synthesizeType();

  // Transform node eliminates subqueries from the expression trees.
  // virtual void transformNode(NormWA& normWARef,
  //                         ExprValueId& locationOfPointerToMe,
  //                         ExprGroupId& introduceSemiJoinHere,
  //                         const ValueIdSet& externalInputs);

  // Normalize node rewrites some sub-expressions into VEGRef.
  // virtual ItemExpr* normalizeNode(NormWA& normWARef);

  // PackFunc behaves like an Aggregate, which is NOT covered even if its
  // children are.
  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	              ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const;

  virtual void getLeafValuesForCoverTest(ValueIdSet & leafValues, 
                                         const GroupAttributes& coveringGA,
                                         const ValueIdSet & newExternalInputs) const;
  // Code Generation.
  virtual short codeGen(Generator*);

  // Make a copy of the operator.
  virtual ItemExpr* copyTopNode(ItemExpr* derivedNode = NULL,
                                 CollHeap* outHeap = 0);
private:

  // Whether the format information below are valid or not. If not, PackFunc
  // will compute these information based on its first operand.
  NABoolean isFormatInfoValid_;

  // Offset of where packed data begin.
  Lng32 base_;

  // Width of one logical row. Negative means bits; Positive means bytes.
  Lng32 width_;

  // Whether the null bit map is going to be present in the packed record.
  NABoolean nullsPresent_;

  // Type of logical row stored.
  const NAType* type_;

}; // class PackFunc

///////////////////////////////////////////////////////////////////
// This function only exists upto the bindNode phase.
// The bindNode method returns a new tree depending on
// the oper. This new tree uses the existing operators to
// perform this function. Some of this kind of transformation
// could and is done in the parser. But for complicated expressions
// it is easier to use Parser::parseDML method as an internal
// expression by passing it a string instead of creating the
// complicated tree in the parser. The parseDML could not be called
// from the parser since it in not a reentrant code (parser uses
// globals).
///////////////////////////////////////////////////////////////////
class ZZZBinderFunction : public BuiltinFunction
{
public:
  ZZZBinderFunction(OperatorTypeEnum oper,
		    ItemExpr *val1Ptr = NULL, ItemExpr *val2Ptr = NULL,
		    ItemExpr *val3Ptr = NULL, ItemExpr *val4Ptr = NULL,
		    ItemExpr *val5Ptr = NULL)
       : BuiltinFunction(oper, CmpCommon::statementHeap(), 5,
			 val1Ptr, val2Ptr, val3Ptr, val4Ptr, val5Ptr) {}

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);
  
  // helper function used by bindNode; returns true if there is an error
  bool enforceDateOrTimestampDatatype(BindWA *bindWA, CollIndex child, int operand);

  // the synthesizeType method is needed only when we process an item
  // expression at DDL time, for DML the function gets transformed into
  // another function before we reach type synthesis
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  // No transformation for this node. Raise an error, if transformation
  // is reached. This is the next step after bindNode.
  virtual void transformNode(NormWA & normWARef,
			     ExprValueId & locationOfPointerToMe,
                             ExprGroupId & introduceSemiJoinHere,
			     const ValueIdSet & externalInputs);
  
  Int32 getPadLength (ItemExpr* padLengthExpr, BindWA* bindWA);
  Int32 getPadStringLength (ItemExpr* padLengthExpr, BindWA* bindWA);
  NABoolean isPadWithSpace (ExprValueId& padExpr, CharInfo::CharSet cs);

  static ItemExpr *tryToUndoBindTransformation(ItemExpr *expr);

};

// --------------------------------------------------------------------------
//
// Sequence functions. These perform running and moving aggregates
// based on a defined sort order
//
// --------------------------------------------------------------------------
// Sequence function base class
//
// Allows for up to 3 function arguments.
// --------------------------------------------------------------------------
//
class ItmSequenceFunction : public BuiltinFunction
{
public:
  ItmSequenceFunction(OperatorTypeEnum itemType, ItemExpr *val1Ptr, ItemExpr *val2Ptr=NULL, ItemExpr *val3Ptr=NULL)
    : BuiltinFunction(itemType, CmpCommon::statementHeap(),
                      3, val1Ptr, val2Ptr, val3Ptr),
      isOLAP_(FALSE),
      olapPartitionBy_(NULL),
      olapOrderBy_(NULL),
      isTDFunction_(FALSE)
      {  }

  // virtual destructor
  virtual ~ItmSequenceFunction();

  // get a printable string that identifies the operator
  virtual const NAString getText() const;

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  // method to do precode generation
  // virtual ItemExpr * preCodeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  virtual  NABoolean isASequenceFunction() const ;  // virtual method
  virtual NABoolean containsTHISFunction();

  //  Sequence functions behave like an Aggregate, which is NOT covered even if its
  // children are.
  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
                              const GroupAttributes& newRelExprAnchorGA,
                              ValueIdSet& referencedInputs,
                              ValueIdSet& coveredSubExpr,
                              ValueIdSet& unCoveredExpr) const;

  // A sequence function is considered a leaf node for cover test.
  virtual void getLeafValuesForCoverTest(ValueIdSet & leafValues, 
                                         const GroupAttributes& coveringGA,
                                         const ValueIdSet & newExternalInputs) const;

  virtual NABoolean calculateMinMaxUecs(ColStatDescList & histograms,
					       CostScalar & minUec,
					       CostScalar & maxUec);

  NABoolean isOLAP() { return isOLAP_; };
  void setIsOLAP( NABoolean v ) { isOLAP_ = v; }

  void setOlapPartitionBy(ItemExpr *partBy) { olapPartitionBy_ = partBy;};

  ItemExpr *getOlapPartitionBy() { return olapPartitionBy_; };
  ItemExpr *removeOlapPartitionBy()
  {
    ItemExpr *partBy = olapPartitionBy_;
    olapPartitionBy_ = NULL;
    return partBy;
  };

  void setOlapOrderBy(ItemExpr *orderBy) { olapOrderBy_ = orderBy;};

  ItemExpr *getOlapOrderBy() { return olapOrderBy_; };
  ItemExpr *removeOlapOrderBy()
  {
    ItemExpr *orderBy = olapOrderBy_;
    olapOrderBy_ = NULL;
    return orderBy;
  };

  void setOLAPInfo(ItemExpr *partBy, 
                   ItemExpr *orderBy,                   
                   NABoolean isTDFunction=FALSE)
  {
    olapPartitionBy_ = partBy;
    olapOrderBy_ = orderBy;

    // default is that the isOLAP flag is ON here unless
    // its a TD function, then its OFF
    isOLAP_ = (isTDFunction) ? FALSE : TRUE;

    isTDFunction_ = isTDFunction;    
  };

  NABoolean isTDFunction() { return isTDFunction_; };
  void setIsTDFunction( NABoolean v ) { isTDFunction_ = v; }

  ItemExpr * transformTDFunction(BindWA * bindWA);
  NABoolean isEquivalentForBinding(const ItemExpr * other);

  virtual QR::ExprElement getQRExprElem() const 
  {
    return QR::QRFunctionWithParameters;
  }

private:
  // OLAP Info
  NABoolean isOLAP_;
  ItemExpr *olapPartitionBy_;
  ItemExpr *olapOrderBy_;
  NABoolean isTDFunction_;
} ;

//------------------------------------------------------------------------
// Running function class.
//
//------------------------------------------------------------------------
//
class ItmSeqRunningFunction : public ItmSequenceFunction
{
public:
  ItmSeqRunningFunction(OperatorTypeEnum itemType, ItemExpr *valPtr)
         : ItmSequenceFunction(itemType, valPtr)
         {  }

  // virtual destructor
  virtual ~ItmSeqRunningFunction();

  // methods for code generation
  virtual ItemExpr *preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  // method to do precode generation
  // virtual ItemExpr * preCodeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

 void transformNode(NormWA & normWARef,
               ExprValueId & locationOfPointerToMe,
               ExprGroupId & introduceSemiJoinHere,
               const ValueIdSet & externalInputs);


  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

 ItemExpr *transformRunningVariance();
 ItemExpr *transformRunningSDev();
 ItemExpr *transformRunningAvg();
 ItemExpr *transformRunningRank();

 virtual NABoolean hasEquivalentProperties(ItemExpr * other) { return TRUE;}
  
} ;
//------------------------------------------------------------------------
// Olap function class.
//
//------------------------------------------------------------------------
//
class ItmSeqOlapFunction : public ItmSequenceFunction
{
public:
  ItmSeqOlapFunction(OperatorTypeEnum itemType, ItemExpr *val1Ptr, ItemExpr *val2Ptr = NULL, ItemExpr *val3Ptr = NULL): 
        ItmSequenceFunction(itemType, val1Ptr, val2Ptr, val3Ptr),
        frameStart_(0),
        frameEnd_(0)
        {  }

  // virtual destructor
  virtual ~ItmSeqOlapFunction();

  // methods for code generation
  virtual ItemExpr *preCodeGen(Generator*);  //transfomr into running seq functions
  //virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);
  OperatorTypeEnum mapOperTypeToRunning() const;
  OperatorTypeEnum mapOperTypeToMoving() const;

  void transformNode(NormWA & normWARef,
               ExprValueId & locationOfPointerToMe,
               ExprGroupId & introduceSemiJoinHere,
               const ValueIdSet & externalInputs);

  ItemExpr *transformOlapVariance(CollHeap *heap);
  ItemExpr *transformOlapSDev(CollHeap *heap);
  ItemExpr *transformOlapAvg(CollHeap *heap);
  ItemExpr *transformOlapRank(CollHeap *heap);
  ItemExpr *transformOlapDRank(CollHeap *heap);
  virtual ItemExpr *transformOlapFunction(CollHeap *heap);

  virtual NABoolean hasEquivalentProperties(ItemExpr * other);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();


  Lng32 getframeStart()
  {
    return frameStart_;
  }

  Lng32 getframeEnd()
  {
    return frameEnd_;
  }

  void setframeStart(Lng32 v)
  {
    frameStart_=v;
  }

  void setframeEnd(Lng32 v)
  {
    frameEnd_=v;
  }

  void setOlapWindowFrame(Lng32 s, Lng32 e)
  {
    frameStart_ = s;
    frameEnd_ = e;
  }

  NABoolean isFrameStartUnboundedPreceding() const
  {
    return (frameStart_ == -INT_MAX);
  }

   NABoolean isFrameStartUnboundedFollowing() const
  {
    return (frameStart_ == INT_MAX);
  }
  NABoolean isFrameEndUnboundedPreceding() const
  {
    return (frameEnd_ == -INT_MAX);
  }

  NABoolean isFrameEndUnboundedFollowing() const
  {
    return (frameEnd_ == INT_MAX);
  }


  virtual  NABoolean isOlapFunction() const ;  // virtual method
  inline NABoolean
  canInverseOLAPOrder()
  {
    return !(frameStart_ == -INT_MAX &&
              frameEnd_ != INT_MAX &&
              (getOperatorType() == ITM_OLAP_MIN || 
               getOperatorType() == ITM_OLAP_MAX) ||
             getOperatorType() == ITM_OLAP_RANK ||
             getOperatorType() == ITM_OLAP_DRANK);

  }

  inline NABoolean
  mustInverseOLAPOrder()
  {
    return (frameStart_ != -INT_MAX &&
            frameEnd_ == INT_MAX &&
            (getOperatorType() == ITM_OLAP_MIN || getOperatorType() == ITM_OLAP_MAX));
  }

  NABoolean
  inverseOLAPOrder(CollHeap *heap);

private:
  //olap window frame -- start and end-- 
  // will add patition and order by here too later and remove them from ItemSequenceFunction
  //
  Lng32 frameStart_;
  Lng32 frameEnd_;
} ;

class ItmLeadOlapFunction: public ItmSeqOlapFunction 
{
public:
  ItmLeadOlapFunction(ItemExpr *valPtr, ItemExpr* offsetExpr = NULL, ItemExpr* defaultValue = NULL): 
        ItmSeqOlapFunction(ITM_OLAP_LEAD, valPtr, offsetExpr, defaultValue),
        offset_(-1)
        { }

  ItmLeadOlapFunction(ItemExpr *valPtr, Int32 offset): 
        ItmSeqOlapFunction(ITM_OLAP_LEAD, valPtr),
        offset_(offset)
        { }

  // virtual destructor
  virtual ~ItmLeadOlapFunction();

  // methods for code generation
  virtual ItemExpr *preCodeGen(Generator*);  //transfomr into running seq functions
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  virtual NABoolean hasEquivalentProperties(ItemExpr * other);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual  NABoolean isOlapFunction() const { return TRUE; } ;  // virtual method

  Int32  getOffset() { return offset_; };
  void setOffset(Int32 x) { offset_ = x; };

  ItemExpr* transformOlapFunction(CollHeap *wHeap);

  void transformNode(NormWA & normWARef, 
                     ExprValueId & locationOfPointerToMe,
                     ExprGroupId & introduceSemiJoinHere, 
                     const ValueIdSet & externalInputs);

  // get a printable string that identifies the operator
  virtual const NAString getText() const
    { return "LEAD"; };

private:

   Int32 offset_;
} ;

// ------------------------------------------------------------------------
//
//  OFFSET sequence function.
//
//  OFFSET(x, y) returns SELECT list item x in row at offset (+ or -)
//  y in the sorted sequence.
//
//  Similar to the cursor FETCH RELATIVE operation, except returns
//  result in context of the current row.
// ------------------------------------------------------------------------
//
class ItmSeqOffset : public ItmSequenceFunction
{
public:
  ItmSeqOffset(ItemExpr *val1Ptr, ItemExpr *val2Ptr, ItemExpr *val3Ptr = NULL,
               NABoolean nullRowIsZero = FALSE, NABoolean leading = TRUE, Lng32 winSize = 0)
         : ItmSequenceFunction(ITM_OFFSET, val1Ptr, val2Ptr, val3Ptr),
           nullRowIsZero_(nullRowIsZero),
           offsetConstantValue_ (0),
           leading_(leading),
           winSize_(winSize)
  { allowsSQLnullArg() = FALSE; }

  ItmSeqOffset(ItemExpr *valPtr, 
               Int32 offsetConstantValue,
               NABoolean nullRowIsZero = FALSE,
               NABoolean leading = TRUE,
               Lng32 winSize = 0)
         : ItmSequenceFunction(ITM_OFFSET, valPtr),
           nullRowIsZero_(nullRowIsZero),
           offsetConstantValue_ (offsetConstantValue),
           leading_(leading),
           winSize_(winSize)
  { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~ItmSeqOffset();

  // methods to do code generation
  virtual ItemExpr *preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();


  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  void transformNode(NormWA & normWARef,
                    ExprValueId & locationOfPointerToMe,
                    ExprGroupId & introduceSemiJoinHere,
                    const ValueIdSet & externalInputs);

  // get the degree of this node. Although it is a binary op, this will return 1 if offset value was
  // set via constant below.

  virtual Int32 getArity() const;

  NABoolean nullRowIsZero() const {return nullRowIsZero_;}

  void setNullRowIsZero(NABoolean b) {nullRowIsZero_ = b;}

  //
  Int32 getOffsetConstantValue () const { return  offsetConstantValue_; }

  NABoolean isLeading() const {return leading_;}
  Lng32 winSize() const {return winSize_;}

  virtual NABoolean hasEquivalentProperties(ItemExpr * other);
  
private:
  NABoolean nullRowIsZero_;
  Int32 offsetConstantValue_;
  NABoolean leading_;
  Lng32 winSize_;

}; // class ItmSeqOffset

class ItmLagOlapFunction: public ItmSeqOlapFunction 
{
public:
  ItmLagOlapFunction(ItemExpr *seqColumn, ItemExpr *offsetExpr, ItemExpr* defaultValue = NULL)
         : ItmSeqOlapFunction(ITM_OLAP_LAG, seqColumn, offsetExpr, defaultValue)
         {}

  // virtual destructor
  virtual ~ItmLagOlapFunction(){}
  // methods to do code generation
  virtual ItemExpr *preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();
  
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL, CollHeap* outHeap = 0);
  
  void transformNode(NormWA & normWARef,
                ExprValueId & locationOfPointerToMe,
                ExprGroupId & introduceSemiJoinHere,
                const ValueIdSet & externalInputs);
	
  virtual  NABoolean isOlapFunction() const { return TRUE; }

  ItemExpr * transformOlapFunction(CollHeap *heap) { return this; }
  // get a printable string that identifies the operator
  virtual const NAString getText() const    { return "LAG"; };
};


// --------------------------------------------------------------------------
//
//  DIFF1 sequence function.
//
//  This function has both 1-parameter and two-parameter forms:
//  DIFF1(x) is equivalent to:  x-OFFSET(x, 1)
//  DIFF1(x, y) is equivalent to:  (x-OFFSET(x, 1)) / (y-OFFSET (y, 1)
//
// --------------------------------------------------------------------------
//
class ItmSeqDiff1 : public ItmSequenceFunction
{
public:
  ItmSeqDiff1(ItemExpr *valPtr1, ItemExpr *valPtr2 = NULL)
         : ItmSequenceFunction(ITM_DIFF1, valPtr1, valPtr2)
  { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~ItmSeqDiff1();

  // method to do code generation
  virtual short codeGen(Generator*);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  ItemExpr *transformDiff1();

 void transformNode(NormWA & normWARef,
                    ExprValueId & locationOfPointerToMe,
                    ExprGroupId & introduceSemiJoinHere,
                    const ValueIdSet & externalInputs);


private:

}; // class ItmSeqDiff1

// --------------------------------------------------------------------------
//
//  DIFF2 sequence function.
//
//  This function has both 1-parameter and two-parameter forms:
//  Diff2(x) is equivalent to:  DIFF1(DIFF1(x))
//  Diff2(x, y) is equivalent to:  DIFF1(DIFF1(x))/ DIFF1(DIFF1(y))
// --------------------------------------------------------------------------
//
class ItmSeqDiff2 : public ItmSequenceFunction
{
public:
  ItmSeqDiff2(ItemExpr *valPtr1, ItemExpr *valPtr2 = NULL)
         : ItmSequenceFunction(ITM_DIFF2, valPtr1, valPtr2)
  { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~ItmSeqDiff2();

  // method to do code generation
  virtual short codeGen(Generator*);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

 ItemExpr *transformDiff2();

 void transformNode(NormWA & normWARef,
               ExprValueId & locationOfPointerToMe,
               ExprGroupId & introduceSemiJoinHere,
               const ValueIdSet & externalInputs);


private:

}; // class ItmSeqDiff2

// --------------------------------------------------------------------------
//
//  ROWS SINCE sequence function.
//
//  This function has two forms:
//  ROWS SINCE <condition>
//  ROWS SINCE <condition> INCLUSIVE
//
//  The <condition> is similar to CASE WHEN <condition>
// --------------------------------------------------------------------------
//
class ItmSeqRowsSince : public ItmSequenceFunction
{
public:
  ItmSeqRowsSince(ItemExpr *valPtr, ItemExpr *valPtr2 = NULL, NABoolean inclusionSpec = FALSE)
         : ItmSequenceFunction(ITM_ROWS_SINCE, valPtr, valPtr2),
         includeCurrentRow_ (inclusionSpec)
  { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~ItmSeqRowsSince();

  // methods for code generation
  virtual ItemExpr *preCodeGen(Generator*);
  virtual short codeGen(Generator*);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  // get a printable string that identifies the operator
  virtual const NAString getText() const;

  virtual void transformNode(NormWA & normWARef,
                    ExprValueId & locationOfPointerToMe,
                    ExprGroupId & introduceSemiJoinHere,
                    const ValueIdSet & externalInputs);

  NABoolean includeCurrentRow() const { return includeCurrentRow_; }

private:

  NABoolean includeCurrentRow_;

}; // class ItmSeqRowsSince

//------------------------------------------------------------------------
// Moving function class.
//
//------------------------------------------------------------------------
//
class ItmSeqMovingFunction : public ItmSequenceFunction
{
public:
  ItmSeqMovingFunction (OperatorTypeEnum itemType,
                        ItemExpr *valPtr1, ItemExpr *valPtr2, ItemExpr *valPtr3 = NULL)
         : ItmSequenceFunction(itemType, valPtr1, valPtr2, valPtr3),
         skipMovingMinMaxTransformation_(FALSE)
  { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~ItmSeqMovingFunction();

  // method to do code generation
  virtual short codeGen(Generator*);

  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

 void transformNode(NormWA & normWARef,
               ExprValueId & locationOfPointerToMe,
               ExprGroupId & introduceSemiJoinHere,
               const ValueIdSet & externalInputs);


  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();
  virtual NABoolean hasEquivalentProperties(ItemExpr * other);

private:                               // the following are invoked only from within transformNode()

 ItemExpr *transformMovingVariance();
 ItemExpr *transformMovingSDev();
 ItemExpr *transformMovingAvg();
 ItemExpr *transformMovingSum();
 ItemExpr *transformMovingCount();
 ItemExpr *transformMovingMinMax();
 ItemExpr *transformMovingRank();

  // the following are used only in transformNode() for MovingMin/Max
  NABoolean skipMovingMinMaxTransformation_;
  NABoolean getSkipMovingMinMaxTransformation() { return skipMovingMinMaxTransformation_; }
  void setSkipMovingMinMaxTransformation() { skipMovingMinMaxTransformation_ = TRUE; }

} ;  // class ItmSeqMovingFunction

//------------------------------------------------------------------------
// Function class for sequence function THIS().
//
//------------------------------------------------------------------------
//
class ItmSeqThisFunction : public ItmSequenceFunction
{
public:
  ItmSeqThisFunction(ItemExpr *valPtr)
         : ItmSequenceFunction(ITM_THIS, valPtr)
         {  }
  // virtual destructor

  virtual ~ItmSeqThisFunction();

  // method to do code generation
  virtual short codeGen(Generator*);

  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();
} ;     // class ItmSeqThisFunction

//------------------------------------------------------------------------
// Function class for ItmScalarMinMax.
//
// This node represends the traditional min/max functions of the form:
//
// SCALAR_MIN(A,B) : CASE WHEN (A < B) THEN A ELSE B
// SCALAR_MAX(A,B) : CASE WHEN (A > B) THEN A ELSE B
//------------------------------------------------------------------------
//
class ItmScalarMinMax : public BuiltinFunction
{
public:
  ItmScalarMinMax (OperatorTypeEnum opType, ItemExpr *val1Ptr, ItemExpr *val2Ptr)
    : BuiltinFunction(opType, CmpCommon::statementHeap(), 2, val1Ptr, val2Ptr)
    { allowsSQLnullArg() = FALSE; }

  // virtual destructor
  virtual ~ItmScalarMinMax();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // A transformation method for protecting sequence functions from not
  // being evaluated due to short-circuit evaluation.
  //
  virtual void protectiveSequenceFunctionTransformation(Generator *generator);

  // method to do code generation
  virtual short codeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

}; // class ItmScalarMinMax

//------------------------------------------------------------------------
// Function class for sequence function NotTHIS().
// Merely a No-op wrapper used during tranformation
//  to indicate that no THIS function occurs
// below this point.
//------------------------------------------------------------------------
//
class ItmSeqNotTHISFunction : public ItmSequenceFunction
{
public:
  ItmSeqNotTHISFunction(ItemExpr *valPtr)
         : ItmSequenceFunction(ITM_NOT_THIS, valPtr)
         {  }
  // virtual destructor

  virtual ~ItmSeqNotTHISFunction();

  // a virtual function for type propagating the node
  virtual const NAType * synthesizeType();

  // method to do code generation
  virtual short codeGen(Generator*);

  // method to do precode generation
  virtual ItemExpr * preCodeGen(Generator*);

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                                 CollHeap* outHeap = 0);

} ;     // class ItmSeqNotTHISFunction

// lookup a column in a native hbase table that is being accessed in row format
class HbaseColumnLookup : public BuiltinFunction
{
public:
  HbaseColumnLookup(
       ItemExpr *child0,
       NAString &hbaseCol,
       const NAType * naType = NULL)
    : BuiltinFunction(ITM_HBASE_COLUMN_LOOKUP, 
		      CmpCommon::statementHeap(), 1, child0),
    hbaseCol_(hbaseCol),
    naType_(naType)
    {}

  virtual ~HbaseColumnLookup();

  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  ItemExpr *bindNode(BindWA *bindWA);

  virtual short codeGen(Generator*);

  const NAType * naType() { return naType_; }
  NAString &hbaseCol() { return hbaseCol_; }

  // get a printable string that identifies the operator
  virtual const NAString getText() const
  {
    return "HBASE_COLUMN_LOOKUP";
  };

 private:
  NAString hbaseCol_;
  const NAType *naType_;
}; // class HbaseColumnLookup

// format hbase columns that are being accessed to be displayed
class HbaseColumnsDisplay : public BuiltinFunction
{
public:
  HbaseColumnsDisplay(
		      ItemExpr *child0,
		      ConstStringList * csl = NULL,
		      Lng32 displayWidth = 100000)
    : BuiltinFunction(ITM_HBASE_COLUMNS_DISPLAY, 
		      CmpCommon::statementHeap(), 1, child0),
    csl_(csl),
    displayWidth_(displayWidth)
    {}

  virtual ~HbaseColumnsDisplay();

  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  ItemExpr *bindNode(BindWA *bindWA);

  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  virtual const NAString getText() const
  {
    return "HBASE_COLUMNS_DISPLAY";
  };

  ConstStringList* &csl() { return csl_; }

 private:
 ConstStringList * csl_;

  Lng32 displayWidth_;
}; // class HbaseColumnsDisplay

// create a column to update/insert into an hbase native table
class HbaseColumnCreate : public BuiltinFunction
{
public:
  class HbaseColumnCreateOptions
  {
    friend class HbaseColumnCreate;
  public:
    enum ConvType
    {
      CAST_AS,
      TYPE_AS,
      NONE
    };
    
    HbaseColumnCreateOptions
      (ItemExpr * colName,
       ItemExpr * colVal,
       const NAType * naType,
       ConvType convType) 
      : colName_(colName),
      colVal_(colVal),
      naType_(naType),
      convType_(convType)
      {}

    const NAType * naType() { return naType_;}
    ConvType convType() { return convType_;}
    ItemExpr * colName() { return colName_; }
    ItemExpr * colVal() { return colVal_; }
    void setColName(ItemExpr * c) { colName_ = c; }
    void setColVal(ItemExpr * c) { colVal_ = c; }
    ItemExpr * colNameIE() { return colNameIE_; }
    void setColNameIE(ItemExpr * cn) { colNameIE_ = cn; }

  private:
    ItemExpr * colNameIE_;
    ItemExpr * colName_;
    ItemExpr * colVal_;
    const NAType * naType_;
    ConvType convType_;

  };

  HbaseColumnCreate(
		    NAList<HbaseColumnCreateOptions*> * hccol)		    
    : BuiltinFunction(ITM_HBASE_COLUMN_CREATE, 
		      CmpCommon::statementHeap(), 0, NULL),
    resultType_(NULL),
    hccol_(hccol),
    colNameMaxLen_(0),
    colValMaxLen_(0)
    {}

  virtual ~HbaseColumnCreate();

  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  // a virtual function for performing name binding within the query tree
  virtual ItemExpr * bindNode(BindWA *bindWA);

  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  virtual const NAString getText() const
  {
    return "HBASE_COLUMN_CREATE";
  };

  NABoolean createListSpecified() { return (hccol_ != NULL); };

 private:
  NAString hbaseCol_;
  const NAType *resultType_;

  short colNameMaxLen_;
  Int32 colValMaxLen_;

  NAList<HbaseColumnCreateOptions*> * hccol_;
}; // class HbaseColumnCreate

class HbaseTimestamp : public BuiltinFunction
{
public:
 HbaseTimestamp(ItemExpr * col)
   : BuiltinFunction(ITM_HBASE_TIMESTAMP,
                     CmpCommon::statementHeap(), 1, NULL),
    col_(col),
    tsVals_(NULL),
    colIndex_(-1)
    {}
  
  virtual ~HbaseTimestamp();
  
  virtual NABoolean isCovered
    (const ValueIdSet& newExternalInputs,
     const GroupAttributes& coveringGA,
     ValueIdSet& referencedInputs,
     ValueIdSet& coveredSubExpr,
     ValueIdSet& unCoveredExpr) const;

  virtual Int32 getArity() const { return (child(0) ? 1 : 0); }

  virtual NABoolean isCacheableExpr(CacheWA& cwa)
    { return TRUE; }

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

  virtual const NAType * synthesizeType();
  
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  ItemExpr *bindNode(BindWA *bindWA);

  virtual ItemExpr * preCodeGen(Generator * generator);

  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  virtual const NAString getText() const
  {
    return "HBASE_TIMESTAMP";
  };
  
  void setColIndex(Lng32 idx) { colIndex_ = idx;}
  Lng32 getColIndex() { return colIndex_; }

  const ItemExpr * col() const { return col_; }
  const ItemExpr * tsVals() { return tsVals_; }
 private:
  ItemExpr * col_;
  ItemExpr * tsVals_;

  Lng32 colIndex_;

  NAString colName_;
}; // class HbaseTimestamp

class HbaseTimestampRef : public BuiltinFunction
{
public:
 HbaseTimestampRef(ItemExpr * col)
   : BuiltinFunction(ITM_HBASE_TIMESTAMP_REF,
                     CmpCommon::statementHeap()),
    col_(col)
    {}
  
  virtual ~HbaseTimestampRef();
  
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  ItemExpr *bindNode(BindWA *bindWA);

  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  virtual const NAString getText() const
  {
    return "HBASE_TIMESTAMP_REF";
  };
  
 private:
  ItemExpr * col_;
}; // class HbaseTimestampRef

class HbaseVersion : public BuiltinFunction
{
public:
 HbaseVersion(ItemExpr * col)
   : BuiltinFunction(ITM_HBASE_VERSION,
                     CmpCommon::statementHeap(), 1, NULL),
    col_(col),
    tsVals_(NULL),
    colIndex_(-1)
    {}
  
  virtual ~HbaseVersion();
  
  virtual NABoolean isCovered
    (const ValueIdSet& newExternalInputs,
     const GroupAttributes& coveringGA,
     ValueIdSet& referencedInputs,
     ValueIdSet& coveredSubExpr,
     ValueIdSet& unCoveredExpr) const;

  virtual Int32 getArity() const { return (child(0) ? 1 : 0); }

  virtual NABoolean isCacheableExpr(CacheWA& cwa)
    { return TRUE; }

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

  virtual const NAType * synthesizeType();
  
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  ItemExpr *bindNode(BindWA *bindWA);

  virtual ItemExpr * preCodeGen(Generator * generator);

  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  virtual const NAString getText() const
  {
    return "HBASE_VERSION";
  };
  
  void setColIndex(Lng32 idx) { colIndex_ = idx;}
  Lng32 getColIndex() { return colIndex_; }

  const ItemExpr * col() const { return col_; }
  const ItemExpr * tsVals() { return tsVals_; }
 private:
  ItemExpr * col_;
  ItemExpr * tsVals_;

  Lng32 colIndex_;

  NAString colName_;
}; // class HbaseVersion

class HbaseVersionRef : public BuiltinFunction
{
public:
 HbaseVersionRef(ItemExpr * col)
   : BuiltinFunction(ITM_HBASE_VERSION_REF,
                     CmpCommon::statementHeap()),
    col_(col)
    {}
  
  virtual ~HbaseVersionRef();
  
  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  ItemExpr *bindNode(BindWA *bindWA);

  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  virtual const NAString getText() const
  {
    return "HBASE_VERSION_REF";
  };
  
 private:
  ItemExpr * col_;
}; // class HbaseVersionRef

// generate a sequence number in a dml query.
class SequenceValue : public BuiltinFunction
{
public:
  SequenceValue(
		const CorrName &seqCorrName,
		NABoolean currVal = FALSE,
		NABoolean nextVal = TRUE)
    : BuiltinFunction(ITM_SEQUENCE_VALUE,
		      CmpCommon::statementHeap(), 0, NULL),
    seqCorrName_(seqCorrName),
    nextVal_(nextVal),
    currVal_(currVal),
    naTable_(NULL)
    {}

  virtual ~SequenceValue();

  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  ItemExpr *bindNode(BindWA *bindWA);

  virtual short codeGen(Generator*);

  // get a printable string that identifies the operator
  virtual const NAString getText() const
  {
    return "SEQUENCE_VALUE";
  };

  CorrName &seqCorrName() { return seqCorrName_; }

  inline const NATable  *getNATable()           const { return naTable_; }
  void setNATable (NATable *naTable) {naTable_ = naTable;}

  virtual NABoolean isCacheableExpr(CacheWA& cwa)
    { return TRUE; }

  // append an ascii-version of ItemExpr into cachewa.qryText_
  virtual void generateCacheKey(CacheWA& cwa) const;

 private:
  CorrName seqCorrName_;
  NABoolean currVal_;
  NABoolean nextVal_;

  // natable for the sequence object
  const NATable *naTable_;

}; // class SequenceValue


// ROWNUM().
// Returns the current number of row being returned to application.
// Starts at 1 and increments after it is returned.
// Can only be used in the outermost select and in the outermost
// where predicate.
class RowNumFunc : public BuiltinFunction
{
public:
  RowNumFunc()
       : BuiltinFunction(ITM_ROWNUM, CmpCommon::statementHeap(),
                         0, NULL) {}

  // virtual destructor
  virtual ~RowNumFunc();

  virtual ItemExpr * bindNode(BindWA *bindWA);
  virtual const NAType * synthesizeType();

  virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
				 CollHeap* outHeap = 0);

  virtual NABoolean isCovered(const ValueIdSet& newExternalInputs,
			      const GroupAttributes& newRelExprAnchorGA,
	   	              ValueIdSet& referencedInputs,
			      ValueIdSet& coveredSubExpr,
			      ValueIdSet& unCoveredExpr) const;

  NABoolean canBeUsedInGBorOB(NABoolean setErr);

}; // class RowNumFunc

class SplitPart : public CacheableBuiltinFunction
{
public: 
  SplitPart(ItemExpr *val1Ptr, ItemExpr *val2Ptr, ItemExpr *val3Ptr)
    :CacheableBuiltinFunction(ITM_SPLIT_PART, 3, val1Ptr, val2Ptr, val3Ptr)
    {
      allowsSQLnullArg() = FALSE;
    } 

   virtual ~SplitPart();

   // a virtual function for type propagating the node
   virtual const NAType * synthesizeType();
   
   virtual ItemExpr * copyTopNode(ItemExpr *derivedNode = NULL,
                      CollHeap *outheap = 0);
   virtual ItemExpr * preCodeGen(Generator*);
}; //class SplitPart

#endif /* ITEMFUNC_H */