/**********************************************************************
// @@@ 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 OPT_HDR
#define OPT_HDR
/* -*-C++-*-
******************************************************************************
*
* File:         opt.h
* Description:  from Cascades Optimizer search engine:
*               This file defines classes for all classes used in the
*               optimizer search engine, beyond those defined in the
*               interface classes.
* Created:      7/22/94
* Language:     C++
*
*
*
*
******************************************************************************
*/

// -----------------------------------------------------------------------
#include "RelExpr.h"
#include "CmpCommon.h"
#include "CmpContext.h"
//<pb>
// -----------------------------------------------------------------------
// Classes defined in this file
// ============================
// The search memory is organized as a single structure called "memo"
// of class "CascadesMemo," which consists of an array of equivalence
// classes, implemented by "CascadesGroups",  plus a hash table for
// finding duplicate (logical) expressions.
//
// An equivalence class' primary content is a set of equivalent logical
// and physical expressions organized as a linked list. (Since an operator
// can be both logical and physical, a separation into multiple lists
// would be quite cumbersome.) In addition, an equivalence class contains
// a list of patterns that have been explored previously for that
// equivalence class.
//
// The search yet to be done is organized as tasks; there are six
// types of tasks that schedule each other.  Tasks yet to be done are
// organized in a LIFO stack, although alternative organizations and
// executions, including randomized and parallel executions, could be
// implemented.  A context class captures constraints for a task, in
// particular cost limits and required and excluded logical and
// physical properties.
//
// When applying a rule, multiple expressions might match the pattern
// given by the rule.  If so, they are bound one at a time; a specific
// binding in captured in a tree of "CascadesBinding" objects.
// -----------------------------------------------------------------------

class CascadesGroup;	     // an equivalence class of log/phys. expressions
class CascadesMemo;          // collection of equivalence classs, search space memory

class Context;               // optimization goal
class ContextList;           // a list of context pointers

class CascadesPlan;          // a plan
class CascadesPlanList;

class PlanWorkSpace;         // a class that is used for recording plan related info.

class CascadesTask;	     // task

class OptimizeGroupTask;     // specific tasks
class OptimizeExprTask;
class ExploreGroupTask;
class ExploreExprTask;
class ApplyRuleTask;
class CreatePlanTask;
class GarbageCollectionTask;

class CascadesTaskList;	     // LIFO stack of tasks to be done

class CascadesBinding;	     // for pattern matching
class OptDefaults;

class IndexDesc;
class RequirementGenerator;

class CmpStatement;

#include <fstream>

class SimpleCostVector;
class OptDebug;              // for debugging purposes

class PerformanceGoal;
class CostWeight;

// forward declaration
class QueryComplexityVector;
namespace tmudr {
  class UDRPlanInfo;
}

#ifdef _DEBUG
  #define DBGLOGMSG(str) \
  { if (CmpCommon::getDefault(NSK_DBG_SHOW_PLAN_LOG) == DF_ON ) \
     (*CURRCONTEXT_OPTDEBUG).stream() << str << endl; }
  #define DBGLOGMSGCNTXT(str,cntxt) \
  { if (CmpCommon::getDefault(NSK_DBG_SHOW_PLAN_LOG) == DF_ON ) \
     (*CURRCONTEXT_OPTDEBUG).stream() << str << (cntxt)->getRequirementsString().data() \
                     << "group " << (cntxt)->getGroupId() << endl; }
  #define DBGLOGPLAN(plan) \
  { if (CmpCommon::getDefault(NSK_DBG_SHOW_PLAN_LOG) == DF_ON ) \
      (*CURRCONTEXT_OPTDEBUG).showNode((plan)->getPhysicalExpr()->castToRelExpr(), \
                      (plan)," *** ", FALSE ); }
  #define DBGMJENUMRULE(message) \
  { if (CmpCommon::getDefault(NSK_DBG_SHOW_MJ_ENUM_RULE_LOG) == DF_ON ) \
      (*CURRCONTEXT_OPTDEBUG).showNode((plan)->getPhysicalExpr()->castToRelExpr(), \
                      (plan)," *** ", FALSE ); }
#else
  #define DBGLOGMSG(str)
  #define DBGLOGMSGCNTXT(str,cntxt)
  #define DBGLOGPLAN(plan)
#endif

// This is a double epsilon being defined to make sure the selectivity
// always has some minimum. We did not want to do it in DefaultValidator.h,
// as that would have been too general.
#define MIN_SELECTIVITY       (1e-16)

// ----------------------------------------------------------------------
// Will put this class in other place later
// A very fast random number sequence generator
// ----------------------------------------------------------------------
class RandomSequence
{
  private:
    Lng32 m_;
    Lng32 a_;
    Lng32 c_;
    Lng32 x_;

  public:

    RandomSequence()
    { initialize();}

    double random()
    {
      x_ = (x_*a_ + c_)%m_;
      return double(x_)/double(m_);
    }

    void initialize(Lng32 i=616)
    {
      m_=259200;       // magic numbers
      a_=7141;         // magic numbers
      c_=54773;        // magic numbers
      x_= i % m_;
    }
};

// ---------------------------------------------------------------
// This class is for caching any parameters initialized in a
// per-sql statement basis. This class gets initialized
// every time a sql statement is compiled (in
// RelExpr * RelExpr::optimize(Guidance * guidance,
//			    ReqdPhysicalProperty * rpp,
//			    CostLimit* costLimit)
// located in opt.cpp).
//
// It contains the information about the optimization
// level and heuristics cached from the Defaults table.
// It also contains the methods for optimization level 1 and tasks limit.
// Lastly, it contains cached recalibration defaults.
// ---------------------------------------------------------------

class OptDefaults
{
public:

  OptDefaults (CollHeap* heap);
  ~OptDefaults ();

  enum optLevelEnum
    {
      MINIMUM,
      LOW,
      MEDIUM_LOW,
      MEDIUM,
      MEDIUM_MAX,
      MAXIMUM,
      AGGRESSIVE
    };

  optLevelEnum optLevel() { return optLevel_;}

  optLevelEnum indexEliminationLevel()
  { return indexEliminationLevel_; }
  double mdamSelectionDefault()
  { return mdamSelectionDefault_; }
  double readAheadMaxBlocks()
  { return readAheadMaxBlocks_; }
  double acceptableInputEstLogPropError()
  { return acceptableInputEstLogPropError_; }

  inline void setTaskCount(Lng32 id){taskCount_ = id;};

  inline Lng32 getTaskCount(){ return taskCount_;};

  inline Lng32 level1SafetyNet() { return level1SafetyNet_; }

  inline double level1SafetyNetMultiple()
  {
    return level1SafetyNetMultiple_;
  };
  inline NABoolean taskLimitExceeded(Lng32 id)
  {
    return (id > optTaskLimit_);
  };

  inline void setEnumPotentialThreshold(Lng32 threshold)
  {
    enumPotentialThreshold_ = threshold;
  }

  inline Lng32 getEnumPotentialThreshold()
  {
    return enumPotentialThreshold_;
  }

  inline NABoolean needShortPassOptimization()
  {
    return ((queryComplexity_ >= shortOptPassThreshold_) OR
            (numTables_ >= 5));
  };
  inline ULng32 getNumOfBlocksPerAccess()
  {
    return numOfBlocksPerAccess_;
  };
  inline Int32 getNumTables()
  {
    return numTables_;
  };
  inline NABoolean isFakeHardware()
  {
    return fakeHardware_;
  };
  inline NABoolean isAdditiveResourceCosting()
  {
    return additiveResourceCosting_;
  };
  inline double getQueryComplexity()
  {
    return queryComplexity_;
  };
  void setQueryMJComplexity(double complexity);
  inline double getQueryMJComplexity()
  {
    return queryMJComplexity_;
  };
  inline NABoolean isComplexMJQuery()
  {
    return isComplexMJQuery_;
  }
  inline double getRequiredMemoryResourceEstimate()
  {
    return requiredMemoryResourceEstimate_;
  };
  inline double getRequiredCpuResourceEstimate()
  {
    return requiredCpuResourceEstimate_;
  };
  inline double getTotalDataAccessCost()
  {
    return totalDataAccessCost_;
  };  
  inline double getMaxOperatorMemoryEstimate()
  {
    return maxOperatorMemoryEstimate_;
  };
  inline double getMaxOperatorCpuEstimate()
  {
    return maxOperatorCpuEstimate_;
  };
  inline double getMaxOperatorDataAccessCost()
  {
    return maxOperatorDataAccessCost_;
  };
  inline double getMemoryPerCPU()
  {
    return memoryPerCPU_;
  };
  inline double getWorkPerCPU()
  {
    return workPerCPU_;
  };
  inline Lng32 getAdjustedDegreeOfParallelism()
  {
    return adjustedDegreeOfParallelism_;
  };
  inline Lng32 getDefaultDegreeOfParallelism()
  {
    return defaultDegreeOfParallelism_;
  };
  inline Lng32 getMaximumDegreeOfParallelism()
  {
    return maximumDegreeOfParallelism_;
  };
  inline Lng32 getMinimumESPParallelism()
  {
    return minimumESPParallelism_;
  };
  inline Lng32 getTotalNumberOfCPUs()
  {
    return totalNumberOfCPUs_;
  };
  inline NABoolean isJoinToTSJRuleNeededOnPass1()
  {
    if (CmpCommon::getDefault(COMP_BOOL_71) != DF_ON)
      return TRUE;
    return enableJoinToTSJRuleOnPass1_;
  };
  inline NABoolean areTriggersPresent()
  {
    return triggersPresent_;
  };
  inline NABoolean isCrossProductControlEnabled()
  {
    return enableCrossProductControl_;
  };
  inline NABoolean isNestedJoinControlEnabled()
  {
    return enableNestedJoinControl_;
  };
  inline NABoolean isZigZagControlEnabled()
  {
    return enableZigZagControl_;
  };
  inline NABoolean isMergeJoinControlEnabled()
  {
    return enableMergeJoinControl_;
  };
  inline NABoolean isOrderedHashJoinControlEnabled()
  {
    return enableOrderedHashJoinControl_;
  };
  inline NABoolean isNestedJoinConsidered()
  {
    return considerNestedJoin_;
  };
  inline NABoolean isHashJoinConsidered()
  {
    return considerHashJoin_;
  };
  inline NABoolean isHybridHashJoinConsidered()
  {
    return considerHybridHashJoin_;
  };
  inline NABoolean isOrderedHashJoinConsidered()
  {
    return considerOrderedHashJoin_;
  };
  inline NABoolean isMergeJoinConsidered()
  {
    return considerMergeJoin_;
  };
  inline DefaultToken isZigZagTreeConsidered()
  {
    return considerZigZagTree_;
  };
  inline NABoolean isMinMaxConsidered()
  {
	return considerMinMaxOpt_;
  };
  inline NABoolean nestedJoinForCrossProducts()
  {
    return nestedJoinForCrossProducts_;
  };

  inline NABoolean preferredProbingOrderForNJ()
  {
    return preferredProbingOrderForNJ_;
  };

  inline NABoolean orderedWritesForNJ()
  {
    return orderedWritesForNJ_;
  };

  inline NABoolean joinOrderByUser()
  {
    return joinOrderByUser_;
  };

  inline NABoolean ignoreExchangesInCQS()
  {
    return ignoreExchangesInCQS_;
  };

  inline NABoolean ignoreSortsInCQS()
  {
    return ignoreSortsInCQS_;
  };

  inline NABoolean dataFlowOptimization()
  {
    return dataFlowOptimization_;
  };

  inline NABoolean optimizerHeuristic1()
  {
    return optimizerHeuristic1_;
  };
  inline NABoolean optimizerHeuristic2()
  {
    return optimizerHeuristic2_;
  };
  inline NABoolean optimizerHeuristic3()
  {
    return optimizerHeuristic3_;
  };
  inline NABoolean optimizerHeuristic4()
  {
    return optimizerHeuristic4_;
  };
  inline NABoolean optimizerHeuristic5()
  {
    return optimizerHeuristic5_;
  };
  inline Lng32 getMJEnumLimit()
  {
    return level1MJEnumLimit_;
  };
  inline void setInitialMemory()
  {
    optInitialMemory_ = 0;

    if (CmpCommon::getDefault(COMP_BOOL_160) == DF_OFF)
    {
      optInitialMemory_ = (CmpCommon::statementHeap())->getAllocSize();
    }
  }
  inline Lng32 getMemUsed()
  {
    UInt32 currentMem = (CmpCommon::statementHeap())->getAllocSize();
    UInt32 memUsed = currentMem - MINOF(currentMem, (UInt32)optInitialMemory_);
    memUsed /= (1024*1024);
    return memUsed;
  }
  inline void setOriginalOptimizationBudget(double budget)
  {
    originalOptimizationBudget_ = budget;
  }
  inline double getOriginalOptimizationBudget()
  {
    return originalOptimizationBudget_;
  }
  inline void setOptimizationBudget(double budget)
  {
    optimizationBudget_ = budget;
  }
  inline double getOptimizationBudget()
  {
    return optimizationBudget_;
  }
  inline Lng32 maxDepthToCheckForCyclicPlan()
  {
    return maxDepthToCheckForCyclicPlan_;
  }
  inline Lng32 memUsageTaskThreshold()
  {
    return memUsageTaskThreshold_;
  }
  inline Lng32 memUsageTaskInterval()
  {
    return memUsageTaskInterval_;
  }
  inline Lng32 getMemUsageSafetyNet()
  {
    return memUsageSafetyNet_;
  }
  inline double getMemUsageOptPassFactor()
  {
    return memUsageOptPassFactor_;
  }
  inline double getMemUsageNiceContextFactor()
  {
    return memUsageNiceContextFactor_;
  }
  inline DefaultToken attemptESPParallelism()
  {
    return attemptESPParallelism_;
  };

  inline NABoolean maxParallelismIsFeasible()
  {
    return maxParallelismIsFeasible_;
  };

  inline NABoolean isOrOptimizationEnabled()
  {
    return enableOrOptimization_;
  };

  inline float numberOfPartitionsDeviation()
  {
    return numberOfPartitionsDeviation_;
  };
  inline double updatedBytesPerESP()
  {
    return updatedBytesPerESP_;
  };
  inline float numberOfRowsParallelThreshold()
  {
    return numberOfRowsParallelThreshold_;
  };
  inline NABoolean deviationType2JoinsSystem()
  {
    return deviationType2JoinsSystem_;
  };
  inline float numOfPartsDeviationType2Joins()
  {
    return numOfPartsDeviationType2Joins_;
  };
  inline NABoolean parallelHeuristic1()
  {
    return parallelHeuristic1_;
  };
  inline NABoolean parallelHeuristic2()
  {
    return parallelHeuristic2_;
  };
  inline NABoolean parallelHeuristic3()
  {
    return parallelHeuristic3_;
  };
  inline NABoolean parallelHeuristic4()
  {
    return parallelHeuristic4_;
  };
  inline NABoolean optimizerPruning()
  {
    return optimizerPruning_;
  };
  inline NABoolean OPHpruneWhenCLExceeded()
  {
    return OPHpruneWhenCLExceeded_;
  };
  inline NABoolean OPHreduceCLfromCandidates()
  {
    return OPHreduceCLfromCandidates_;
  };
  inline NABoolean OPHreduceCLfromPass1Solution()
  {
    return OPHreduceCLfromPass1Solution_;
  };
  inline NABoolean OPHreuseFailedPlan()
  {
    return OPHreuseFailedPlan_;
  };
  inline NABoolean OPHreuseOperatorCost()
  {
    return OPHreuseOperatorCost_;
  };
  inline NABoolean OPHskipOGTforSharedGCfailedCL()
  {
    return OPHskipOGTforSharedGCfailedCL_;
  };
  inline NABoolean OPHuseCandidatePlans()
  {
    return OPHuseCandidatePlans_;
  };
  inline NABoolean OPHuseCompCostThreshold()
  {
    return OPHuseCompCostThreshold_;
  };
  inline NABoolean OPHuseConservativeCL()
  {
    return OPHuseConservativeCL_;
  };
  inline NABoolean OPHuseEnforcerPlanPromotion()
  {
    return OPHuseEnforcerPlanPromotion_;
  };
  inline NABoolean OPHuseFailedPlanCost()
  {
    return OPHuseFailedPlanCost_;
  };
  inline NABoolean OPHuseNiceContext()
  {
    return OPHuseNiceContext_;
  };
  inline NABoolean OPHusePWSflagForContext()
  {
    return OPHusePWSflagForContext_;
  };
  inline NABoolean OPHuseCachedElapsedTime()
  {
    return OPHuseCachedElapsedTime_;
  };
  inline NABoolean OPHexitNJcrContChiLoop()
  {
    return OPHexitNJcrContChiLoop_;
  };
  inline NABoolean OPHexitMJcrContChiLoop()
  {
    return OPHexitMJcrContChiLoop_;
  };
  inline NABoolean OPHexitHJcrContChiLoop()
  {
    return OPHexitHJcrContChiLoop_;
  };
  inline NABoolean compileTimeMonitor()
  {
    return compileTimeMonitor_;
  };
  inline NABoolean reuseBasicCost()
  {
    return reuseBasicCost_;
  };
  inline void setReuseBasicCost(NABoolean v)
  {
    reuseBasicCost_ = v;
  };
  inline NABoolean randomPruningOccured()
  {
    return randomPruningOccured_;
  };
  inline NABoolean pushDownDP2Requested()
  {
    return pushDownDP2Requested_;
  };
  inline NABoolean reduceBaseHistograms()
  {
  	return reduceBaseHistograms_;
  };
  inline NABoolean reduceIntermediateHistograms()
  {
   	return reduceIntermediateHistograms_;
  };
  inline NABoolean preFetchHistograms()
  {
   	return preFetchHistograms_;
  };
  inline Int64 siKeyGCinterval()
  {
    return siKeyGCinterval_;
  };

  static NABoolean cacheHistograms();

  inline double joinCardLowBound()
  {
    return joinCardLowBound_;
  };
  inline NABoolean ustatAutomation()
  {
    return ustatAutomation_;
  };
  inline NABoolean histMCStatsNeeded()
  {
  	return histMCStatsNeeded_;
  };
  inline double histDefaultSampleSize()
  {
    return histDefaultSampleSize_;
  }
  inline void setHistDefaultSampleSize(double val)
  {
    histDefaultSampleSize_ = val;
  }
  inline NABoolean histSkipMCUecForNonKeyCols()
  {
  	return histSkipMCUecForNonKeyCols_;
  };
  inline Lng32 histMissingStatsWarningLevel()
  {
      return histMissingStatsWarningLevel_;
  }
  inline NABoolean histOptimisticCardOpt()
  {
    return histOptimisticCardOpt_;
  }
  inline ULng32 histTupleFreqValListThreshold()
  {
    return histTupleFreqValListThreshold_;
  }
  inline ULng32 histNumOfAddDaysToExtrapolate()
  {
    return histNumOfAddDaysToExtrapolate_;
  }
  inline NABoolean incorporateSkewInCosting()
  {
      return incorporateSkewInCosting_;
  }
  inline ULng32 maxSkewValuesDetected()
  {
	return maxSkewValuesDetected_;
  }
  inline double skewSensitivityThreshold()
  {
	return skewSensitivityThreshold_;
  }
  inline NABoolean histAssumeIndependentReduction()
  {
      return histAssumeIndependentReduction_;
  }
  inline NABoolean histUseSampleForCardEst()
  {
    return histUseSampleForCardEst_;
  }

  void setHistUseSampleForCardEst(NABoolean v)
  {
    histUseSampleForCardEst_ = v;
  }

  inline Lng32 partitioningSchemeSharing()
  {
    return partitioningSchemeSharing_;
  };
  inline double riskPremiumNJ()
  {
    return riskPremiumNJ_;
  };
  inline double riskPremiumMJ()
  {
    return riskPremiumMJ_;
  };
  double riskPremiumSerial() ;

  inline double maxMaxCardinality() { return maxMaxCardinality_; }

  inline double robustHjToNjFudgeFactor()
  {
    return robustHjToNjFudgeFactor_;
  };
  inline Lng32 robustSortGroupBy()
  {
    return robustSortGroupBy_;
  };
  inline DefaultToken robustQueryOptimization()
  {
    return robustQueryOptimization_;
  };

  inline double defSelForRangePred()
  {
    if (defSelForRangePred_ < MIN_SELECTIVITY)
      return MIN_SELECTIVITY ;
    else
      return defSelForRangePred_;
  };

  inline double defSelForWildCard()
  {
    if (defSelForWildCard_ < MIN_SELECTIVITY)
      return MIN_SELECTIVITY ;
    else
      return defSelForWildCard_;
  };

    inline double defSelForNoWildCard()
  {
    if (defSelForNoWildCard_ < MIN_SELECTIVITY)
      return MIN_SELECTIVITY ;
    else
      return defSelForNoWildCard_;
  };

  inline double defNoStatsUec()
  {
    return defNoStatsUec_;
  };

  inline void setNoStatsUec(double uec)
  {
    defNoStatsUec_ = uec;
  };

  inline double defNoStatsRowCount()
  {
    return defNoStatsRowCount_;
  };

  inline double baseHistogramReductionFF()
  {
    return baseHistogramReductionFF_;
  };
  inline double intermediateHistogramReductionFF()
  {
    return intermediateHistogramReductionFF_;
  };
  inline double histogramReductionConstantAlpha()
  {
    return histogramReductionConstantAlpha_;
  };

  NABoolean pruneByOptDefaults(Rule* rule, RelExpr* relExpr);
  NABoolean pruneByOptLevel(Rule* rule, RelExpr* relExpr);
  NABoolean pruneByRProbability(Rule* rule, RelExpr* relExpr);
  NABoolean pruneByPotential(Rule* rule, RelExpr* relExpr);
  Int32 optimizerGracefulTermination()
  {
    return optimizerGracefulTermination_;
  };

  RequiredResources * estimateRequiredResources(RelExpr* rootExpr);
  // initialize portion of the cache based on ActiveSchemaDB's optDefaults 
  // and the pass-in argument rootExpr
  void initialize(RelExpr* rootExpr);

  Int32 getRulePriority(Rule* rule);


  double getReductionToPushGBPastTSJ()
  {
    return reduction_to_push_gb_past_tsj_;
  };
  // -----------------------------------------------------------------------
  // Cost-related methods:
  // -----------------------------------------------------------------------

  // This method is needed by the GUI to initialize its
  // own copy of OptDefaults:
  // initialize all cost related members here!!
  void initializeCostInfo();

  double getTimePerCPUInstructions()
  { return calibratedMSCF_ET_CPU_;}

  double getTimePerSeqKb()
  { return calibratedMSCF_ET_IO_TRANSFER_;}

  double getTimePerSeek()
  { return calibratedMSCF_ET_NUM_IO_SEEKS_;}

  double getTimePerKbOfLocalMsg()
  { return calibratedMSCF_ET_LOCAL_MSG_TRANSFER_;}

  double getTimePerLocalMsg()
  { return calibratedMSCF_ET_NUM_LOCAL_MSGS_;}

  double getTimePerKbOfRemoteMsg()
  { return calibratedMSCF_ET_REMOTE_MSG_TRANSFER_;}

  double getTimePerRemoteMsg()
  { return calibratedMSCF_ET_NUM_REMOTE_MSGS_;}

  double getMemoryLimitPerCPU()
  { return calculatedMEMORY_LIMIT_PER_CPU_; }

  NABoolean useHighFreqInfo()
  { return useHighFreqInfo_; }

  inline void setMemoryLimitPerCPU(double memLimit)
  {calculatedMEMORY_LIMIT_PER_CPU_ = memLimit;}

  NABoolean useNewMdam();

  CascadesTask *getCurrentTask() { return currentTask_; }
  ULng32 getMemoExprCount() { return memoExprCount_; }

  void resetMemoExprCount() { memoExprCount_ = 0; }
  void resetCurrentTask() { currentTask_ = NULL; }

  // --------------------------------------
  // Mutators:
  // --------------------------------------
  void recalibrateCPU();
  void recalibrateIOSeqTransfer();
  void recalibrateIOSeeks();
  void recalibrateLocalMsg();
  void recalibrateLocalMsgTransfer();
  void recalibrateRemoteMsg();
  void recalibrateRemoteMsgTransfer();
  double recalibrate(Int32 calEnum
                            ,Int32 baseEnum, Int32 endEnum);


  NABoolean newMemoryLimit(RelExpr * rootExpr,
                                  NABoolean recompute );

  NABoolean isRuleDisabled(ULng32 ruleBitPosition);

  void setCurrentTask( CascadesTask *t ) { currentTask_ = t; }
  ULng32 updateGetMemoExprCount() { return ++memoExprCount_; }

  // Query Strategizer Params
  // used for explain
  // BEGIN
  NABoolean useStrategizer() {return useStrategizer_; }
  double getCpuCost() { return cpuCost_; };
  double getScanCost() { return scanCost_; };
  double getTotalCost() { return (cpuCost_ + scanCost_); };
  double getBudgetFactor() { return budgetFactor_; };
  double getPass1Tasks() { return pass1Tasks_; };
  double getTaskFactor() { return taskFactor_; };
  double getNComplexity() {return nComplexity_; };
  double get2NComplexity() { return n_2Complexity_; };
  double getN2Complexity() { return n2Complexity_; };
  double getN3Complexity() { return n3Complexity_; };
  double getExhaustiveComplexity() { return exhaustiveComplexity_; };
  
  void setCpuCost(double cpuCost) { cpuCost_ = cpuCost; };
  void setScanCost(double scanCost) { scanCost_ = scanCost; };
  void setBudgetFactor(double budgetFactor) { budgetFactor_ = budgetFactor; };
  void setPass1Tasks(double pass1Tasks) { pass1Tasks_ = pass1Tasks; };
  void setTaskFactor(double taskFactor) { taskFactor_ = taskFactor; };
  void setNComplexity(double nComplexity) { nComplexity_ = nComplexity; };
  void set2NComplexity(double n_2Complexity) { n_2Complexity_ = n_2Complexity; };
  void setN2Complexity(double n2Complexity) { n2Complexity_ = n2Complexity; };
  void setN3Complexity(double n3Complexity) { n3Complexity_ = n3Complexity; };
  void setExhaustiveComplexity(double exhaustiveComplexity) { exhaustiveComplexity_ = exhaustiveComplexity; };
  // END

  Lng32 getRequiredESPs() { return requiredESPs_; }
  void setRequiredESPs(Lng32 x) { requiredESPs_ = x; }

  const IndexDesc* getRequiredScanDescForFastDelete() 
              { return requiredScanDescForFastDelete_; }
  void setRequiredScanDescForFastDelete(const IndexDesc* x) 
              { requiredScanDescForFastDelete_ = x; }

  NABoolean isSideTreeInsert() { return isSideTreeInsert_; }
  void setSideTreeInsert(NABoolean x) { isSideTreeInsert_ = x; }

  double computeRecommendedNumCPUs(double cpuResourceRequired);
  double computeRecommendedNumCPUsForMemory(double memoryResourceRequired);

  // -----------------------------------------------------------------------
  // default weighing factors for cost: make the total value a multiple
  // of random disk I/Os (normalize all values to 20 ms and add them up).
  // Space consumption (memory and temp disk files) doesn't count.
  // -----------------------------------------------------------------------
  CostWeight* getDefaultCostWeight() const { return defaultCostWeight_; }
  PerformanceGoal* getDefaultPerformanceGoal() const { return defaultPerformanceGoal_; }
  PerformanceGoal* getResourcePerformanceGoal() const { return resourcePerformanceGoal_; }


protected:
   NABoolean InitCostVariables();
   void CleanupCostVariables();

private:
  optLevelEnum optLevel_;
  optLevelEnum indexEliminationLevel_;
  double mdamSelectionDefault_;
  double readAheadMaxBlocks_;
  double acceptableInputEstLogPropError_;

  Lng32 taskCount_;
  Lng32 optTaskLimit_;
  Lng32 enumPotentialThreshold_;

  // following is a bit map that controls
  // which rules should fire and which rules should
  // not fire, the meaning of each bit is as below
  // 1 - join commutativity
  // 2 - join left shift
  // 3 - push gb below join
  // 4 - push partial gb below tsj
  // 5 - split gb
  // 6 - hash gb
  // 7 - sort gb
  // The numbers above have to be passed in as parameter
  // to isRuleDisabled()
  ULng32 optRulesGuidance_;
  Lng32 level1Constant1_;
  Lng32 level1Constant2_;
  Lng32 level1ImmunityLimit_;
  Lng32 level1MJEnumLimit_;
  ULng32 numOfBlocksPerAccess_;
  Int32  numTables_;
  double queryComplexity_;
  double queryMJComplexity_;
  NABoolean isComplexMJQuery_;
  double requiredMemoryResourceEstimate_;
  double requiredCpuResourceEstimate_;
  double totalDataAccessCost_;
  double maxOperatorMemoryEstimate_;
  double maxOperatorCpuEstimate_;
  double maxOperatorDataAccessCost_;
  double memoryPerCPU_;
  double workPerCPU_;
  Lng32 adjustedDegreeOfParallelism_;
  Lng32 defaultDegreeOfParallelism_;
  Lng32 maximumDegreeOfParallelism_;
  Lng32 minimumESPParallelism_;
  Lng32 totalNumberOfCPUs_;
  NABoolean enableJoinToTSJRuleOnPass1_;
  NABoolean triggersPresent_;
  double reduction_to_push_gb_past_tsj_;
  NABoolean enableCrossProductControl_;
  NABoolean enableNestedJoinControl_;
  NABoolean enableZigZagControl_;
  NABoolean enableMergeJoinControl_;
  NABoolean enableOrderedHashJoinControl_;
  NABoolean considerNestedJoin_;
  NABoolean considerHashJoin_;
  NABoolean considerOrderedHashJoin_;
  NABoolean considerHybridHashJoin_;
  NABoolean considerMergeJoin_;
  DefaultToken considerZigZagTree_;
  NABoolean considerMinMaxOpt_;
  NABoolean preferredProbingOrderForNJ_;
  NABoolean orderedWritesForNJ_;
  NABoolean nestedJoinForCrossProducts_;
  NABoolean joinOrderByUser_;
  NABoolean ignoreExchangesInCQS_;
  NABoolean ignoreSortsInCQS_;
  NABoolean dataFlowOptimization_;
  NABoolean optimizerGracefulTermination_;
  NABoolean optimizerHeuristic1_;
  NABoolean optimizerHeuristic2_;
  NABoolean optimizerHeuristic3_;
  NABoolean optimizerHeuristic4_;
  NABoolean optimizerHeuristic5_;
  DefaultToken attemptESPParallelism_;
  NABoolean maxParallelismIsFeasible_;
  NABoolean enableOrOptimization_;
  float numberOfPartitionsDeviation_;
  double updatedBytesPerESP_;
  float numberOfRowsParallelThreshold_;
  float numOfPartsDeviationType2Joins_;
  NABoolean deviationType2JoinsSystem_;
  NABoolean parallelHeuristic1_;
  NABoolean parallelHeuristic2_;
  NABoolean parallelHeuristic3_;
  NABoolean parallelHeuristic4_;
  NABoolean compileTimeMonitor_;
  NABoolean reuseBasicCost_;
  NABoolean randomPruningOccured_;

  NABoolean optimizerPruning_;
  NABoolean OPHpruneWhenCLExceeded_;
  NABoolean OPHreduceCLfromCandidates_;
  NABoolean OPHreduceCLfromPass1Solution_;
  NABoolean OPHreuseFailedPlan_;
  NABoolean OPHreuseOperatorCost_;
  NABoolean OPHskipOGTforSharedGCfailedCL_;
  NABoolean OPHuseCandidatePlans_;
  NABoolean OPHuseCompCostThreshold_;
  NABoolean OPHuseConservativeCL_;
  NABoolean OPHuseEnforcerPlanPromotion_;
  NABoolean OPHuseFailedPlanCost_;
  NABoolean OPHuseNiceContext_;
  NABoolean OPHusePWSflagForContext_;
  NABoolean OPHuseCachedElapsedTime_;
  NABoolean OPHexitNJcrContChiLoop_;
  NABoolean OPHexitMJcrContChiLoop_;
  NABoolean OPHexitHJcrContChiLoop_;

  RandomSequence *ranSeq_;
  NABoolean pushDownDP2Requested_;
  Lng32 shortOptPassThreshold_;
  Lng32 level1Threshold_;
  Lng32 level1SafetyNet_;
  double level1SafetyNetMultiple_;
  Lng32 optInitialMemory_;
  double originalOptimizationBudget_;
  double optimizationBudget_;
  Lng32 maxDepthToCheckForCyclicPlan_;
  Lng32 memUsageTaskThreshold_;
  Lng32 memUsageTaskInterval_;
  Lng32 memUsageSafetyNet_;
  double memUsageOptPassFactor_;
  double memUsageNiceContextFactor_;
  NABoolean fakeHardware_;
  NABoolean additiveResourceCosting_;
  // ------------------------------------------------------------------------
  // opt defaults for histogram intervals reduction, histogram caching and
  // histogram preFetching
  // ------------------------------------------------------------------------
  NABoolean reduceBaseHistograms_;
  NABoolean reduceIntermediateHistograms_;
  NABoolean preFetchHistograms_;
  Int64 siKeyGCinterval_;  // query/security invalidation key garbage collection interval, in seconds

  NABoolean ustatAutomation_;
  double histDefaultSampleSize_;
  double baseHistogramReductionFF_;
  double intermediateHistogramReductionFF_;
  double histogramReductionConstantAlpha_;
  NABoolean histMCStatsNeeded_;
  NABoolean histSkipMCUecForNonKeyCols_;
  Lng32 histMissingStatsWarningLevel_;
  Lng32 histOptimisticCardOpt_;
  NABoolean incorporateSkewInCosting_;
  NABoolean histAssumeIndependentReduction_;
  NABoolean histUseSampleForCardEst_;
  ULng32 maxSkewValuesDetected_;
  double skewSensitivityThreshold_;
  NABoolean useHighFreqInfo_;
  ULng32 histTupleFreqValListThreshold_;
  ULng32 histNumOfAddDaysToExtrapolate_;

  double joinCardLowBound_;
  double defNoStatsUec_;
  double defNoStatsRowCount_;
  double defSelForWildCard_;
  double defSelForNoWildCard_;
  double defSelForRangePred_;

  Lng32 partitioningSchemeSharing_;
  double riskPremiumNJ_;
  double riskPremiumMJ_;
  double riskPremiumSerial_;
  double robustHjToNjFudgeFactor_;
  Lng32 robustSortGroupBy_;
  DefaultToken robustQueryOptimization_;

  double maxMaxCardinality_;

  // -----------------------------------------------------------------------
  // The following are the resource-to-time multipliers that were
  // recalibrated for the current SQL statement
  // -----------------------------------------------------------------------
  NADefaults *defs_;

  double calibratedMSCF_ET_CPU_;

  double calibratedMSCF_ET_IO_TRANSFER_;

  double calibratedMSCF_ET_NUM_IO_SEEKS_;

  double calibratedMSCF_ET_LOCAL_MSG_TRANSFER_;

  double calibratedMSCF_ET_NUM_LOCAL_MSGS_;

  double calibratedMSCF_ET_REMOTE_MSG_TRANSFER_;

  double calibratedMSCF_ET_NUM_REMOTE_MSGS_;

  // ------------------------------------------------------------------------
  // The memory_limit is calculated for each query based on the table sizes
  //  after local predicates have been applied, unless the user entered
  //  a specific memory limit defualt.
  // ------------------------------------------------------------------------
  double calculatedMEMORY_LIMIT_PER_CPU_;
  NABoolean useNewMdam_;

  CascadesTask *currentTask_;
  ULng32 memoExprCount_;
  
  // Query Strategizer Params
  // used for explain
  // BEGIN
  NABoolean useStrategizer_;
  double cpuCost_;
  double scanCost_;
  double budgetFactor_;
  double pass1Tasks_;
  double taskFactor_;
  double nComplexity_;
  double n_2Complexity_;
  double n2Complexity_;
  double n3Complexity_;
  double exhaustiveComplexity_; 
  // END

  // requred ESPs and scan indexDesc involved - for fast delete used in parallel
  // purge data
  Lng32 requiredESPs_;
              
  const IndexDesc* requiredScanDescForFastDelete_;

  NABoolean isSideTreeInsert_;

  CostWeight* defaultCostWeight_;
  PerformanceGoal* defaultPerformanceGoal_;
  PerformanceGoal* resourcePerformanceGoal_;

  CollHeap* heap_;
}; // class OptDefaults

//<pb>
// -----------------------------------------------------------------------
// Optimization procedure
// ======================
// This is the only run-time interface from the DBMS to the optimizer,
// although there are many interfaces from the optimizer to
// DBI-supplied methods.  All operators in the input tree, called the
// "query," must be logical operators.  All operators in the final
// output, called the "plan", will be physical operators.  If the
// optimizer is not able to produce a plan, typically because there
// aren't sufficient physical operators or implementation rules, this
// procedure will return NULL.
// -----------------------------------------------------------------------

// -----------------------------------------------------------------------
// Plan
// ====
// A CascadesPlan identifies a physical expression that represents the
// query execution plan for a given Context, for a given optimization
// pass.
// It contains the synthesized Physical Property for the physical
// expression as well as its Cost. It also contains a RuleSubset
// that indicates the set of Rules that have been applied.
// -----------------------------------------------------------------------
class CascadesPlan : public ReferenceCounter
{
public:
  // ---------------------------------------------------------------------
  // Constructor and Destructor.
  // ---------------------------------------------------------------------
  CascadesPlan(RelExpr * physExpr, Context * context = NULL);

  virtual ~CascadesPlan();

  // ---------------------------------------------------------------------
  // Accessor functions.
  // ---------------------------------------------------------------------
  inline RelExpr * getPhysicalExpr() const           { return physExpr_; }

  inline PhysicalProperty * getPhysicalProperty() const
                                                     { return physProp_; }
  inline const Cost * getOperatorCost() const
  { return operatorCost_; }

  inline const Cost * getRollUpCost() const
  { return rollUpCost_; }

  inline CostScalar getPlanElapsedTime() { return planElapsedTime_; }
  inline void setPlanElapsedTime(ElapsedTime et) { planElapsedTime_ = et; }

  inline NABoolean exceededCostLimit() { return planExceededCostLimit_; }
  inline void setExceededCostLimit() { planExceededCostLimit_ = TRUE; }

  inline Context * getContext() const                 { return context_; }

  // Get the pass numberwhen the plan was created
  inline Lng32 getCreationPassNumber() const
  { return passNoWhenCreated_; }

  // returns TRUE if the plan succeeded in the current pass, else
  // it returns FALSE
  inline NABoolean succeededInCurrentPass() const
  { return (succeededInPassNo_ == GlobalRuleSet->getCurrentPassNumber()); }

  // returns TRUE if the plan failed in the current pass, else
  // it returns FALSE
  inline NABoolean failedInCurrentPass() const
  { return (failedInPassNo_ == GlobalRuleSet->getCurrentPassNumber()); }

  inline Context * getContextForChild(Lng32 childIndex) const
         { if ( childIndex >= Lng32 (childContexts_.entries()) )
             return NULL;
           else
             return childContexts_[childIndex]; }

  inline NABoolean isBigMemoryOperator() const          { return isBMO_; }

  // ---------------------------------------------------------------------
  // Mutator functions.
  // ---------------------------------------------------------------------
  inline void setPhysicalProperty(PhysicalProperty *ppv)
  { physProp_ = ppv; }

  void setOperatorCost(Cost *cost);
  void setRollUpCost(Cost *cost);

  inline void setContextForChild(Lng32 childIndex, Context *context)
  { childContexts_.insertAt(childIndex, context); }

  inline void setSuccessInCurrentPass()
  { succeededInPassNo_ = GlobalRuleSet->getCurrentPassNumber(); }

  inline void setFailedInCurrentPass()
  { failedInPassNo_ = GlobalRuleSet->getCurrentPassNumber(); }

  inline void setBigMemoryOperator(NABoolean isBMO)     { isBMO_ = isBMO; }

  // ---------------------------------------------------------------------
  // Methods for accessing solutions from the child contexts
  // ---------------------------------------------------------------------
  const CascadesPlan * getSolutionForChild (Lng32 childIndex) const;

  const PhysicalProperty * getPhysicalPropertyForChild (Lng32 childIndex) const;

  const Cost * getCostForChild(Lng32 childIndex) const;

  NABoolean exprOccursInChildTree(RelExpr *newExpr,
                                  Int32 maxDepth=1) const;

  // ---------------------------------------------------------------------
  // Utility methods
  // ---------------------------------------------------------------------
  // for tracking the time of plan creation
  TaskMonitor planMonitor_;
  Lng32 lastTaskId_;

  // GUI display method (defined in DisplayTree.C)
  void displayTree();
//<pb>
private:

  // ---------------------------------------------------------------------
  // The physical expression to be optimized.
  // ---------------------------------------------------------------------
  RelExpr * physExpr_;

  // ---------------------------------------------------------------------
  // The physical properties for this plan.
  // ---------------------------------------------------------------------
  PhysicalProperty * physProp_;

  // ---------------------------------------------------------------------
  // Does this plan belong to a big memory operator?
  // ---------------------------------------------------------------------
  NABoolean isBMO_;

  // ---------------------------------------------------------------------
  // Cost for this operator independent of its children.  Based initially
  // on an estimated degree of parallelism and possibly revised if actual
  // degree of parallelism differs from estimate.
  // ---------------------------------------------------------------------
  Cost * operatorCost_;

  // ---------------------------------------------------------------------
  // Cost for the sub-plan rooted at this operator (operator cost combined
  // with the operator's children cost)
  // ---------------------------------------------------------------------
  Cost * rollUpCost_;

  // This is cached value of plan elapsed time. It is used to speed up
  // comparison with costLimit when  OPH_CONSERVATIVE_COST_LIMIT is OFF
  // the value is set as a side effect of the first compareWithPlanCost
  // call with this plan as an argument.
  ElapsedTime planElapsedTime_;

  // Used by pruning heuristic to reuse failed plan cost. Flag is set to
  // TRUE when failed because its partial or rollUp cost exceeded cost
  // limit. Flag is passed to context to keep track about plans exceeding
  // cost limit in context local flag currentPlanExceededCostLimit_
  NABoolean planExceededCostLimit_;

  // ---------------------------------------------------------------------
  // The context for which this plan was created.
  // ---------------------------------------------------------------------
  Context * context_;

  // ---------------------------------------------------------------------
  // The optimization pass number for which this plan was created
  // ---------------------------------------------------------------------
  const Lng32 passNoWhenCreated_;

  // ---------------------------------------------------------------------
  // The optimization pass number for which this plan last succeeded:
  // ---------------------------------------------------------------------
  Lng32 succeededInPassNo_;

  // ---------------------------------------------------------------------
  // The optimization pass number for which this plan last failed:
  // ---------------------------------------------------------------------
  Lng32 failedInPassNo_;

  // ---------------------------------------------------------------------
  // The optimization goal for each child of the given physical expression
  // that is created using the given context.
  // ---------------------------------------------------------------------
  ARRAY(Context *) childContexts_; // for phys. Operators

}; // CascadesPlan

// -----------------------------------------------------------------------
// Just for convenience: a list collection of CascadesPlan pointers
// -----------------------------------------------------------------------

class CascadesPlanList : public LIST(CascadesPlan *)
{
public:
  CascadesPlanList(CollHeap* h/*=0*/) : LIST(CascadesPlan *)(h)
    {  }
};
//<pb>
// -----------------------------------------------------------------------
// Optimization context
// ====================
// A context describes an optimization goal: required and excluded
// physical properties and a cost limit for the optimization of a
// certain equivalence class.
//
// The context also contains information about the potential solutions
// (candidates) that have been found during optimization. After the
// optimization is complete, the context contains either a solution or a
// NULL pointer to indicate failure.
//
// A context is typically created by an OptimizeGroupTask task and then
// shared by multiple follow-up tasks that deal with optimizing the
// equivalence class:
// - OptimizeExprTask tasks for all logical expressions in the
//   equivalence class at the time the OptimizeGroupTask task performs
//   (unless OptimizeGroupTask finds the optimal solution without
//    creating other tasks)
// - ApplyRuleTask tasks created by the OptimizeExprTask tasks
// - CreatePlanTask tasks created by the ApplyRuleTask tasks when
//   applying implementation rules
// - OptimizeExprTask tasks created by the ApplyRuleTask tasks when
//   applying transformation rules
// -----------------------------------------------------------------------

class Context : public NABasicObject
{

public:

  // constructor (do NOT use this constructor, use CascadesGroup::shareContext()
  // or ExprGroupId::shareContext()!!!!!)
  Context (CascadesGroupId equivClassId,
	   const ReqdPhysicalProperty * const reqdPhys,
           const InputPhysicalProperty* const inputPhys,
	   const EstLogPropSharedPtr& inputLogProp);

  virtual ~Context ();

  // ---------------------------------------------------------------------
  // Accessor methods used by the optimizer outside the Cascades
  // search engine.
  // ---------------------------------------------------------------------

  inline const ReqdPhysicalProperty * getReqdPhysicalProperty() const
                                                     { return reqdPhys_; }

  inline const InputPhysicalProperty* getInputPhysicalProperty() const
  { return inputPhys_; }

  NABoolean requiresOrder() const;
  NABoolean requiresPartitioning() const;
  NABoolean requiresSpecificLocation() const;

  inline CostLimit* getCostLimit() const            { return costLimit_; }

  inline CascadesPlan * getPlan() const           { return currentPlan_; }

  inline const PhysicalProperty *getPhysicalPropertyForSolution() const
  {
    if (solution_)
      return solution_->getPhysicalProperty();
    else
      return NULL;
  }

  inline const Cost *getCostForSolution() const
  {
    if (solution_)
      return solution_->getRollUpCost();
    else
      return NULL;
  }

  const RelExpr *
  getPhysicalExprOfSolutionForChild(Lng32 childIndex) const;

  const PhysicalProperty * getPhysicalPropertyOfSolutionForChild
                              (Lng32 childIndex) const;

  const Cost * getCostOfSolutionForChild(Lng32 childIndex) const;

  const RelExpr *
  getPhysicalExprOfSolutionForGrandChild(Lng32 childIndex,
                                         Lng32 grandChildIndex) const;

  const PhysicalProperty * getPhysicalPropertyOfSolutionForGrandChild
                              (Lng32 childIndex,
                               Lng32 grandChildIndex) const;

  // ---------------------------------------------------------------------
  // Mutator methods used by the optimizer outside the Cascades
  // search engine.
  // ---------------------------------------------------------------------

  // --- Methods on Cost Limit

  void setCostLimit(CostLimit* c);

  void setCostLimitExceeded() { costLimitExceeded_ = TRUE; }

  // is the current cost limit a feasible one for creating a plan?
  NABoolean isCostLimitFeasible() const
                                      { return (NOT costLimitExceeded_); }
  NABoolean exceededCostLimit() const
                                      { return NOT costLimitExceeded_; }


  // These two method used by pruning heuristic to use failed plan cost
  inline void setCurrentPlanExceededCostLimit()
  {
	currentPlanExceededCostLimit_ = TRUE;
  }
  inline NABoolean currentPlanExceededCostLimit()
  {
	return currentPlanExceededCostLimit_;
  }
  // ---------------------------------------------------------------------
  // Methods that are used within the Cascades search engine.
  // ---------------------------------------------------------------------

  // Compare one context with another;
  // result == MORE <==> this context is more restricive
  // in both reqd and excl phys prop; similar for LESS;
  // result == INCOMPATIBLE if contexts have conflicting
  // requested properties (like sorted by A vs. sorted by B),
  // otherwise, result = UNDEFINED.
  COMPARE_RESULT compareContexts (const Context & other) const;

  // Mark this Context to indicate that it is *done* for the current pass.
  // The marking is done for a Context that cannot yield an optimal plan,
  // e.g., because the plan is infeasible given the cost limit.
  void markAsDoneForCurrentPass()
                  { doneInPass_ = GlobalRuleSet->getCurrentPassNumber(); }

  // Use this to re-optimize the current context:
  void resetCurrentPassNumber()
  { doneInPass_ = Lng32(-1); }

  // Has this Context been optimized during the current optimization pass?
  NABoolean optimizedInCurrentPass() const
        { return (doneInPass_ == GlobalRuleSet->getCurrentPassNumber()); }

  // Does this Context provide an optimal solution?
  // The Context provides an optimal solution, iff a solution is found
  // during the current optimization pass whose cost is within the cost
  // limit.
  NABoolean hasOptimalSolution() const;

  // The Context provides possible solution, iff a solution is found
  // during the current optimization pass. Cost limit needs to be checked
  // separately, when necessary.
  NABoolean hasSolution() const
  {
    return ( solution_ AND optimizedInCurrentPass() );
  }

  void clearFailedStatus();

  // Test whether the given plan satisfies a context.
  // (no consideration of the cost limit)
  NABoolean satisfied(const CascadesPlan * const plan) const;

  // Find the best existing plan for a context and indicate in the return
  // value whether the optimal plan or a definite failure has been found.
  NABoolean findBestSolution();

  // The following function will be used by parallelHeuristic2.
  // The heuristics will check if the current group is small (less than
  // ROWS_PARALLEL_THRESHOLD) and has only one base table to skip
  // re-optimization of logical expressions and existing plans for this
  // group if the context has partitioning requirements other than
  // "exactly one partition".
  NABoolean reoptimizeExprAndPlans();

  // return a complete solution (a binding of a tree of physical nodes)
  //
  // see function body for description of the parameter
  RelExpr * bindSolutionTree(NABoolean getPrevSolution=FALSE) const;

  NABoolean isPruningEnabled() const           { return pruningEnabled_; }
  void setPruningEnabled(NABoolean v)             { pruningEnabled_ = v; }

  // store pws information in context, used for preliminary cost estimation
  void setPlanWorkSpace(PlanWorkSpace *myPws) { myPws_ = myPws; }
  inline PlanWorkSpace* getPlanWorkSpace() const { return myPws_; }

  NABoolean isNice() const
  {
    return niceContext_;
  }

  NABoolean isNiceContextEnabled() const;

  void setNice(NABoolean v)                          { niceContext_ = v; }

  CascadesGroupId getGroupId() const                  { return groupId_; }
  void setGroupId(CascadesGroupId g)                     { groupId_ = g; }

  // methods on the associated input est. logical properties
  EstLogPropSharedPtr getInputLogProp() const  { return inputEstLogProp_; }
  void setInputLogProp(const EstLogPropSharedPtr& elp) { inputEstLogProp_ = elp; }

  // --- Methods on the current plan

  // Whenever this Context is reused (CascadesGroup::shareContext()),
  // the current plan is cleared.
  void clearCurrentPlan()                         { currentPlan_ = NULL; }

  // Whenever this Context is resued for creating a new plan
  // (CreatePlanTask::CreatePlanTask), the new plan is assigned
  // with this Context.
  void assignCurrentPlan(CascadesPlan * plan)     { currentPlan_ = plan; }

  // --- Methods on the plans that are candidate solutions.

  void addCandidatePlan(CascadesPlan * plan);

  inline Lng32 getCountOfCandidatePlans() const
                                         { return candidates_.entries(); }
  inline CascadesPlan * getCandidatePlan(Lng32 i)
                                                { return candidates_[i]; }
  inline NABoolean isACandidate(CascadesPlan *plan) const
                                    { return candidates_.contains(plan); }

  // --- Methods on the plan that is the best solution so far

  inline const CascadesPlan * getSolution() const    { return solution_; }


  void setSolution(CascadesPlan *plan,
                   NABoolean checkAndAdjustCostLimit = TRUE);

  void setPhysicalPropertyForSolution(PhysicalProperty* spp)
                                  { solution_->setPhysicalProperty(spp); }

  // manage the number of outstanding operations/tasks for this context
  Lng32 getOutstanding() const                     { return outstanding_; }
  inline void incrOutstanding()                        { outstanding_++; }
  void decrOutstanding();

  Context * getCurrentAncestor() const        { return currentAncestor_; }
  void setCurrentAncestor(Context *c)            { currentAncestor_ = c; }

  NABoolean isADuplicate() const          { return duplicateOf_ != NULL; }
  Context * getDuplicateOf() const                { return duplicateOf_; }
  void setDuplicateOf(Context *c)                    { duplicateOf_ = c; }

  void setPredecessorTask(CascadesTask *t)       { predecessorTask_ = t; }
  CascadesTask * getPredecessorTask() const   { return predecessorTask_; }

  inline const RuleSubset &getTriedEnforcerRules() const
                                           { return triedEnforcerRules_; }
  inline RuleSubset &triedEnforcerRules() { return triedEnforcerRules_; }
  inline RuleSubset &ignoredRules() { return ignoreTheseRules_; }

  virtual void print (FILE * f = stdout,
		      const char * prefix = "",
		      const char * suffix = "") const;

  NAString getRequirementsString() const;
  //GTOOL
  NAString getCostString() const;
  NAString getRPPString() const;
  NAString getIPPString() const;
  NAString getILPString() const;
  NAString getStatusString() const;

  // -- Methods to enable the optimizer "recovery" mechanism
  // -- basically, if the optimizer hits an assertion in pass N,
  // -- we return the best plan from pass N-1

  inline const CascadesPlan * getPreviousSolution() const
                                                 { return prevSolution_; }
  NABoolean setPreviousSolution() ;

  const GroupAttributes *getGroupAttr() const;

//<pb>
private:

  // ---------------------------------------------------------------------
  // information that is passed top-down during the optimization process
  // ---------------------------------------------------------------------

  const ReqdPhysicalProperty* const reqdPhys_;  // required physical properties

  const InputPhysicalProperty* const inputPhys_; // input physical properties

  CostLimit*                costLimit_;       // cost limit

  // ---------------------------------------------------------------------
  // administrative information, used by the optimizer search engine
  // ---------------------------------------------------------------------
  CascadesGroupId  groupId_;           // where is this context used
  Lng32             doneInPass_;        // OptimizeGroupTask done in this pass
  Lng32             outstanding_;       // # plans outstanding in
                                       // OptimizeGroupTask task
  Context*         currentAncestor_;   // current parent context
  Context*         duplicateOf_;       // duplicate resulting from
                                       // equivalence class merge

  // pointer to the predecessor task for this context, i.e.
  // the task scheduled just prior to the OptimizeGroupTask for this context
  CascadesTask*    predecessorTask_;

  NABoolean        costLimitExceeded_; // solution exceeds cost limit
  NABoolean        currentPlanExceededCostLimit_; // flag passed from plan
  NABoolean        pruningEnabled_;    // allowed to perform branch and bound?

  // "Nice context". If true, parent will not imlicitly require properties
  // from grandchildren (could be satisfied by child naturally or forced
  // by enforcers above immediate child). Usually, parent requirement will
  // be always tried first before firing enforcers. This causes, for
  // example, partitioning requirement created by groupBy to be tried by
  // any relational operator below that groupBy, as weel as arrangement
  // requirement created by merge join. "Nice context" reduces the number
  // of contexts to be optimized, therefore - compile time and memory
  // required to optimize the plan. The plan created with "nice context"
  // could be a littel worse than default plan.
  NABoolean        niceContext_;

  // ---------------------------------------------------------------------
  // Each context is associated with one set of input estimated logical
  // properties from this group (or NULL).
  // ---------------------------------------------------------------------
  EstLogPropSharedPtr inputEstLogProp_;  // input est. log. properties used
                                         // during optimization

  // ---------------------------------------------------------------------
  // Bitmap specifying which enforcer rules have already been applied
  // for this context (to avoid applying them again).
  // ---------------------------------------------------------------------
  RuleSubset triedEnforcerRules_;

  // ---------------------------------------------------------------------
  // Bitmap specifying All the rules that this context may consider.
  // This is done for performance reason and not correctness.
  // ---------------------------------------------------------------------
  RuleSubset ignoreTheseRules_;

  // ---------------------------------------------------------------------
  // Plans that are generated bottom up.
  // ---------------------------------------------------------------------
  CascadesPlan*    currentPlan_;  // plan that is currently being optimized
				  // using  this Context
  CascadesPlan*    solution_;     // optimal solution for this context
  CascadesPlan*    prevSolution_ ;// pointer to the solution of the previous
                                  // optimizer pass (needed for recovery from
                                  // assertion failures)
  CascadesPlanList candidates_;   // plans that satisfy the context

  PlanWorkSpace*       myPws_;    // my PlanWorkSpace

}; // Context

// -----------------------------------------------------------------------
// A list and an array of context pointers
// -----------------------------------------------------------------------
class ContextList : public LIST(Context *)
{
public:
  ContextList(CollHeap* h/*=0*/) : LIST(Context *)(h) //
    {  }
};

class ContextArray : public ARRAY(Context *)
{
public:
  ContextArray(CollHeap* h/*=0*/) : ARRAY(Context *)(h)
    {}

  // copy ctor
  ContextArray (const ContextArray & orig, CollHeap * h=0) ;
};
//<pb>
// -----------------------------------------------------------------------
// class PlanWorkSpace
//
// This object is created and destroyed together with the CreatePlanTask.
// It provides a memory for the implementation of the plan generator,
// createPlan(). The latter method can create multiple
// Contexts for considering different plans for one or more of its
// children. It saves each Context that is created for its child in
// a PlanWorkSpace object. Finally, it selects one of the candidates
// per child to create its own execution plan.
// -----------------------------------------------------------------------

class PlanWorkSpace : public NABasicObject
{
public:

  // ---------------------------------------------------------------------
  // Constructor and destructor.
  // ---------------------------------------------------------------------
  PlanWorkSpace(Lng32 numberOfChildren);

  ~PlanWorkSpace();

  const Context *getContext() const { return myContext_; }

  // ---------------------------------------------------------------------
  // Set the context under which this operator is optimized for. A plan
  // must have already been created for this context by CreatePlanTask.
  // ---------------------------------------------------------------------
  void storeContext(Context* myContext)
  {
    myContext_ = myContext;
    CMPASSERT(myContext_->getPlan() != NULL);
  }

  // ---------------------------------------------------------------------
  // Is the workspace empty?
  // ---------------------------------------------------------------------
  NABoolean isEmpty() const               { return (contextCount_ == 0); }

  Lng32 getCountOfChildContexts() const           { return contextCount_; }

  // ---------------------------------------------------------------------
  // Store a new child Context in the PlanWorkSpace.
  // ---------------------------------------------------------------------
  void storeChildContext(Lng32 childIndex, Lng32 planNumber,
			 Context* childContext);

  // ---------------------------------------------------------------------
  // Get a specific child Context.
  // ---------------------------------------------------------------------
  Context* getChildContext(Lng32 childIndex, Lng32 planNumber = 0) const;

  // Is this plan's n-th child a scan?
  NABoolean getScanLeaf(int childNumber, int planNumber, FileScan *&scanLeaf) const;

  // -----------------------------------------------------------------------
  // Erase the latest context.
  // -----------------------------------------------------------------------
  void eraseLatestContextFromWorkSpace();

  // -----------------------------------------------------------------------
  // Delete the specified child Context from the PlanWorkSpace.
  // -----------------------------------------------------------------------
  void deleteChildContext(Lng32 childIndex, Lng32 planNumber);

  // ---------------------------------------------------------------------
  // Initialize the cost and set it to the initial local cost.
  // ---------------------------------------------------------------------
  void initializeCost(Cost* operatorCost);

  void setOperatorCost(Cost * cost);

  Cost* getOperatorCost() const          { return operatorCost_; }

  void setCountOfStreams(Lng32 countOfStreams)
                                     { countOfStreams_ = countOfStreams; }

  Lng32 getCountOfStreams() const               { return countOfStreams_; }

  // ---------------------------------------------------------------------
  // Return initial operator cost if the guess we made about the
  // physical properties that costing is based on was accurate.
  // Otherwise, recompute the operator cost using the synthesized
  // physical property stored in myContext_->getPlan() and return it.
  // ---------------------------------------------------------------------
  Cost* getFinalOperatorCost(Lng32 planNumber);

  // ---------------------------------------------------------------------
  // Set/get a computed PartialPlan cost in/from the PlanWorkSpace.
  // ---------------------------------------------------------------------
  void setPartialPlanCost(Cost* newCost);

  Cost* getPartialPlanCost() const                { return partialPlanCost_; }

  // ---------------------------------------------------------------------
  // Set/get a computed known children cost in/from the PlanWorkSpace.
  // ---------------------------------------------------------------------
  void setKnownChildrenCost(Cost* newCost);

  Cost* getKnownChildrenCost() const          { return knownChildrenCost_; }

  void updateBestCost(Cost* cost, Lng32 planNumber);

  Cost*             getBestRollUpCostSoFar() const
                                               { return bestRollUpCostSoFar_; }

  Cost*             getBestOperatorCostSoFar() const
                                             { return bestOperatorCostSoFar_; }

  Lng32              getBestPlanSoFar() const { return bestPlanSoFar_; }

  NABoolean isBestPlanSoFarBMO() const       { return bestPlanSoFarIsBMO_; }

  PhysicalProperty* getBestSynthPhysPropSoFar() const
                                            { return bestSynthPhysPropSoFar_; }

  void setPartialPlanCostToOperatorCost();

  // ---------------------------------------------------------------------
  // Get the latest Context that was considered.
  // ---------------------------------------------------------------------
  Context* getLatestChildContext() const        { return latestContext_; }

  Lng32 getLatestChildIndex() const                { return latestChild_; }

  Lng32 getLatestPlan() const                       { return latestPlan_; }
  Lng32 getPrevPlan() const                     { return prevPlan_; }


  // ---------------------------------------------------------------------
  // Keep track of number of children costed for latest plan.
  // ---------------------------------------------------------------------
  Lng32 getPlanChildCount() const               { return planChildCount_; }
  void incPlanChildCount()                          { ++planChildCount_; }
  void resetPlanChildCount()                      { planChildCount_ = 0; }

  // ---------------------------------------------------------------------
  // If the latest Context cannot be used because the cost for its plan
  // exceeds the cost limit, mark it as failed,
  // ---------------------------------------------------------------------
  void markLatestContextAsViolatesCostLimit()
                                         { withinCostLimitFlag_ = FALSE; }
  NABoolean isLatestContextWithinCostLimit() const
                                          { return withinCostLimitFlag_; }

  // ---------------------------------------------------------------------
  // Iterates over the well-formed plans stored in this pws, cost them
  // and pick the one with the lowest cost if planNumber is specified to
  // be -1. Otherwise, just pick the plan with planNumber if it's valid,
  // pick no plan otherwise. Return TRUE and set planNumber to the plan
  // picked if one is picked. Return FALSE and set planNumber to -1 other
  // wise.
  // ---------------------------------------------------------------------
  NABoolean findOptimalSolution(Lng32& planNumber);

  Cost* getCostOfPlan(Lng32 planNumber);

  // ---------------------------------------------------------------------
  // Does this pws belong to a big memory operator?
  // ---------------------------------------------------------------------
  void setBigMemoryOperator(NABoolean isBMO)           { isBMO_ = isBMO; }
  NABoolean isBigMemoryOperator() const                 { return isBMO_; }

  // ---------------------------------------------------------------------
  // Does this pws wants parallelism
  // ---------------------------------------------------------------------
  void setParallelismIsOK(NABoolean isOK)   { parallelismIsOK_ = isOK; }
  NABoolean getParallelismIsOK() const      { return parallelismIsOK_; }

  NABoolean allChildrenContextsConsidered()
    { return allChildrenContextsConsidered_;}
  void setAllChildrenContextsConsidered()
    { allChildrenContextsConsidered_ = TRUE;}
  void resetAllChildrenContextsConsidered()
    { allChildrenContextsConsidered_ = FALSE;}

#ifdef DEBUG
  // ---------------------------------------------------------------------
  //  Reset count of PlanWorkSpace objects created.  Used for debugging
  // purpopes only. The counter is maintained by CmpStatement::planWorkSpaceCount_
  // ---------------------------------------------------------------------
  void resetPwsCount();

#endif /* DEBUG */

//<pb>
private:

  // ---------------------------------------------------------------------
  // The context under which the operator associated with this pws is
  // optimized for.
  // ---------------------------------------------------------------------
  Context* myContext_;

  // ---------------------------------------------------------------------
  // The following array has as many elements as the number of children
  // of the physical expression for which plan generation is in progress.
  // Each element is an array of pointers to Contexts that are used for
  // optimzing a specific child.
  // ---------------------------------------------------------------------
  ARRAY(ContextArray*)  childContexts_;

  // ---------------------------------------------------------------------
  // A counter for contexts created so far.
  // ---------------------------------------------------------------------
  Lng32 contextCount_;

  // ---------------------------------------------------------------------
  // Cache the latest Context that was stored in childContexts_
  // as well as the index for the child.
  // ---------------------------------------------------------------------
  Lng32     latestChild_;
  Lng32     latestPlan_;
  Context* latestContext_;

  // keep track of previous plan, this will be compared with current plan
  // (latestPlan) to decide if preliminary cost need to be recomputed
  Lng32     prevPlan_;

  // ---------------------------------------------------------------------
  // Keep track of the number of children costed for the latest plan.
  // ---------------------------------------------------------------------
  Lng32     planChildCount_;

  // ---------------------------------------------------------------------
  // If the latest Context cannot be used because the cost for its plan
  // exceeds the cost limit, mark it as failed,
  // ---------------------------------------------------------------------
  NABoolean withinCostLimitFlag_;

  // ---------------------------------------------------------------------
  // Cost for this operator independent of its children.  Based initially
  // on an estimated degree of parallelism and possibly revised if actual
  // degree of parallelism differs from estimate.
  // ---------------------------------------------------------------------
  Cost* operatorCost_;

  // ---------------------------------------------------------------------
  // Degree of parallelism assumed when computing operator cost.
  // ---------------------------------------------------------------------
  Lng32 countOfStreams_;

  // ---------------------------------------------------------------------
  // The cost for this operator together with the cost for one or more
  // (but not all) of its children. This cost is NOT the final cost.
  // ---------------------------------------------------------------------
  Cost* partialPlanCost_;

  // -------------------------------------------------------------------
  // The cost for one or more (but not all) of this operator's children.
  // -------------------------------------------------------------------
  Cost* knownChildrenCost_;

  // --------------------------------------------------------------------
  //  The best roll-up cost of any plan considered so far for this plan
  // workspace.  Also keep track of the operator cost, plan number,
  // whether it is a BMO and synthesized physical properties associated
  // with the best plan so far.
  // --------------------------------------------------------------------
  Cost*             bestRollUpCostSoFar_;
  Cost*             bestOperatorCostSoFar_;
  Lng32              bestPlanSoFar_;
  NABoolean         bestPlanSoFarIsBMO_;
  PhysicalProperty* bestSynthPhysPropSoFar_;

  // ---------------------------------------------------------------------
  // Does this pws belong to a big memory operator?
  // ---------------------------------------------------------------------
  NABoolean isBMO_;

  // Flag is set to TRUE when all children contexts have been considered

  NABoolean allChildrenContextsConsidered_;

  // This attribute will be set to FALSE for hash and merge joins
  // when parallelHeuristic is on and okToAttemtESPParallelism()
  // function retuns FALSE
  NABoolean parallelismIsOK_;

#ifdef DEBUG
  ////////////////////////////////////////////////////////////////////////
  //   THE FOLLOWING FIELD IS USED FOR DEBUGGING PURPOSES ONLY    //
  ////////////////////////////////////////////////////////////////////////

  // ---------------------------------------------------------------------
  // Value of CmpStatement::planWorkSpaceCount_ at time of PlanWorkSpace creation. 
  // Used for debugging purposes only.  Never modified once set.
  // ---------------------------------------------------------------------
  Lng32 pwsID_;

#endif /* DEBUG */

}; // class PlanWorkSpace

class NestedJoinPlanWorkSpace : public PlanWorkSpace
{
public:

  NestedJoinPlanWorkSpace(Lng32 numberOfChildren) : 
       PlanWorkSpace(numberOfChildren),
       useParallelism_(FALSE),
       childNumPartsRequirement_(0),
       childNumPartsAllowedDeviation_(0.0),
       numOfESPsForced_(FALSE),
       childPlansToConsider_(0),
       OCBJoinIsConsidered_(FALSE),
       OCRJoinIsConsidered_(FALSE),
       fastLoadIntoTrafodion_(FALSE) {}
  ~NestedJoinPlanWorkSpace() {}

  NABoolean getUseParallelism()       const       { return useParallelism_; }
  Lng32     getChildNumPartsRequirement() const
                                        { return childNumPartsRequirement_; }
  float     getChildNumPartsAllowedDeviation() const
                                   { return childNumPartsAllowedDeviation_; }
  NABoolean getNumOfESPsForced()      const      { return numOfESPsForced_; }
  Lng32     getChildPlansToConsider() const { return childPlansToConsider_; }
  NABoolean getOCBJoinIsConsidered()  const  { return OCBJoinIsConsidered_; }
  NABoolean getOCRJoinIsConsidered()  const  { return OCRJoinIsConsidered_; }
  NABoolean getFastLoadIntoTrafodion()  const  { return fastLoadIntoTrafodion_; }

  void setParallelismItems(NABoolean useParallelism,
                           Lng32     childNumPartsRequirement,
                           float     childNumPartsAllowedDeviation,
                           NABoolean numOfESPsForced)
          {                useParallelism_ =                useParallelism;
                 childNumPartsRequirement_ =      childNumPartsRequirement;
            childNumPartsAllowedDeviation_ = childNumPartsAllowedDeviation;
                          numOfESPsForced_ =               numOfESPsForced; }
  void setChildPlansToConsider(Lng32 cp)      { childPlansToConsider_ = cp; }
  void setOCBJoinIsConsidered(NABoolean o)      { OCBJoinIsConsidered_ = o; }
  void setOCRJoinIsConsidered(NABoolean o)      { OCRJoinIsConsidered_ = o; }
  void setFastLoadIntoTrafodion(NABoolean o)      { fastLoadIntoTrafodion_ = o; }

  void transferParallelismReqsToRG(RequirementGenerator &rg);

private:

  NABoolean useParallelism_;
  Lng32     childNumPartsRequirement_;
  float     childNumPartsAllowedDeviation_;
  NABoolean numOfESPsForced_;
  Lng32     childPlansToConsider_;
  NABoolean OCBJoinIsConsidered_;
  NABoolean OCRJoinIsConsidered_;
  NABoolean fastLoadIntoTrafodion_;

}; // class NestedJoinPlanWorkSpace

class TMUDFPlanWorkSpace : public PlanWorkSpace
{
public:

  TMUDFPlanWorkSpace(Lng32 numberOfChildren) : 
       PlanWorkSpace(numberOfChildren),
       udrPlanInfo_(NULL)  {}
  ~TMUDFPlanWorkSpace() {}

  // ---------------------------------------------------------------------
  // get/set TMUDF-related things
  // ---------------------------------------------------------------------
  tmudr::UDRPlanInfo *getUDRPlanInfo()           { return udrPlanInfo_; }
  const tmudr::UDRPlanInfo *getUDRPlanInfo() const
                                                 { return udrPlanInfo_; }
  void setUDRPlanInfo(tmudr::UDRPlanInfo *pi)      { udrPlanInfo_ = pi; }

private:

  tmudr::UDRPlanInfo *udrPlanInfo_;

};

//<pb>
// -----------------------------------------------------------------------
// Groups of equivalent expressions
// ================================
// The search memory consists of many groups (equivalence classes) of
// equivalent expressions. A group collects all equivalent logical
// expressions (queries) and physical expressions (plans) and provides a
// centralized place for the logical properties of all these
// expressions.  It consists of three main components
// (a) a list of logical expressions that all produce the same result,
// (b) the logical properties of that result, and
// (c) a list of plans that implement the logical expressions.
// (d) a list of pattern for which this group has been expanded
// -----------------------------------------------------------------------

class CascadesGroup : public NABasicObject
{

public:

  CascadesGroup (CascadesGroupId groupId,
		 GroupAttributes *groupAttr);
  ~CascadesGroup ();

  inline CascadesGroupId getGroupId() const           { return groupId_; }

  inline GroupAttributes * getGroupAttr() const     { return groupAttr_; }

  // add, unlink, and retrieve logical/physical expressions, and plans
  void addLogExpr (RelExpr * expr, RelExpr *src=NULL);
  NABoolean addPhysExpr (RelExpr* & expr, RelExpr *src=NULL);
  void addPlan(CascadesPlan * plan);

  RelExpr *unlinkLogExpr(RelExpr *expr);
  RelExpr *unlinkPhysExpr(RelExpr *expr);

  inline RelExpr * getFirstLogExpr() const           { return logExprs_; }
  inline RelExpr * getFirstPhysExpr() const         { return physExprs_; }
  CascadesPlan   * getFirstPlan() const;

  const CascadesPlanList& getPlans() const              { return plans_; }
  Lng32 getCountOfPlans() const                { return plans_.entries(); }

  RelExpr * getLastLogExpr() const;

  Lng32 getCountOfLogicalExpr() const;
  Lng32 getCountOfPhysicalExpr() const;
  double calculateNoOfLogPlans() const;

  HashValue hash ();

  void merge (CascadesGroup * other);

  // create or share a context with a given optimization goal for this group
  Context * shareContext(const ReqdPhysicalProperty* const reqdPhys,
                         const InputPhysicalProperty* const inputPhys,
			 CostLimit* costLimit,
			 Context* parentContext,
			 const EstLogPropSharedPtr& inputLogProp);

  // access all the optimization goals (contexts) for this group
  inline Lng32 getCountOfContexts() const
                                              { return goals_.entries(); }
  inline Context * getContext(Lng32 i)                { return goals_[i]; }

  inline Lng32 getExploredInPass() const        { return exploredInPass_; }
  inline void setExploredInPass(Lng32 e)           { exploredInPass_ = e; }

  inline RuleSubset getExploredRules () const       {return exploredRules_;}
  inline void addToExploredRules (RuleSubset & rules) {exploredRules_ += rules;}

  // temporary, for nice context prototype
  inline NABoolean isBelowRoot() const
  {
      return isBelowRoot_;
  }
  inline void setBelowRoot(NABoolean val)
  {
      isBelowRoot_ = val;
  }

  void print (FILE * f = stdout,
	      const char * prefix = "",
	      const char * suffix = "") const;
//<pb>
private:

  CascadesGroupId   groupId_;          // index into CascadesMemo
  GroupAttributes * groupAttr_;        // common attributes for this Group
  RelExpr         * logExprs_;         // linked list of logical expressions
  RelExpr         * physExprs_;        // linked list of physical expressions
  CascadesPlanList  plans_;            // linked list of plans
  ContextList       goals_;            // optimization goals tried so far
  Lng32              exploredInPass_;   // to avoid exploring twice
  RuleSubset        exploredRules_;    // Rules that the groups has been explored
                                       // with or scheduled to be explored with.
  // This is temporary and later should be moved to GroupAttr ot GroupAnalysys,
  // the flag will be TRUE for immediate child of the ROOT. This will help
  // top parallelism heristic and nice contrext for top groupBy
  NABoolean  isBelowRoot_;
}; // CascadesGroup
//<pb>
// -----------------------------------------------------------------------
// Search space memory
// ===================
// All search efforts' results are kept in the search space memory.
// The main components of this memory is an array of groups.  In
// addition, there is a hash table to facilitate fast detection of
// duplicate expressions.
// -----------------------------------------------------------------------

class CascadesMemo : public NABasicObject
{

public:

  CascadesMemo (CascadesGroupId groups = 100, Lng32 buckets = 1001);
  ~CascadesMemo ();
  // to include a newly derived expression in "memo"
  RelExpr * include (RelExpr * query,
		     NABoolean & duplicateExprFlag,
		     NABoolean & groupMergeFlag,
		     NABoolean GrpIdIsBinding = FALSE, //soln-10-070330-3667
		     CascadesGroupId groupId = INVALID_GROUP_ID,
		     Context * context = NULL,
                     RelExpr *before = NULL
                    );

  // deal with duplicate detection
  void addExpr (RelExpr * expr, HashValue hash_value);
  RelExpr * findDuplicate (RelExpr * expr) const;

  // deal with groups
  CascadesGroupId makeNewGroup(GroupAttributes *ga);
  void update (CascadesGroup * oldGroup, CascadesGroup * newGroup);
  inline Lng32 getCountOfUsedGroups() const
                                             { return group_.entries(); }
  inline CascadesGroup * operator[] (CascadesGroupId groupId)
                                              { return group_[groupId]; }

  // consolidate group pointers after group merge(s)
  Int32 garbageCollection();

  // check for inconsistencies (return FALSE if something wrong)
  NABoolean consistencyCheck() const;

  void print (FILE * f = stdout,
	      const char * prefix = "",
	      const char * suffix = "") const;

  void print_all_trees (CascadesGroupId root,
			NABoolean incl_log,
			NABoolean incl_phs,
			FILE * f = stdout) const;
//<pb>
private:

  ARRAY(CascadesGroup *) group_;      // groups of equivalent expressions

  ARRAY(RelExpr *)	 hash_;       // for dupl. expr. detection
  Lng32                   hashSize_;   // size of hash table

}; // CascadesMemo
//<pb>
// -----------------------------------------------------------------------
// Tasks
// =====
// A task is an activity within the search process.  The original task
// is to optimize the entire query.  Tasks create and schedule each
// other; when no un-done tasks remain, optimization terminates.
//  Tasks must destroy themselves when done!
// -----------------------------------------------------------------------

class CascadesTask : public NABasicObject
{
friend class CascadesTaskList;

public:

  enum cascadesTaskTypeEnum
    {
      OPTIMIZE_GROUP_TASK,
      OPTIMIZE_EXPR_TASK,
      APPLY_RULE_TASK,
      CREATE_PLAN_TASK,
      EXPLORE_GROUP_TASK,
      EXPLORE_EXPR_TASK,
      GARBAGE_COLLECTION_TASK,
      NUMBER_OF_TASK_TYPES = 7     // This should be at the end of the list
    };

  CascadesTask (Guidance * guidance, Context * context,
		Lng32 parentTaskId, short stride);
  ~CascadesTask ();

  Context * getContext() const                        { return context_; }

  inline CascadesTask * getNextTask() const {return next_; }

  inline Lng32 getParentTaskId() const { return parentTaskId_; }

  inline short getSubTaskId() const { return stride_; }

  virtual CascadesGroupId getGroupId() const;

  virtual RelExpr * getExpr();

  virtual CascadesPlan * getPlan();

  virtual void perform (Lng32 taskId) = 0;

  virtual void garbageCollection(RelExpr *oldx,
				 RelExpr *newx,
				 Int32 groupMergeCount);

  virtual NAString taskText() const;

  NABoolean taskNumberExceededLimit(Lng32 id);

  virtual void print (FILE * f = stdout,
		      const char * prefix = "",
		      const char * suffix = "") const;

  virtual cascadesTaskTypeEnum taskType() = 0;

//<pb>
private:

  CascadesTask	* next_;	  // linked list of tasks

protected:

  Guidance	* guidance_;	  // search guidance
  Context	* context_;	      // shared context
  Lng32        parentTaskId_;  // parent task, in execution order
  short       stride_;        
  // stride_ is (sub)task number assigned by parent in its parent::perform
  // call when parent was popped and it pushed this (sub)task onto the
  // cascades todo stack. 
  // {parentTaskId_,stride_} uniquely identifies this CascadesTask.

}; // CascadesTask
//<pb>
// -----------------------------------------------------------------------
// List of un-done tasks
// -----------------------------------------------------------------------

class CascadesTaskList : public NABasicObject
{

public:

  CascadesTaskList ();
  ~CascadesTaskList ();
  inline NABoolean empty () const { return first_ == NULL; }

  // push and pop
  inline void push (CascadesTask * task) { task->next_ = first_; first_ = task; }
  CascadesTask * pop ();

  // for the rare case when tasks need to be scheduled in a specific position
  // on the stack
  void insertTask (CascadesTask * task, CascadesTask * predecessorTask);

  // for the rare case when tasks need to be scheduled in a specific position
  // on the stack
  void insertOptimizeExprTask (CascadesTask * task, CascadesTask * predecessorTask);

  // non-destructive read
  CascadesTask * getFirst() { return first_; }
  CascadesTask * getNext(CascadesTask *prev) { return prev->next_; }

  void print (FILE * f = stdout,
	      const char * prefix = "",
	      const char * suffix = "") const;

private:

  CascadesTask	* first_;	// anchor of CascadesTask stack

}; // CascadesTaskList
//<pb>
// -----------------------------------------------------------------------
// Task to optimize a group
// ========================
// Find the optimal plan for any expression in a group.
// -----------------------------------------------------------------------

class OptimizeGroupTask : public CascadesTask
{

public:

  OptimizeGroupTask (Context * context,
		     Guidance * guidance,
		     NABoolean reoptimize,
		     Lng32 parentTaskId, short stride);
  virtual CascadesGroupId getGroupId() const;

  virtual void perform (Lng32 taskId);

  virtual NAString taskText() const;

  void print (FILE * f = stdout,
	      const char * prefix = "",
	      const char * suffix = "") const;

  virtual cascadesTaskTypeEnum taskType() {return CascadesTask::OPTIMIZE_GROUP_TASK;}

private:

  CascadesGroupId  groupId_;
  NABoolean        reoptimize_;  // retry optimization before taking any
                                 // existing "best" plans, if this is set to TRUE
  // helper method that returns true if scheduling a CreatePlanTask for this
  // plan's physExpr for this context_ can generate a DAG (non-tree) plan
  NABoolean canCauseCycle(const CascadesPlan *plan) const;
}; // OptimizeGroupTask
//<pb>
// -----------------------------------------------------------------------
// Task to explore a logical expression
// ====================================
// Find the optimal plan for any expression equivalent to a given one.
// -----------------------------------------------------------------------

class OptimizeExprTask : public CascadesTask
{

public:

  OptimizeExprTask (RelExpr * expr,
		    Guidance * guidance,
		    Context * context,
		    Lng32 parentTaskId, short stride);
  virtual CascadesGroupId getGroupId() const;

  virtual RelExpr * getExpr();

  virtual void perform (Lng32 taskId);

  virtual void garbageCollection(RelExpr *oldx,
				 RelExpr *newx,
				 Int32 groupMergeCount);

  void print (FILE * f = stdout,
	      const char * prefix = "",
	      const char * suffix = "") const;

  virtual NAString taskText() const;

  virtual cascadesTaskTypeEnum taskType() {return CascadesTask::OPTIMIZE_EXPR_TASK;}

private:

  RelExpr	* expr_;

}; // OptimizeExprTask
//<pb>
// -----------------------------------------------------------------------
// Task to explore a group
// =======================
// Given a pattern, create all equivalent expressions matching
// the pattern.  If the pattern is NULL, create all equivalent
// expressions.
// -----------------------------------------------------------------------

class ExploreGroupTask : public CascadesTask
{

public:

  ExploreGroupTask (CascadesGroupId groupId,
		    RelExpr * pattern,
		    Guidance * guidance,
		    Lng32 parentTaskId, short stride);
  virtual CascadesGroupId getGroupId() const;

  virtual void perform (Lng32 taskId);

  void print (FILE * f = stdout,
	      const char * prefix = "",
	      const char * suffix = "") const;

  virtual NAString taskText() const;

  virtual cascadesTaskTypeEnum taskType() {return CascadesTask::EXPLORE_GROUP_TASK;}

private:

  CascadesGroupId   groupId_;
  RelExpr	  * pattern_;

}; // ExploreGroupTask
//<pb>
// -----------------------------------------------------------------------
// Task to explore a logical expression
// ====================================
// Given a pattern, create all equivalent expressions matching
// the pattern.  If the pattern is NULL, create all equivalent
// expressions.
// -----------------------------------------------------------------------

class ExploreExprTask : public CascadesTask
{

public:

  ExploreExprTask (RelExpr * expr,
		   RelExpr * pattern,
		   Guidance * guidance,
		   Lng32 parentTaskId, short stride);
  virtual CascadesGroupId getGroupId() const;
  virtual RelExpr * getExpr();

  virtual void perform (Lng32 taskId);

  virtual void garbageCollection(RelExpr *oldx,
				 RelExpr *newx,
				 Int32 groupMergeCount);
  void print (FILE * f = stdout,
	      const char * prefix = "",
	      const char * suffix = "") const;

  virtual NAString taskText() const;

  virtual cascadesTaskTypeEnum taskType() {return CascadesTask::EXPLORE_EXPR_TASK;}

private:

  RelExpr	* expr_;
  RelExpr	* pattern_;

}; // ExploreExprTask
//<pb>
// -----------------------------------------------------------------------
// Task to apply a rule to a logical expression
// ============================================
// Given a rule and a logical expression, determine all sensible
// bind ings for the subexpressions currently available in "memo" and
// apply the rule.
// -----------------------------------------------------------------------

class ApplyRuleTask : public CascadesTask
{

public:

  ApplyRuleTask (Rule * rule,
		 RelExpr * expr,
		 RelExpr * pattern,
		 Guidance * guidance,
		 Context * context,
		 Lng32 parentTaskId, short stride);
  virtual CascadesGroupId getGroupId() const;
  virtual RelExpr * getExpr();

  virtual void perform (Lng32 taskId);

  virtual void garbageCollection(RelExpr *oldx,
				 RelExpr *newx,
				 Int32 groupMergeCount);

  void print (FILE * f = stdout,
	      const char * prefix = "",
	      const char * suffix = "") const;
  virtual NAString taskText() const;

  virtual cascadesTaskTypeEnum taskType() {return CascadesTask::APPLY_RULE_TASK;}

private:

  Rule		* rule_;	// rule to apply
  RelExpr	* expr_;	// root of expr. before rule
  RelExpr     	* pattern_;     // pattern for further exploration
  NABoolean     exploring_;     // FALSE if apply is for an optimizing task
                                // TRUE if apply is for exploring task

}; // ApplyRuleTask
//<pb>
// -----------------------------------------------------------------------
// Task to create a subplan
// ========================
// After an implementation rule has been applied during optimization,
// i.e., an implementation algorithm has been considered for one node
// in the query tree, optimization continues by optimizating each
// child to the implementation algorithm.  This task schedules further
// tasks to optimize one child at a time.  This task is different from
// other task types in the sense that this task is activated multiple
// times, i.e., each time another child has been optimized.
// -----------------------------------------------------------------------

class CreatePlanTask : public CascadesTask
{

public:

  CreatePlanTask (Rule * rule,
		  RelExpr * expr,
		  Guidance * guidance,
		  Context * context,
		  Lng32 parentTaskId, short stride,
		  CascadesPlan * failedPlan = NULL);

  ~CreatePlanTask ();
  void print (FILE * f = stdout,
	      const char * prefix = "",
	      const char * suffix = "") const;
  virtual NAString taskText() const;
  virtual CascadesGroupId getGroupId() const;
  virtual RelExpr * getExpr();
  virtual CascadesPlan * getPlan();

  virtual void perform (Lng32 taskId);

  virtual void garbageCollection(RelExpr *oldx,
				 RelExpr *newx,
				 Int32 groupMergeCount);

  virtual cascadesTaskTypeEnum taskType() {return CascadesTask::CREATE_PLAN_TASK;}

private:

  CascadesPlan * plan_;            // the plan

  PlanWorkSpace*  workSpace_;      // how many lives did this task have so far

  Rule *         rule_;            // implementation rule that was applied

}; // CreatePlanTask
//<pb>
// -----------------------------------------------------------------------
// Task to clean up after a group merge
// ====================================
// After a group merge, the merged group can be accessed with two
// different group numbers. The garbage collection task walks through
// the CascadesMemo structure and makes sure only one group number is used for
// each group, to avoid duplicate expressions that aren't detected as
// such, because they use different (but equivalent) group numbers.
// -----------------------------------------------------------------------

class GarbageCollectionTask : public CascadesTask
{

public:

  GarbageCollectionTask ();
  ~GarbageCollectionTask ();
  virtual void perform (Lng32 taskId);

  virtual void garbageCollection(RelExpr *oldx,
				 RelExpr *newx,
				 Int32 groupMergeCount);

  void print (FILE * f = stdout,
	      const char * prefix = "",
	      const char * suffix = "") const;

  virtual NAString taskText() const;

  virtual cascadesTaskTypeEnum taskType() {return CascadesTask::GARBAGE_COLLECTION_TASK;}

private:

  NABoolean alreadyDone_;
}; // GarbageCollectionTask
//<pb>
// -----------------------------------------------------------------------
// Bindings
// ========
// for pattern matching while applying a rule.  The CascadesBinding-tree is
// structured like the pattern; each CascadesBinding points to a logical
// expression (within a group).  The "advance" method permits to
// iterator over all possible bindings for a pattern.
// -----------------------------------------------------------------------

class CascadesBinding : public ReferenceCounter
{

public:

  enum CascadesBindingStateEnum
    {
      START_GROUP,	// newly created for an entire group
      START_EXPR,	// newly created for a single expression
      VALID_BINDING,	// last binding was succeeded
      ALMOST_EXHAUSTED, // last binding succeeded, but no further ones
      FINISHED,	        // iteration through bindings is exhausted
      EXPR_FINISHED	// current expr is finished; in advance() only
    };

  static const char * binding_state_name (CascadesBindingStateEnum state)
    {
      return  state == START_GROUP ? "start a group" :
              state == START_EXPR ? "start an expr" :
              state == VALID_BINDING ? "valid binding" :
              state == ALMOST_EXHAUSTED ? "last valid binding" :
              state == FINISHED ? "finished" : "undefined";
    } // binding_state_name

  // to find bindings for all expressions in group
  CascadesBinding(CascadesGroupId groupId,
		  RelExpr * pattern,
		  CascadesBinding * parent,
		  NABoolean incl_log,
		  NABoolean incl_phys);

  // to find bindings rooted at a specific logical expression
  CascadesBinding(RelExpr * expr,
		  RelExpr * pattern,
		  CascadesBinding * parent,
		  NABoolean incl_log,
		  NABoolean incl_phys);

  ~CascadesBinding();
  void print(FILE * f = stdout,
	     const char * prefix = "",
	     const char * suffix = "") const;

  NABoolean advance();		// produce the next binding

  RelExpr * extract_expr();        // materialize a binding
  void release_expr();          // release the materialized binding

  inline CascadesGroupId getGroupId() const { return groupId_; }
  inline CascadesBinding * getParent() { return parent_; }
//<pb>
private:

  CascadesBindingStateEnum  state_;

  NABoolean	     fixed_;	    // is advancing prohibited?
  CascadesGroupId    groupId_;      // group for which a binding is to be created
  RelExpr	   * curExpr_;	    // first or current expression
  RelExpr          * copiedExpr_;   // copied extracted expression or NULL

  RelExpr	   * pattern_;	    // pattern to search for
  CascadesBinding  * parent_;       // parent binding or NULL for top
  NABoolean	     inclLog_;	    // include log. expr's?
  NABoolean	     inclPhys_;	    // include phys. expr's?

  LIST(CascadesBinding *) children_;  // bindings for child expr's

};  // CascadesBinding

// -----------------------------------------------------------------------
// class OptDebug
//
// This class is for printing debug information to a file in the optimizer.
// On NSK, Display GUI is not available and arkcmp does not own a console
// window.  Hence, we want to log debug information to a file.
//
// -----------------------------------------------------------------------

class OptDebug
{
public:
  OptDebug();
  ~OptDebug();

  NABoolean openLog( const char* filename );
  void closeLog();

  
  void setCompileInstanceClass(const char* str);

  // ---------------------------------------------------------------------
  // Accessor functions.
  // ---------------------------------------------------------------------
  ostream& stream();
  FILE*    fp();

  // ---------------------------------------------------------------------
  // Functions to show tree nodes and their properties for debugging purpose.
  // ---------------------------------------------------------------------
  void showTree( const ExprNode *tree = NULL,
                 const CascadesPlan *plan = NULL,
                 const char *prefix = "",
                 NABoolean showDetail = TRUE );

  // ---------------------------------------------------------------------
  // Functions to show CascadeTask for debugging purpose.
  // ---------------------------------------------------------------------
  void showTask( Int32 pass = -1,
                 Int32 groupId = -1,
                 Int32 task_count = -1,
                 const CascadesTask *task = NULL,
                 const ExprNode *tree = NULL,
                 const CascadesPlan *plan = NULL,
                 const char *prefix = "" );

  void showNode( const ExprNode *tree = NULL,
                 const CascadesPlan *plan = NULL,
                 const char *prefix = "",
                 NABoolean showDetail = TRUE );

  // ---------------------------------------------------------------------
  // Functions to show memo statistics for debugging purpose.
  // ---------------------------------------------------------------------
  void showMemoStats(CascadesMemo *memo, const char *prefix, ostream &out);

private:

  // ---------------------------------------------------------------------
  // Log file related members.
  // ---------------------------------------------------------------------

  NABoolean fileIsGood_;         // true if a file has been specified
  char      logFileName_[1024];  // log file name
  fstream   fstream_;            // log file stream
  FILE     *file_;               // log file object

  CmpContextInfo::CmpContextClassType ciClass_;  // the class of compile instances
                                 // to which the compilation activities as
                                 // specified by NSK_DBG_<nnn> will be reported.
                                 // The values are defined by 
                                 // CmpContextInfo::setCompileInstanceClass.

  // ---------------------------------------------------------------------
  // Helper functions
  // ---------------------------------------------------------------------

  void showItemExpr( const ExprNode *tree = NULL,
                     const CascadesPlan *plan = NULL,
                     const char *prefix = "" );

  void showProperties( const ExprNode *tree = NULL,
                       const CascadesPlan *plan = NULL,
                       const char *prefix = "" );

  double getCost( const RelExpr *re, const CascadesPlan *plan );
  double getRows( const RelExpr *re, const CascadesPlan *plan );
  const NAString getGroups( const RelExpr *re );
  const NAString getType( const RelExpr *re, const CascadesPlan *plan );

  void showCharacteristicInputs( const RelExpr *re,
                                 const CascadesPlan *plan,
                                 const char *prefix = "" );
  void showCharacteristicOutputs( const RelExpr *re,
                                  const CascadesPlan *plan,
                                  const char *prefix = "" );
  void showConstraints( const RelExpr *re,
                        const CascadesPlan *plan,
                        const char *prefix = "" );
  void showContext( const RelExpr *re,
                    const CascadesPlan *plan,
                    const char *prefix = "" );
  void showCosts( const RelExpr *re,
                  const CascadesPlan *plan,
                  const char *prefix = "" );
  void showLogicalProperties( const RelExpr *re,
                              const CascadesPlan *plan,
                              const char *prefix = "" );
  void showPhysicalProperties( const RelExpr *re,
                               const CascadesPlan *plan,
                               const char *prefix = "" );

  void showEstLogProp( const EstLogPropSharedPtr& estLogProp,
                       const char * prefix = "" );

  void showCostInDetail( const NAString& header,
                         const Cost *cost,
                         const char *prefix = "" );
  void showSimpleCostVector( const char* header,
                             const SimpleCostVector &scv,
                             const char *prefix,
                             ostream &out );
  void showSimpleCostVectorDetail( const SimpleCostVector &scv,
                                   const char *prefix,
                                   ostream &out );

};  // class OptDebug

class AssertException;

class QueryOptimizerDriver
{
public:
  QueryOptimizerDriver(RelExpr *relExpr);
  ~QueryOptimizerDriver();
  RelExpr * doPass1Only(RelExpr *relExpr, Context *context);
  RelExpr * doPass1Pass2(RelExpr *relExpr, Context *context);
  RelExpr * doPass2PerhapsPass1(RelExpr *relExpr, Context *context,
				RelExpr *original);
  Context * initializeOptimization(RelExpr *relExpr);
  void resetOptimization();
private:
  void DEBUG_BREAK_ON_TASK();
  void DEBUG_SHOW_TASK(CascadesTask * task);
  void DEBUG_PRINT_COUNTERS();
  void DEBUG_RESET_PWSCOUNT();
  void DEBUG_SHOW_PLAN(Context *context);

  void DEBUG_GUI_DO_MEMO_STEP(CascadesTask *task);
  void DEBUG_GUI_SET_POINTERS();
  void DEBUG_GUI_DISPLAY_TRIGGERS_AFTER_NORMALIZATION(RelExpr *relExpr);
  void DEBUG_GUI_HIDE_QUERY_TREE();
  void DEBUG_GUI_DISPLAY_AFTER_OPTIMIZATION(Context *context);

  void TEST_ERROR_HANDLING();

  void initializeMonitors();
  RelExpr * bindSavedPass1Solution(RelExpr *relExpr, Context *context);
  void setupPassTwoHeuristics(Context *context);
  void optimizeAPass(Context *context);
  void optimizeAPassHelper(Context *context);
  void markFatalAndGenErrorNoPlan(RelExpr *relExpr, Context *context);
  void genWarnAssertPassTwo(AssertException & e);
  void genWarnNoPlanPassTwo();
  void genErrorNoPlan(RelExpr *relExpr, Context *context);

  NABoolean fatalExceptionOccurring_;
  NABoolean isStream_;
  NABoolean isCQS_;
  Lng32 taskCount_;
  Lng32 taskCountHold_;
  NABoolean printCounters_;
};

void opt_qsort(void *base, UInt32 num, UInt32 width, Int32 (*comp)(const void *, const void *));


// class to wrap some optimizer global variables. 
class OptGlobals
{
public:
   OptGlobals (NAHeap* heap_);

   // -----------------------------------------------------------------------
   // counters for capturing optimizer statistics
   // -----------------------------------------------------------------------

   ObjectCounter* contextCounter; 
   ObjectCounter* cascadesPlanCounter; 

   Lng32            duplicate_expr_count;

#ifdef DEBUG
  // ---------------------------------------------------------------------
  // Counter for number of PlanWorkSpace objects generated by the
  // optimizer for a particular SQL statement.
  // Used for debugging purposes only
  // ---------------------------------------------------------------------
  Lng32 planWorkSpaceCount;
#endif /* DEBUG */

   Lng32            logical_expr_count;
   Lng32            physical_expr_count;
   Lng32            plans_count;

   // ----------------------------------------------------------------
   // counters for evaluating ASM
   // -----------------------------------------------------------------
   Int32 asm_count;
   Int32 cascade_count;
   
   // TaskMonitor cascadesTasksMonitor[CascadesTask::NUMBER_OF_TASK_TYPES];
   TaskMonitor *cascadesTasksMonitor[CascadesTask::NUMBER_OF_TASK_TYPES];
   TaskMonitor *cascadesPassMonitor;
   
   // These monitor were introduced to collect statistics about how
   // much time ScanOptimizer spent in most important functions
   // for costing and how many times those functions were called
   
   // First 3 Monitors collect statistics about fileScanOptimizer.optimize(...)
   // in costmethod. fileScanMonitor gives total statistics, nestedJoinMonitor
   // - inside nested joins, indexJoinMonitor - inside index joins
   
   TaskMonitor     *fileScanMonitor;
   TaskMonitor     *nestedJoinMonitor;
   TaskMonitor     *indexJoinMonitor;
   
   // Next 3 Monitors collect statistics about computeCostForSingleSubset
   // in costmethod. singleSubsetMonitor gives total statistics,
   // singleVectorCostMonitor - inside computeCostVector,
   // singleObjectCostMonitor - inside computeCostObject
   
   TaskMonitor     *singleSubsetCostMonitor;
   TaskMonitor     *singleVectorCostMonitor;
   TaskMonitor     *singleObjectCostMonitor;
   
   // Next 3 Monitors collect statistics about computeCostForMultipleSubset
   // in costmethod. multSubsetMonitor gives total statistics,
   // multVectorCostMonitor - inside computeCostVectorForMultipleSubset,
   // multObjectCostMonitor - inside computeCostObject (only to compute
   // final cost object, cases when computeCostObject is called to compute
   // intermediate cost to check the costBound are not counted).
   
   TaskMonitor     *multSubsetCostMonitor;
   TaskMonitor     *multVectorCostMonitor;
   TaskMonitor     *multObjectCostMonitor;
   
   // This last monitor counts how many times a final cost object was
   // created for asynchronous access for both singleSubset and
   // multipleSubset. This is being counted in computeCostObject
   // function. To ignore all other calls (except final) for
   // computeCostObject synCheckFlag is used. (Inside computeCostFor
   // MultipleSubset computeCOstObject is called many times to
   // check costBound). It is set to TRUE right before the final call,
   // and - to FALSE right after it.
   
   TaskMonitor    *asynchrMonitor;
   NABoolean       synCheckFlag;
   
   // Controls DCMPASSERT delta < 0 for Linux
   NABoolean warningGiven;
   
   // -----------------------------------------------------------------------
   // command line options (initially set in sqlcomp.C)
   // -----------------------------------------------------------------------
   
   NABoolean       pruningIsFeasible;
   NABoolean       maxParIsFeasible;
   NABoolean       forceParallelInsertSelect;

   // Setting this to FALSE makes the optimizer print out statistics
   NABoolean       BeSilent;
   
   // ----------------------------------------------------------------------
   // A  global output string for debugging
   // ----------------------------------------------------------------------
   
   char returnString[500];      // global output string for debugging
   
   // for debugging only
   Int32             group_merge_count;
   Int32             garbage_expr_count;
   Int32             pruned_tasks_count;
   NABoolean         countExpr;

   CascadesMemo     * memo;
   CascadesTaskList * task_list;

private:
 NAHeap* heap_;
};
#endif // OPT_HDR