#ifndef NormWA_H
#define NormWA_H
/* -*-C++-*-
*************************************************************************
*
* File:         NormWA.h
* Description:  The workarea used by the normalizer
* Created:      December 7, 1994
* Language:     C++
*
*
// @@@ 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 @@@
*
*
*************************************************************************
*/

#include "BaseTypes.h"
#include "Collections.h"
#include "VEGTable.h"
#include "ValueDesc.h"
// ----------------------------------------------------------------------
// contents of this file
// ----------------------------------------------------------------------
class NormWA;
class SqoWA;

// ----------------------------------------------------------------------
// Forward declarations
// ----------------------------------------------------------------------
class VEGReference;
class CmpContext;

// ***********************************************************************
// SqoWA
//
// The work area for the Semantic Query Optimizer phase.
//
// For now to keep track of things we have to undo if we hit 
// conditions where we cannot proceed with the SQO and have to restore
// the relExpr tree to its original form.
// ***********************************************************************

enum SqoChangedItemExprEnum { SQO_REPLACED, SQO_NEWCHILD, SQO_NEWOPTYPE };
enum SqoChangedRelExprEnum { SQO_REASSIGNED_VREGION };

class SqoChangedItemExprs: public NABasicObject
{
public:
     
        // Constructor
      SqoChangedItemExprs(ValueId changedId, SqoChangedItemExprEnum what, 
                          ItemExpr *old , Int32 changedChild, Lng32 subqId) : 
                             changedVid_(changedId), 
                             whatChanged_(what), 
                             oldItemExpr_(old), 
                             changedChild_(changedChild),
                             subqId_(subqId) 
      {}

      SqoChangedItemExprs(ValueId changedId, SqoChangedItemExprEnum what, 
                          ItemExpr *old, const OperatorTypeEnum oldOpType, 
                          Lng32 subqId) : 
                             changedVid_(changedId), 
                             whatChanged_(what), 
                             oldItemExpr_(old), 
                             changedChild_(0), 
                             oldOperatorType_(oldOpType),
                             subqId_(subqId) 
      {}

      SqoChangedItemExprs(ValueId changedId, SqoChangedItemExprEnum what, 
                          ItemExpr *old, Lng32 subqId ) : 
                             changedVid_(changedId), 
                             whatChanged_(what), 
                             oldItemExpr_(old), 
                             changedChild_(0),
                             subqId_(subqId) 
      {}

        // Destructor
      ~SqoChangedItemExprs() {}
      
      NABoolean undoChanges(NormWA & normWARef, Lng32 subqId);

private:
      Lng32                      subqId_;
      ValueId                   changedVid_;
      SqoChangedItemExprEnum    whatChanged_;
      ItemExpr                  *oldItemExpr_;
      Lng32                       changedChild_;
      OperatorTypeEnum          oldOperatorType_;
}; // class SqoChangedItemExprs


class SqoChangedRelExprs: public NABasicObject
{
public:
     
        // Constructor
      SqoChangedRelExprs(RegionId vegRegion, SqoChangedRelExprEnum what, 
                         RelExpr *changedExpr, RelExpr *origExpr, 
                         Lng32 origChildId, Lng32 changedChildId, Lng32 subqId) 
          : vregion_(vegRegion), whatChanged_(what), 
            changedRelExpr_(changedExpr), originalRelExpr_(origExpr), 
            origChildId_(origChildId), changedChildId_(changedChildId),
            subqId_(subqId) 
      {}

        // Destructor
      ~SqoChangedRelExprs() {}

      NABoolean undoChanges(NormWA & normWARef, Lng32 subqId);

private:
      Lng32                     subqId_;
      SqoChangedRelExprEnum    whatChanged_;
      RelExpr                  *changedRelExpr_;
      RelExpr                  *originalRelExpr_;
      Lng32                      changedChildId_;
      Lng32                      origChildId_;
      RegionId                 vregion_;
}; // class SqoChangedRelExprs

class SqoWA: public NABasicObject
{
public:
         // Constructors
      SqoWA() 
              : changedItemExprs_(CmpCommon::statementHeap()),
                changedRelExprs_(CmpCommon::statementHeap()),
                subqId_(0)
      {}

      SqoWA(const SqoWA & other) 
              : changedItemExprs_(other.changedItemExprs_),
                changedRelExprs_(other.changedRelExprs_),
                subqId_(other.subqId_)
      {}

         // Destructor
      ~SqoWA() {}

      void incrementSubQId() { subqId_ ++; }
      Lng32 getSubQId() { return subqId_; }

      void insertChangedItemExpr(ValueId changedId, SqoChangedItemExprEnum whatChanged, ItemExpr *origExpr )
      {
         changedItemExprs_.insert( new (CmpCommon::statementHeap())
                                     SqoChangedItemExprs(changedId, 
                                     whatChanged,
                                     origExpr, subqId_ )); 
      }

      void insertChangedItemExpr(ValueId changedId, SqoChangedItemExprEnum whatChanged, ItemExpr *origExpr, Int32 changedChild )
      {
         changedItemExprs_.insert( new (CmpCommon::statementHeap())
                                     SqoChangedItemExprs(changedId, 
                                     whatChanged,
                                     origExpr,
                                     changedChild, subqId_ )); 
      }

      void insertChangedItemExpr(ValueId changedId, SqoChangedItemExprEnum whatChanged, ItemExpr *origExpr, OperatorTypeEnum origOp )
      {
         changedItemExprs_.insert( new (CmpCommon::statementHeap())
                                     SqoChangedItemExprs(changedId, 
                                     whatChanged,
                                     origExpr,
                                     origOp, subqId_ )); 
      }
      void insertChangedRelExpr(RelExpr *originalRel, RelExpr *changedRel, SqoChangedRelExprEnum whatChanged, RegionId vregionId, Int32 origRegionChild, Int32 newRegionChild)
      {
         changedRelExprs_.insert( new (CmpCommon::statementHeap())
                                     SqoChangedRelExprs(vregionId, whatChanged,
                                        changedRel, originalRel,
                                        origRegionChild, 
                                        newRegionChild, subqId_)); 
      }

      void undoChanges(NormWA & normWARef );
  
private:
     Lng32   subqId_;
     // We need a list of ItemExprs that we have changed
     LIST(SqoChangedItemExprs *) changedItemExprs_;


     // We need to remember a list of RelExprs that we have changed
     // For now the only thing we change for RelExprs are the ownership
     // of VEGRegions, thus we have to remember the original owner and 
     // the RegionId.
     LIST(SqoChangedRelExprs *)  changedRelExprs_;

     
}; // class SqoWA


// ***********************************************************************
//
// Region
//
// A ValueId Equality Group (VEG) contains the ValueIds of all
// expressions that are related by an "=" relationship. This means,
// that each expression that belongs to a certain VEG will produce
// the same value as any other expression that belongs to the same 
// VEG. Aggregeting operation, such as, summation, averaging or 
// even an outer join impose certain restrictions on how VEGs are
// formed. For example, consider the query tree 
//
//                       IJ-> T1.c = T3.c
//                      /  \ 
//                    T1    IJ -> T2.c = T3.c
//                         /  \ 
//                       T2    T3
//
// The predicate T1.c = T3.c causes the columns T1.c and T3.c to 
// belong to a VEG, VEG1. The predicate T2.c = T3.c defines another 
// VEG, VEG2. Since each inner join transmits values without any 
// aggregation, it is clear that since T1.c = T3.c and T2.c = T3.c
// T1.c must also be equal to T2.c. Hence VEG1 and VEG2 can be 
// into a single VEG. Now consider the query tree,
//
//                                               R1
//                          ..........................
//                       LJ.-> T1.c = T3.c       R2
//                      / . \   ......................
//                    T1 .  LJ. -> T2.c = T3.c   R3
//                      .  / .\ 
//                     . T2  :  T3
//                     :     :.......................
//                     :..............................
//
// For the sake of disucssion, the query tree is partitioned into
// three zones or regions, called Regions R1, R2 and R3. Each Region
// defines a scope within which a certain equality relationship is
// valid. Thus the relationship T1.c = T3.c is valid only within R2
// while the relationship T2.c = T3.c is valid only within R3. The 
// effect of such a partionining is seen in the manner in which VEGs
// are formed. The predicate T1.c = T3.c causes the columns T1.c and 
// T3.c to belong to a VEG, VEG1. Similarly, the predicate T2.c = T3.c
// causes the columns T2.c and T3.c to belong to another VEG, VEG2.
// VEG1 and VEG2 cannot be combined because T3.c values that flow
// from R3 into R2 can suffer null augmentation and hence change.
//
// The normalizer creates a new Region for 
// a) the right subtree of a left outer join 
// b) the left subtree of a right outer join and 
// c) each of the left and right subtrees of a full outer join
//   
// ***********************************************************************

// ***********************************************************************
// NormWA
//
// The work area for the Transform/Normalize/Rewrite phase.
//
// ***********************************************************************
class NormWA : public NABasicObject
{
public:
  // --------------------------------------------------------------------
  // Constructor functions
  // --------------------------------------------------------------------

  NormWA(CmpContext* cmpContext)
    : currentCmpContext_(cmpContext), subqUnderExprTreeCount_(0),
      walkingAnExprTreeCount_(0), complexScalarExprCount_(0), 
      nullCount_(0), notCount_(0), orCount_(0), inConstraintsCount_(0),
	  inBlockedUnionCount_(0) //++Triggers -
      // QSTUFF
      ,inEmbeddedUpdateOrDelete_(FALSE)
      // QSTUFF
      ,inEmbeddedInsert_(FALSE)
      ,inBeforeTrigger_(FALSE)
      ,inJoinPredicate_(FALSE)
      ,mergeUpdDelCount_(0)
      ,leftJoinConversionCount_(0)
      ,correlatedSubqCount_(0)
      ,inSelectListCount_(0)
      ,inHavingClause_(FALSE)
      ,inValueIdProxy_(FALSE)
      ,inGenericUpdateAssign_(FALSE)
      ,inMergeUpdWhere_(FALSE)
      ,inMVQueryRewrite_(FALSE)
      ,containsJoinsToBeEliminated_(FALSE)
      ,containsSemiJoinsToBeTransformed_(FALSE)
      ,extraHubVertex_(NULL)
      ,leftJoinChildVEGRegion_(NULL)
      ,containsGroupBysToBeEliminated_(FALSE)
      ,checkForExtraHubTables_(FALSE)
      ,compilingMVDescriptor_(FALSE)
      ,requiresRecursivePushdown_(FALSE)
      ,readList_(CmpCommon::statementHeap())
      ,writeList_(CmpCommon::statementHeap())
      ,origSeqFunction_(CmpCommon::statementHeap())
      ,equiTransformedExpr_(CmpCommon::statementHeap())
      ,commonSubExprCount_(0)
  {
    vegTable_ = new (wHeap()) VEGTable;
    sqoWARef_ = new (CmpCommon::statementHeap()) SqoWA;
  }

  
  NormWA(const NormWA & other) 
    : currentCmpContext_(other.currentCmpContext_),
      walkingAnExprTreeCount_(other.walkingAnExprTreeCount_),
      subqUnderExprTreeCount_(other.subqUnderExprTreeCount_),
      complexScalarExprCount_(other.complexScalarExprCount_), 
      nullCount_(other.nullCount_), 
      notCount_(other.notCount_), 
      orCount_(other.orCount_),
      inConstraintsCount_(other.inConstraintsCount_),
      inBlockedUnionCount_(other.inBlockedUnionCount_), //++ Triggers -
      vegTable_(other.vegTable_)
      // QSTUFF
      ,inEmbeddedUpdateOrDelete_(other.inEmbeddedUpdateOrDelete_)
      // QSTUFF
      ,inEmbeddedInsert_(other.inEmbeddedInsert_)
      ,inBeforeTrigger_(other.inBeforeTrigger_)
      ,inJoinPredicate_(other.inJoinPredicate_)
      ,mergeUpdDelCount_(other.mergeUpdDelCount_)
      ,leftJoinConversionCount_(other.leftJoinConversionCount_)
      ,correlatedSubqCount_(other.correlatedSubqCount_)
      ,inSelectListCount_(other.inSelectListCount_)
      ,inHavingClause_(other.inHavingClause_)
      ,inValueIdProxy_(other.inValueIdProxy_)
      ,inGenericUpdateAssign_(other.inGenericUpdateAssign_)
      ,inMergeUpdWhere_(other.inMergeUpdWhere_)
      ,inMVQueryRewrite_(other.inMVQueryRewrite_)
      ,containsJoinsToBeEliminated_(other.containsJoinsToBeEliminated_)
      ,containsSemiJoinsToBeTransformed_(other.containsSemiJoinsToBeTransformed_)
      ,extraHubVertex_(other.extraHubVertex_)
      ,sqoWARef_(other.sqoWARef_)
      ,leftJoinChildVEGRegion_(other.leftJoinChildVEGRegion_)
      ,containsGroupBysToBeEliminated_(other.containsGroupBysToBeEliminated_)
      ,checkForExtraHubTables_(FALSE)
      ,compilingMVDescriptor_(FALSE)
      ,requiresRecursivePushdown_(other.requiresRecursivePushdown_)
      ,readList_(other.readList_, STMTHEAP)
      ,writeList_(other.writeList_, STMTHEAP)
      ,origSeqFunction_(other.origSeqFunction_, STMTHEAP)
      ,equiTransformedExpr_(other.equiTransformedExpr_, STMTHEAP)
      ,commonSubExprCount_(0)
  {}
  
  // --------------------------------------------------------------------
  // Destructor functions
  // --------------------------------------------------------------------
  ~NormWA(){}
  
  // --------------------------------------------------------------------
  // Initialize a NormWA free of all state information.
  // This method is called at the root of each (sub)query tree.
  // --------------------------------------------------------------------
  void clearStateInformation()
  { walkingAnExprTreeCount_ = 
    complexScalarExprCount_ =
    nullCount_ = notCount_ = orCount_ = inConstraintsCount_ = 0;
    inValueIdProxy_ = FALSE;  // not a recursive flag.
  }
  
  // --------------------------------------------------------------------
  // Region
  // --------------------------------------------------------------------
  void allocateAndSetVEGRegion(const VEGRegionTypeEnum tev,
                               ExprNode * const ownerExprPtr,
                               Lng32 subtreeId = 0)
  { 
    vegTable_->allocateAndSetVEGRegion(tev,ownerExprPtr,subtreeId); 
  } 

  void locateAndSetVEGRegion(ExprNode * const ownerExprPtr,
                             Lng32 subtreeId = 0) 
           { vegTable_->locateAndSetVEGRegion(ownerExprPtr, subtreeId); }

  void restoreOriginalVEGRegion() { vegTable_->restoreOriginalRegion(); }
  void reassignVEGRegion(ExprNode * ownerExprPtr, 
                         Lng32       ownerSubtreeId,
                         ExprNode * newOwnerExprPtr, 
                         Lng32       newOwnerSubtreeId = 0) 
  { 
    vegTable_->reassignVEGRegion(ownerExprPtr, 
                      ownerSubtreeId, newOwnerExprPtr, newOwnerSubtreeId); 
  }

  // --------------------------------------------------------------------
  // Add a ValueId Equality Group (VEG) for each "=" predicate.
  // --------------------------------------------------------------------
  void addVEG(const ValueId & expr1Id, const ValueId & expr2Id)
                                 { vegTable_->addVEG(expr1Id, expr2Id); }

  void addVEG(const ValueIdSet & setOfValues)
                                      { vegTable_->addVEG(setOfValues); }

  void deleteVEGMember(const ValueId &vId)
                                     { vegTable_->deleteVEGMember(vId); }

  // ++Trigger -, from later version 
  void addVEGInOuterRegion(const ValueId & expr1Id, const ValueId & expr2Id)
                                 { vegTable_->addVEGInOuterRegion(expr1Id, expr2Id); }

  // --------------------------------------------------------------------
  // Accessor method for retrieving a VEG, given the ValueId of a 
  // potential member.
  // --------------------------------------------------------------------
  ItemExpr * getVEGReference(const ValueId & exprId) const
      { return vegTable_->getVEGReference(exprId,leftJoinChildVEGRegion_); }

  // --------------------------------------------------------------------
  // The following method locates the Region where the owner ExprNode
  // produces the given value and marks it as "To Be Merged".
  // --------------------------------------------------------------------
  VEGRegion * locateVEGRegionAndMarkToBeMerged(const ValueId & exprId) const
          { return vegTable_->locateVEGRegionAndMarkToBeMerged(exprId); }

  // --------------------------------------------------------------------
  // Do the same as above. But also look at the contents of the
  // ToBeMerged Regions to see if we could merge some more regions as
  // well because contents of the region might contain null_instantiated
  // columns in some other regions.
  // --------------------------------------------------------------------
  void locateVEGRegionAndMarkToBeMergedRecursively(const ValueId & exprId);

  // --------------------------------------------------------------------
  // The following method locates the Region of which the given ExprNode
  // is the owner and returns TRUE if it is merged; FALSE otherwise.
  // --------------------------------------------------------------------
  NABoolean locateVEGRegionAndCheckIfMerged(ExprNode * const ownerExpr) const
        { return vegTable_->locateVEGRegionAndCheckIfMerged(ownerExpr); }
  
  NABoolean locateVEGRegionAndCheckIfMerged
  (ExprNode * const ownerExpr, Lng32 subtreeId) const
  { return vegTable_->locateVEGRegionAndCheckIfMerged(ownerExpr, subtreeId); }
  

  // --------------------------------------------------------------------
  // Post processing of the VEGTable after it is built.
  // --------------------------------------------------------------------
  void processVEGRegions()            { vegTable_->processVEGRegions(); }

  //-----------------------------------------------------------------------
  //A method to locate the VEG region given an ExprNode
  //-----------------------------------------------------------------------
  VEGRegion* locateVEGRegion(ExprNode *ownerENptr)
                            { return vegTable_->locateVEGRegion(ownerENptr);}

  //-----------------------------------------------------------------------
  //A method to locate the VEG region given an ExprNode and subtreeId
  //-----------------------------------------------------------------------
  VEGRegion* locateVEGRegion(ExprNode *ownerENptr, Lng32 subtreeId)
                            { return vegTable_->locateVEGRegion(ownerENptr, subtreeId);}


  // --------------------------------------------------------------------
  // A method for performing transitive closure of "=" predicates.
  // --------------------------------------------------------------------
  ItemExpr * performTC(const ValueId & vegMember) const
                              { return vegTable_->performTC(vegMember); }
  
  // --------------------------------------------------------------------
  // The Normalizer sets the "walking an expression tree" flag when
  // processing one of the following expressions:
  // 1) An IF-THEN-ELSE (SQL CASE statement).
  // 2) An aggregate function.
  // 3) A predicate tree that is root in an OR.
  // 4) A predicate tree that is root in a  NOT.
  // 5) A predicate tree that is root in an IS NULL/IS UNKNOWN.
  // The method that sets it is also expected to restore it to its 
  // original state.
  // --------------------------------------------------------------------
  void setWalkingAnExprTreeFlag()       { walkingAnExprTreeCount_++; }
  void restoreWalkingAnExprTreeFlag()   { walkingAnExprTreeCount_--; }
  NABoolean walkingAnExprTree() const   { return walkingAnExprTreeCount_ > 0; }
  Lng32 getWalkingAnExprTreeCount()      { return walkingAnExprTreeCount_; }

  // ---------------------------------------------------------------------
  // Needs to remember this subquery is under an expr, so that when we go
  // back to transform the new Join and its subtree introduced, we won't
  // incorrectly use the selection predicates in the subquery to convert
  // left join into inner join.
  // ---------------------------------------------------------------------
  void setSubqUnderExprTreeFlag()       { subqUnderExprTreeCount_++; }
  void restoreSubqUnderExprTreeFlag()   { subqUnderExprTreeCount_--; }
  NABoolean subqUnderExprTree() const   { return subqUnderExprTreeCount_ > 0; }

  // --------------------------------------------------------------------
  // The Normalizer sets the complex scalar expression flag while 
  // processing one of the following expressions:
  // 1) An IF-THEN-ELSE (SQL CASE statement).
  // 2) A user defined function.
  // The method that sets it is also expected to restore it to its 
  // original state.
  // --------------------------------------------------------------------
  void setComplexScalarExprFlag(); 
  void restoreComplexScalarExprFlag(); 
  NABoolean inAComplexScalarExpr() const { return complexScalarExprCount_ > 0; }

  // --------------------------------------------------------------------
  // The Normalizer NULL flag is usually set when an IS NULL or an
  // IS UNKNOWN is encountered in the transformed tree. The method 
  // that sets it is also expected to restore it to its original state.
  // This is because normalization is performed recursively and an
  // IS NULL or an IS UNKNOWN may be encountered while processing
  // the operand of another ISNULL or IS UNKNOWN.
  // The subquery transformation uses this information. 
  // --------------------------------------------------------------------
  void setNullFlag(); 
  void restoreNullFlag(); 
  NABoolean isChildOfAnIsNull() const   { return nullCount_ > 0; }
  
  // --------------------------------------------------------------------
  // The Normalizer NOT flag is usually set when a NOT is encountered 
  // in the transformed tree. The method that sets it is also expected 
  // to restore it to its original state. This is because normalization 
  // is performed recursively and a NOT may be encountered while 
  // processing the operand of another NOT.
  // The subquery transformation uses this information. 
  // --------------------------------------------------------------------
  void setNotFlag(); 
  void restoreNotFlag(); 
  NABoolean isChildOfANot() const       { return notCount_ > 0; }

  // --------------------------------------------------------------------
  // The Normalizer OR flag is usually set when an OR is encountered 
  // in the transformed tree. The method that sets it is also expected 
  // to restore it to its original state. This is because normalization 
  // is performed recursively and an OR may be encountered while 
  // processing the subtree rooted in another OR.
  // The subquery transformation uses this information. 
  // --------------------------------------------------------------------
  void setOrFlag(); 
  void restoreOrFlag(); 
  NABoolean haveAnOrAncestor() const    { return orCount_ > 0; }

  // --------------------------------------------------------------------
  // Check constraints are relied upon to enforce things, so we cannot
  // rely on them and do certain transforms (eliminate/strength-reduce)
  // when we are transforming constraints -- that would be circulus in probando.
  // --------------------------------------------------------------------
  void setInConstraintsFlag()           { inConstraintsCount_++; }
  void restoreInConstraintsFlag()       { inConstraintsCount_--; }
  NABoolean inConstraints() const       { return inConstraintsCount_ > 0; }

  // --------------------------------------------------------------------
  // 
  // If a recursive/cascaded triggers backbone has a connection to the 
  // triggering generic update the connection is using @old and @new 
  // columns from the triggering generic update.
  // We found out that equality relation between each two levels of cascaded 
  // triggers might cause the creation of a huge VEGREF that the optimizer  
  // can't handle in a reasonable time.
  // To prevent this problem will block the creation of VEGs on equal predicates
  // involving a @old/ @new columns on high cascade levels.
  // Cascade levels are counted by inBlockedUnionCount_, since every cascaded 
  // trigger backbone top node is a BlockedUnion
  //
  // --------------------------------------------------------------------
  void setInBlockedUnionCount()		{ inBlockedUnionCount_++; }
  void restoreInBlockedUnionCount()	{inBlockedUnionCount_--; }
  Lng32 getInBlockedUnionCount()		{ return inBlockedUnionCount_; }

  // retrieve the current CmpContext
  CmpContext* currentCmpContext() const { return currentCmpContext_; }

  // retrieve the wHeap
  CollHeap* wHeap();

  //QSTUFF
  // these lists contain the names of tables read and updates
  // respectively to check whether there is a potential read/write
  // conflict
  LIST(NAString) &getWriteList()  { return writeList_; }
  LIST(NAString) &getReadList()   { return readList_; }

  NABoolean isInEmbeddedUpdateOrDelete() { return inEmbeddedUpdateOrDelete_; }
  void      setInEmbeddedUpdateOrDelete(NABoolean i) { inEmbeddedUpdateOrDelete_ = i;}
  //QSTUFF

  // Support for embedded inserts from VALUES
  NABoolean isInEmbeddedInsert() { return inEmbeddedInsert_; }
  void      setInEmbeddedInsert (NABoolean i) { inEmbeddedInsert_ = i;}
  
  NABoolean isInBeforeTrigger() { return inBeforeTrigger_; }
  void      setInBeforeTrigger(NABoolean i) { inBeforeTrigger_ = i;}

  NABoolean isInJoinPredicate() { return inJoinPredicate_; }
  void      setInJoinPredicate(NABoolean i) { inJoinPredicate_ = i;}
  
  long getMergeUpdDelCount()	    { return mergeUpdDelCount_; }
  void setMergeUpdDelCount(long val) {mergeUpdDelCount_ = val;}
  void incrementMergeUpdDelCount()   { mergeUpdDelCount_++; }

  NABoolean requiresLeftTSJLinearization() 
  { return leftJoinConversionCount_ > 1; }
  
  void incrementLeftJoinConversionCount()   { leftJoinConversionCount_++; }
  void decrementLeftJoinConversionCount()   { leftJoinConversionCount_--; }
  Lng32 getLeftJoinConversionCount()	    { return leftJoinConversionCount_; }
  void setLeftJoinConversionCount(Lng32 val) {leftJoinConversionCount_ = val;}

  NABoolean requiresSemanticQueryOptimization() 
  { return ((correlatedSubqCount_ > 0) || 
	    containsJoinsToBeEliminated_ ||
            checkForExtraHubTables_ ||
	    containsGroupBysToBeEliminated_ ||
	    containsSemiJoinsToBeTransformed_ ||
            commonSubExprCount_ > 0); }
  
  void incrementCorrelatedSubqCount()		{ correlatedSubqCount_++; }
  void decrementCorrelatedSubqCount()	{correlatedSubqCount_--; }
  Lng32 getCorrelatedSubqCount()		{ return correlatedSubqCount_; }
  void setCorrelatedSubqCount(Lng32 val)  {correlatedSubqCount_ = val;}

  NABoolean requiresRecursivePushdown() 
          { return requiresRecursivePushdown_;}
  void setRequiresRecursivePushdown(NABoolean val) 
	  {requiresRecursivePushdown_ = val;}

  NABoolean containsJoinsToBeEliminated() 
          { return containsJoinsToBeEliminated_;}
  void setContainsJoinsToBeEliminated(NABoolean val) 
	  {containsJoinsToBeEliminated_ = val;}

  NABoolean checkForExtraHubTables()
          { return checkForExtraHubTables_;}
  void setCheckForExtraHubTables(NABoolean val)
          {checkForExtraHubTables_ = val;}

  NABoolean containsGroupBysToBeEliminated() 
                   { return containsGroupBysToBeEliminated_;}
  void setContainsGroupBysToBeEliminated(NABoolean val) 
	           {containsGroupBysToBeEliminated_ = val;}

  NABoolean containsSemiJoinsToBeTransformed() 
          { return containsSemiJoinsToBeTransformed_;}
  void setContainsSemiJoinsToBeTransformed(NABoolean val) 
	  {containsSemiJoinsToBeTransformed_ = val;}
  RelExpr* getExtraHubVertex() { return extraHubVertex_;}
  void setExtraHubVertex(RelExpr* ptr) 
	  {extraHubVertex_ = ptr;}

  Int32 getCommonSubExprRefCount() { return commonSubExprCount_; }
  void incrementCommonSubExprRefCount() { commonSubExprCount_++; }

  // Return a reference to the Semantic Query WA
  SqoWA * getSqoWA() { return sqoWARef_;}


  // --------------------------------------------------------------------
  // counter to record if we are currently transforming expressions in a select 
  // list (i.e. compExpr). This is used for subquery unesting. A subquery in a 
  // select list does not reject null values since there is no predicate 
  // outside the subquery and the result if the subquery is produced as is. 
  // If the subquery produces a null value that must be retained. Therefore 
  // subqureries in a select list are equivalent to other predicates that do 
  // not reject null values (for e.g. IS NOT NULL, count(*) = 0, ...)
  // --------------------------------------------------------------------
  void setInSelectList()           { inSelectListCount_++; }
  void restoreInSelectList()       { inSelectListCount_--; }
  NABoolean inSelectList() const        { return inSelectListCount_ > 0; }

  // --------------------------------------------------------------------
  // flag to record if we are currently transforming expressions in a HAVING 
  // clause (i.e. selection pred of GroupByAgg). This is used for subquery 
  // unesting. A subquery in a HAVING clause currently cannot be unnested.
  // --------------------------------------------------------------------
  void setInHavingClause(NABoolean val )       { inHavingClause_ = val; }
  NABoolean inHavingClause() const             { return inHavingClause_; }

  // --------------------------------------------------------------------
  // flag to record if we are currently transforming a ValueIdProxy
  // The assumption is that the we have already split out the different 
  // outputs of MVFs or Subqueries of degree > 1. Thus we want the transform
  // to only return a descrete value, not a list.
  // This is used for flattening ITM_ITEM_LISTS of subqueries with degree > 1 
  // and MVFs
  // --------------------------------------------------------------------
  void setInValueIdProxy(NABoolean val ) { inValueIdProxy_ = val; }
  NABoolean inValueIdProxy() const       { return inValueIdProxy_; }

  // --------------------------------------------------------------------
  // flag to record if we are currently transforming expressions 
  // associated with a assign expression of a GenericUpdate node 
  // Examples are newRecExpr, insert expresion for mergeThis is used for subquery unesting. 
  // A subquery in an INSERT/UPDATE/DELETE needs a left join to be unnested.
  // --------------------------------------------------------------------
  void setInGenericUpdateAssign(NABoolean val) {inGenericUpdateAssign_ = val;}
  NABoolean inGenericUpdateAssign() const           {return inGenericUpdateAssign_;}

  // flag to record if we are currently transforming expressions in 
  // a Merge ... Update ... Where predicate. 
  void setInMergeUpdWhere(NABoolean val) {inMergeUpdWhere_ = val;}
  NABoolean inMergeUpdWhere() const {return inMergeUpdWhere_;}

  // Use this to avoid rangespec transformation in the Normalizer if called by
  // MVQR for a node in rewritten query (since it will already have been done).
  void setInMVQueryRewrite(NABoolean val) { inMVQueryRewrite_ = val; }
  NABoolean inMVQueryRewrite() const      { return inMVQueryRewrite_; }

  //----------------------------------------------------------------------
  //
  void setAllSeqFunctions(ValueIdSet v) { allSeqFunctions_ = v;}
  ValueIdSet getAllSeqFunctions() const { return allSeqFunctions_; }
  void resetAllSeqFunctions () { allSeqFunctions_.clear(); }
  void addSeqFunction( ValueId v) { allSeqFunctions_ += v ; }
  ValueId getEquivalentItmSequenceFunction(ValueId newSeqId);
  void optimizeSeqFunctions( ItemExpr * ie, ItemExpr * pie, Int32 idx );


  void resetSeqFunctionsCache(){
    origSeqFunction_.clear();
    equiTransformedExpr_.clear();
  }

  void insertIntoSeqFunctionsCache (ItemExpr * orig, ValueId transformed) {
    origSeqFunction_.insert( orig);
    equiTransformedExpr_.insert(  transformed );
    CMPASSERT (origSeqFunction_.entries() == equiTransformedExpr_.entries());
  }

  NABoolean retrieveFromSeqFunctionsCache(CollIndex index, ValueId &transformed) {
    if (index <0 || index > origSeqFunction_.entries()-1) {
      return FALSE;
    }
    //orig = origSeqFunction_[index];
    transformed = equiTransformedExpr_[index];
    return TRUE;
  }

  CollIndex SeqFunctionsCacheEntries(){
    CMPASSERT (origSeqFunction_.entries() == equiTransformedExpr_.entries());
    return origSeqFunction_.entries();
  }
  
  NABoolean findEquivalentInSeqFunctionsCache( ItemExpr * newItem , ValueId &cacheEquivTransSeqId);

  VEGTable * getVEGTable() {return vegTable_ ;}

  const RelExpr * getCurrentOwnerExpr() ;

  void saveLeftJoinChildVEGRegion(ExprNode * const ownerExprPtr, 
                            Lng32 subtreeId = 0) 
  {leftJoinChildVEGRegion_ = 
           vegTable_->locateVEGRegion(ownerExprPtr, subtreeId); } 

  void resetLeftJoinChildVEGRegion() {leftJoinChildVEGRegion_ = NULL; }

  void setCompilingMVDescriptor(NABoolean b)  { compilingMVDescriptor_ = b; }

  NABoolean compilingMVDescriptor() { return compilingMVDescriptor_; }

private:

  // --------------------------------------------------------------------
  // Counters that keep track of whether an expression is the child of
  // an ISNULL, IS UNKNOWN or a NOT.
  // Whenever a new counter is added, update the following methods:
  // 1) default constructor
  // 2) copy constructor
  // 3) clearStateInformation()
  // --------------------------------------------------------------------
  Lng32 walkingAnExprTreeCount_;
  Lng32 subqUnderExprTreeCount_;

  Lng32 complexScalarExprCount_;

  Lng32 nullCount_;
  
  Lng32 notCount_;

  Lng32 orCount_;

  Lng32 inConstraintsCount_;

  // ++Triggers -
  Lng32 inBlockedUnionCount_;

  // QSTUFF

  // this flag is set to prevent a constant equalitity predicate, e.g.
  // x = 10, to become veggyfied when normalizing an expression containing
  // an embedded delete or update. This prevents the predicate from being
  // lost when not pushing it down to leave operators due to the veg relation
  
  NABoolean inEmbeddedUpdateOrDelete_;

 // this flag is set to prevent a constant equalitity predicate, e.g.
  // x = 10, to become veggyfied when normalizing an expression containing
  // an embedded insert from VALUES. This prevents the predicate from being
  // lost when not pushing it down to leave operators due to the veg relation
  
  NABoolean inEmbeddedInsert_;
   
  // this flag is set to prevent some transformations for binary logic
  // that does not take before triggers into account

  NABoolean inBeforeTrigger_;

  // this flag is set so that ItemExpr trees are not modified during calls
  // to ItemExpr::normalizeNode, when normalizing (i.e. rewriting) the join 
  // predicate. All modifications will be done on a copy of the original 
  // itemexpr. This is necessary since the same valueid may be used in 
  // others parts of the query tree that are in different veg regions. 
  // and any veg rewite that is correct in one region may not be in other 
  // regions.

  NABoolean inJoinPredicate_ ;

  // counter to record the number of mergeupdate/delete in query
  long mergeUpdDelCount_;
  
  // counter to record the number of correlated subqueries where we need to
  // transform the TSJ into a Left Join. During transform 
  // this counter is incremented for each subquery that matches criteria for
  // subquery unnesting.  The criteria is that we have a correlated Subquery
  // (TSJ->GB->Filter), and the GroupBy contains nonNullRejecting predicates
  // (like count() etc)
  Lng32 leftJoinConversionCount_ ;

  // counter to record the number of correlated subqueries. During transform 
  // this counter is incremented for each subquery that matches criteria for
  // subquery unnesting. Then during normalize the counter will be decremented
  // for each qualifying subquery that is not correlated. The during the SQO phase
  // we undertake a tree walk only if there is at least one correlated subquery.
  Lng32 correlatedSubqCount_ ;

  // counter to record if we are currently transforming expressions in a select 
  // list (i.e. compExpr). This is used for subquery unesting. A subquery in a 
  // select list does not reject null values since there is no predicate outside
  // the subquery and the result if the subquery is produced as is. If the 
  // subquery produces a null value that must be reatined. Therefor 
  // subqureries in a select list are equivalent to other predicates that 
  // do not reject null values (like IS NOT NULL, count(*) = 0, ...)

  Lng32 inSelectListCount_ ;

  NABoolean inHavingClause_ ;

  NABoolean inValueIdProxy_ ;

  NABoolean inGenericUpdateAssign_ ;

  NABoolean inMergeUpdWhere_ ;

  NABoolean inMVQueryRewrite_ ;

  NABoolean containsJoinsToBeEliminated_ ;

  NABoolean checkForExtraHubTables_;

  NABoolean containsGroupBysToBeEliminated_;

  NABoolean containsSemiJoinsToBeTransformed_ ;

  RelExpr * extraHubVertex_;

  Int32 commonSubExprCount_;

  // Pointer to Semantic Query Optimization WA. Used for error recovery
  SqoWA * sqoWARef_;

  // this variable are used to check whether the same table is both
  // updated and read
  LIST(NAString)  readList_;
  LIST(NAString)  writeList_;
  // QSTUFF

  // --------------------------------------------------------------------
  // A VEGTable instance is allocted in the NormWA
  // Once could either call it a vegTable_ because it is a table of
  // VEG's or a salad_ because it is a collection of VEG's. The name
  // salad_ is more appropriate because the vegTable_ is not a table
  // but a list. 
  // --------------------------------------------------------------------
  VEGTable * vegTable_;          
  
  // place to hold the current CmpContext
  CmpContext* currentCmpContext_;
  
  ValueIdSet allSeqFunctions_;

  LIST(ItemExpr *) origSeqFunction_;
  LIST(ValueId) equiTransformedExpr_;

  VEGRegion *leftJoinChildVEGRegion_; 

  NABoolean compilingMVDescriptor_;

  NABoolean requiresRecursivePushdown_;

}; // class NormWA


#endif /* NormWA_H */