/**********************************************************************
// @@@ 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 PHYPROP_HDR
#define PHYPROP_HDR
/* -*-C++-*-
**************************************************************************
*
* File:         PhyProp.h
* Description:  Physical Properties and Cost
* Created:      4/10/94
* Language:     C++
*
*
*
*
**************************************************************************
*/

// -----------------------------------------------------------------------
#include "SchemaDB.h"
#include "PartFunc.h"
#include "RelEnforcer.h"
#include "PartReq.h"
#include "RelEnforcer.h"
#include "opt.h"

#include "LookupTable.h"

// -----------------------------------------------------------------------
//  The following classes are defined in this file.
// -----------------------------------------------------------------------
class PhysicalProperty;
class ReqdPhysicalProperty;
class InputPhysicalProperty;
class CurrentFragmentBigMemoryProperty;

// -----------------------------------------------------------------------
// forward references
// -----------------------------------------------------------------------
class GroupAttributes;
class CorrName;
class DP2CostDataThatDependsOnSPP;
class PushDownProperty;
class PushDownRequirement;
namespace tmudr {
  class UDRPlanInfo;
}

// -----------------------------------------------------------------------
// global defines
// -----------------------------------------------------------------------

// see class ReqdPhysicalProperty

#define DEFAULT_LOCATION     EXECUTE_IN_ESP
#define DEFAULT_SINGLETON    1
//#define DEFAULT_DATA_SOURCE  SOURCE_PERSISTENT_TABLE /* not used */


// -----------------------------------------------------------------------
// Physical Properties
// ===================
//
//    Physical properties are those that can be derived from physical
//    expressions.  Thus, these are properties that have a dependency
//    on the physical strategy/algorithm chosen to implement the 
//    query.  
// -----------------------------------------------------------------------

class PhysicalProperty : public NABasicObject
{

public:

  // ---------------------------------------------------------------------
  //  Constructors and destructor
  // ---------------------------------------------------------------------
  PhysicalProperty() 
    : sortOrderType_(NO_SOT),
      dp2SortOrderPartFunc_(NULL),
      actualPartFunc_(NULL), 
      location_(DEFAULT_LOCATION),  
      sourceOfData_(SOURCE_PERSISTENT_TABLE),
      indexDesc_(NULL),
      partSearchKey_(NULL),
      currentCountOfCPUs_(1),
      dp2CostInfo_(NULL),
      udrPlanInfo_(NULL),
      pushDownProperty_(NULL),
      memoryNeedsinCurrentFragment_(NULL),
      explodedOcbJoin_(FALSE),
      accessOnePartition_(FALSE),
      insertedDataIsSorted_(FALSE)
  {}
  
  PhysicalProperty(const ValueIdList &sortKey, 
                   SortOrderTypeEnum sortOrderType,
                   PartitioningFunction* dp2SortOrderPartFunc = NULL,
		   PartitioningFunction * actualPartFunc = NULL,
		   const PlanExecutionEnum plenum = DEFAULT_LOCATION, 
                   const DataSourceEnum dsenum = SOURCE_PERSISTENT_TABLE,
                   const IndexDesc * indexDesc = NULL,
		   const SearchKey * partSearchKey = NULL,
                   const PushDownProperty* pdp = NULL,
				   NABoolean explOcbJoin = FALSE
		   )
    : sortKey_(sortKey),
      sortOrderType_(sortOrderType),
      dp2SortOrderPartFunc_(dp2SortOrderPartFunc),
      actualPartFunc_(actualPartFunc), 
      location_(plenum),  
      sourceOfData_(dsenum),
      indexDesc_(indexDesc),
      partSearchKey_(partSearchKey),
      currentCountOfCPUs_(1),
      dp2CostInfo_(NULL),
      udrPlanInfo_(NULL),
      pushDownProperty_(pdp),
      memoryNeedsinCurrentFragment_(NULL),
      explodedOcbJoin_(explOcbJoin),
      accessOnePartition_(FALSE),
      insertedDataIsSorted_(FALSE)
  {}

  PhysicalProperty(PartitioningFunction * actualPartFunc,
		   const PlanExecutionEnum plenum = DEFAULT_LOCATION, 
		   const DataSourceEnum dsenum = SOURCE_PERSISTENT_TABLE
		   )
    : sortOrderType_(NO_SOT),
      dp2SortOrderPartFunc_(NULL),
      actualPartFunc_(actualPartFunc), 
      location_(plenum),  
      sourceOfData_(dsenum),
      indexDesc_(NULL),
      partSearchKey_(NULL),
      currentCountOfCPUs_(1),
      dp2CostInfo_(NULL),
      udrPlanInfo_(NULL),
      pushDownProperty_(NULL),
      memoryNeedsinCurrentFragment_(NULL),
      explodedOcbJoin_(FALSE),
      accessOnePartition_(FALSE),
      insertedDataIsSorted_(FALSE)
	{}

  PhysicalProperty(const PhysicalProperty &other)
    : sortKey_(other.sortKey_), 
      sortOrderType_(other.sortOrderType_),
      dp2SortOrderPartFunc_(other.dp2SortOrderPartFunc_),
      actualPartFunc_(other.actualPartFunc_), 
      location_(other.location_),  
      sourceOfData_(other.sourceOfData_),
      indexDesc_(other.indexDesc_),
      partSearchKey_(other.partSearchKey_),
      currentCountOfCPUs_(other.currentCountOfCPUs_),
      dp2CostInfo_(other.dp2CostInfo_),
      udrPlanInfo_(other.udrPlanInfo_),
      pushDownProperty_(other.pushDownProperty_),
      memoryNeedsinCurrentFragment_(other.memoryNeedsinCurrentFragment_),
      explodedOcbJoin_(other.explodedOcbJoin_),
      accessOnePartition_(other.accessOnePartition_),
      insertedDataIsSorted_(other.insertedDataIsSorted_)
  {}

  PhysicalProperty(const PhysicalProperty &other,
		   const ValueIdList &sortKey,
                   SortOrderTypeEnum sortOrderType,
                   PartitioningFunction* dp2SortOrderPartFunc 
                  )
    : sortKey_(sortKey), 
      sortOrderType_(sortOrderType),
      dp2SortOrderPartFunc_(dp2SortOrderPartFunc),
      actualPartFunc_(other.actualPartFunc_), 
      location_(other.location_),  
      sourceOfData_(other.sourceOfData_),
      indexDesc_(other.indexDesc_),
      partSearchKey_(other.partSearchKey_),
      currentCountOfCPUs_(other.currentCountOfCPUs_),
      dp2CostInfo_(other.dp2CostInfo_),
      udrPlanInfo_(other.udrPlanInfo_),
      pushDownProperty_(other.pushDownProperty_),
      memoryNeedsinCurrentFragment_(other.memoryNeedsinCurrentFragment_),
      explodedOcbJoin_(other.explodedOcbJoin_),
      accessOnePartition_(other.accessOnePartition_),
      insertedDataIsSorted_(other.insertedDataIsSorted_)
   {}

   PhysicalProperty(const PhysicalProperty &other,
		    const ValueIdList &sortKey,
                    SortOrderTypeEnum sortOrderType,
                    PartitioningFunction* dp2SortOrderPartFunc,
                    DataSourceEnum sourceOfData
                   )
    : sortKey_(sortKey), 
      sortOrderType_(sortOrderType),
      dp2SortOrderPartFunc_(dp2SortOrderPartFunc),
      actualPartFunc_(other.actualPartFunc_), 
      location_(other.location_),  
      sourceOfData_(sourceOfData),
      indexDesc_(other.indexDesc_),
      partSearchKey_(other.partSearchKey_),
      currentCountOfCPUs_(other.currentCountOfCPUs_),
      dp2CostInfo_(other.dp2CostInfo_),
      udrPlanInfo_(other.udrPlanInfo_),
      pushDownProperty_(other.pushDownProperty_),
      memoryNeedsinCurrentFragment_(other.memoryNeedsinCurrentFragment_),
      explodedOcbJoin_(other.explodedOcbJoin_),
      accessOnePartition_(other.accessOnePartition_),
      insertedDataIsSorted_(other.insertedDataIsSorted_)
   {}

  PhysicalProperty(const PhysicalProperty &other,
		   const ValueIdList &sortKey,
                   SortOrderTypeEnum sortOrderType,
                   PartitioningFunction* dp2SortOrderPartFunc,
		   PartitioningFunction* actualPartFunc
                  )
    : sortKey_(sortKey), 
      sortOrderType_(sortOrderType),
      dp2SortOrderPartFunc_(dp2SortOrderPartFunc),
      actualPartFunc_(actualPartFunc), 
      location_(other.location_),  
      sourceOfData_(other.sourceOfData_),
      indexDesc_(other.indexDesc_),
      partSearchKey_(other.partSearchKey_),
      currentCountOfCPUs_(other.currentCountOfCPUs_),
      dp2CostInfo_(other.dp2CostInfo_),
      udrPlanInfo_(other.udrPlanInfo_),
      pushDownProperty_(other.pushDownProperty_),
      memoryNeedsinCurrentFragment_(other.memoryNeedsinCurrentFragment_),
      explodedOcbJoin_(other.explodedOcbJoin_),
      accessOnePartition_(other.accessOnePartition_),
      insertedDataIsSorted_(other.insertedDataIsSorted_)
 
  {}


  virtual ~PhysicalProperty();
  
  // ---------------------------------------------------------------------
  // Accessor/Mutator functions
  // ---------------------------------------------------------------------

   const NABoolean getexplodedOcbJoinProperty() const
      { return explodedOcbJoin_; }

  // For determining if the partitioning key is a prefix of the
  // sort key (i.e. the clustering key) 
  NABoolean isPartKeyPrefixOfSortKey() const;

  // --- For sort key
  inline NABoolean isSorted() const   { return (sortKey_.entries() > 0); }
  inline const ValueIdList & getSortKey() const       { return sortKey_; }

  // accessors 
  inline SortOrderTypeEnum getSortOrderType() const
  { return sortOrderType_; }
  inline PartitioningFunction* getDp2SortOrderPartFunc() const
  { return dp2SortOrderPartFunc_; }

  // mutators
  void setSortOrderType(SortOrderTypeEnum sortOrderType)
  { 
    // Check that the synthesized sort order type is within the
    // allowable range for a synthesized sort order type.
    DCMPASSERT((sortOrderType >= NO_SOT) AND
               (sortOrderType <= DP2_SOT))
    sortOrderType_ = sortOrderType;
  }
  void setDp2SortOrderPartFunc(
                     PartitioningFunction* dp2SortOrderPartFunc)
  { dp2SortOrderPartFunc_ = dp2SortOrderPartFunc; }

  void setLocation(PlanExecutionEnum location)
  {location_ = location;}

  // --- For partitioning function
  inline NABoolean isPartitioned() const
  { return (actualPartFunc_ AND actualPartFunc_->getCountOfPartitions() > 1); }

  inline void scaleNumberOfPartitions(Lng32 npartns)
   { 
     if ( actualPartFunc_ )
        actualPartFunc_ = actualPartFunc_->scaleNumberOfPartitions(npartns); 
   }; 

  inline PartitioningFunction * getPartitioningFunction() const 
                                               { return actualPartFunc_; }
  inline Lng32 getCountOfPartitions() const
  {
    if (actualPartFunc_)
      return actualPartFunc_->getCountOfPartitions();
    else
      return 1;
  }

  // --- Read-only access to the partitioning key.
  inline const ValueIdSet & getPartitioningKey() const
                        { return  actualPartFunc_->getPartitioningKey(); }

  // --- For plan execution
  inline NABoolean executeInMasterOrESP() const 
                       { return (location_ == EXECUTE_IN_MASTER_OR_ESP); }
  inline NABoolean executeInMasterOnly() const 
                              { return (location_ == EXECUTE_IN_MASTER); }
  inline NABoolean executeInESPOnly() const 
                                 { return (location_ == EXECUTE_IN_ESP); }
  inline NABoolean executeInDP2() const 
                                 { return (location_ == EXECUTE_IN_DP2); }
  inline PlanExecutionEnum getPlanExecutionLocation() const
                                                     { return location_; }

  // -- For the source of the data
  inline DataSourceEnum getDataSourceEnum() const
                                                 { return sourceOfData_; }
  inline void setDataSourceEnum(DataSourceEnum s)
                                                    { sourceOfData_ = s; }

  // -- Accessor for the table descriptor
  inline const IndexDesc * getIndexDesc() const     { return indexDesc_; }
  inline void  setIndexDesc(const IndexDesc * val)   { indexDesc_ = val; }

  // -- Accessor and Mutator for the partition search key (part. key predicates)
  inline const SearchKey * getPartSearchKey() const
                                                { return partSearchKey_; }
  inline void setPartSearchKey(const SearchKey* partSearchKey)
                                       { partSearchKey_ = partSearchKey; }

  // -- Accessor and Mutator for cpuCountInDP2_.
  inline Lng32 getCurrentCountOfCPUs() const    { return currentCountOfCPUs_; }
  inline void setCurrentCountOfCPUs(const Lng32 value)
                                            { currentCountOfCPUs_ = value; }
				      
  // ---------------------------------------------------------------------
  // comparison functions (A > B means that A delivers all the
  // physical properties that B has plus some more).
  // ---------------------------------------------------------------------
  inline NABoolean operator > (const PhysicalProperty &other) const
                              { return compareProperties(other) == MORE; }
  inline NABoolean operator < (const PhysicalProperty &other) const
                              { return compareProperties(other) == LESS; }
  inline NABoolean operator == (const PhysicalProperty &other) const
                              { return compareProperties(other) == SAME; }

  // -----------------------------------------------------------------------
  // For costing data that gets computed at synthesis time:
  // -----------------------------------------------------------------------
  const DP2CostDataThatDependsOnSPP * getDP2CostThatDependsOnSPP() const
  { return dp2CostInfo_; }
  
  void setDP2CostThatDependsOnSPP(DP2CostDataThatDependsOnSPP * dp2Cost)
  { dp2CostInfo_ = dp2Cost; }

  // for UDRs (only to transfer this info to the code generator)
  tmudr::UDRPlanInfo *getUDRPlanInfo() const      { return udrPlanInfo_; }
  void setUDRPlanInfo(tmudr::UDRPlanInfo *pi)       { udrPlanInfo_ = pi; }
  
  // -----------------------------------------------------------------------
  // Make sure that all members are covered by the group attributes!
  //
  // Currently, we only check the sort key.  Someday we may check other
  // fields, such as the partitioning function.
  // -----------------------------------------------------------------------
  void enforceCoverageByGroupAttributes (const GroupAttributes * groupAttr) ;

  // ---------------------------------------------------------------------
  //  Utility functions
  // ---------------------------------------------------------------------
  void print(FILE* ofd = stdout,
	     const char * prefix = DEFAULT_INDENT,
             const char * suffix = "") const;

 
  void setPushDownProperty(const PushDownProperty* pdp) 
 	{ pushDownProperty_ = pdp; };
  const PushDownProperty* getPushDownProperty() const
	{ return pushDownProperty_; } ;

  void setBigMemoryEstimationProperty( CurrentFragmentBigMemoryProperty *c)
       { memoryNeedsinCurrentFragment_ = c;}

  const CurrentFragmentBigMemoryProperty * getBigMemoryEstimationProperty()
       { return memoryNeedsinCurrentFragment_; }

  void setAccessOnePartition(NABoolean x) { accessOnePartition_ = x; } ;
  NABoolean getAccessOnePartition() const { return accessOnePartition_; } ;

  void setInsertedDataIsSorted(NABoolean x) { insertedDataIsSorted_ = x; } ;
  NABoolean getInsertedDataIsSorted() const { return insertedDataIsSorted_; } ;

private:
  // ---------------------------------------------------------------------
  // Method for comparing two Physical property vectors.
  // ---------------------------------------------------------------------
  COMPARE_RESULT compareProperties(const PhysicalProperty & other) const;

  // ---------------------------------------------------------------------
  // Information about the order of the result rows
  // ---------------------------------------------------------------------
  ValueIdList  sortKey_;       // sorted by the specified cols/expressions

  // ---------------------------------------------------------------------
  // The type of sort order: NO_SOT, ESP_NO_SORT_SOT,
  // ESP_VIA_SORT_SOT, DP2_SOT
  // ---------------------------------------------------------------------
  SortOrderTypeEnum sortOrderType_;
  
  // ---------------------------------------------------------------------
  // The physical partitioning function of the access path that generated
  // the sort order. NULL if no sort order or if the sort order type is
  // not DP2.
  // ---------------------------------------------------------------------
  PartitioningFunction* dp2SortOrderPartFunc_;

  // ---------------------------------------------------------------------
  // The partitioning function encapsulates data parallelism.
  // When a plan fragment executes within DP2 the degree of operator
  // parallelism is equal to the number of partitions, i.e., the degree 
  // of data parallelism. In contrast, when a plan fragement executes
  // in ESP, the number of data streams, i.e., partitions, are expected
  // to be equal to the number of operator instances that are expected
  // to execute in parallel.
  // ---------------------------------------------------------------------
  PartitioningFunction * actualPartFunc_; 
  
  // ---------------------------------------------------------------------
  // Information about where the plan, or plan fragment, should be 
  // executed.
  // ---------------------------------------------------------------------
  PlanExecutionEnum  location_;
  
  // ---------------------------------------------------------------------
  // The source for the data, persistent table, temporary table or esp.
  // ---------------------------------------------------------------------
  DataSourceEnum  sourceOfData_;
  
  // ---------------------------------------------------------------------
  // The index which is the source of data. It points
  // to a table name only when sourceIsAPersistentTable() is TRUE.
  // Otherwise it is NULL.
  // This information is preserved until the first Exchange operator 
  // is reached.
  // ---------------------------------------------------------------------
  const IndexDesc * indexDesc_;

  // ---------------------------------------------------------------------
  // The search key to be used to determine partitions for indexDesc_.
  // This search key contains artificial predicates, designed to split
  // data into different streams when an operator is executed in parallel,
  // and any other predicates that may restrict the partititions used.
  // All predicates in partSearchKey_ have to be covered by the
  // characteristic inputs of the RelExpr that carries this object.
  // ---------------------------------------------------------------------
  const SearchKey * partSearchKey_;

  // ---------------------------------------------------------------------
  // No of CPU used if the operator executes in DP2. Meaningless if the
  // operator doesn't executes in DP2. This is for informational purpose
  // only. Should not be used to determine whether some ReqdPhysProperty
  // are satisfied.
  // ---------------------------------------------------------------------
  // $$$ This member should be moved to class
  // $$$ DP2CostDataThatDependsOnSPP!!!!
  Lng32 currentCountOfCPUs_;

  // -----------------------------------------------------------------------
  // The following class should contain all costing data for dp2
  // operators that gets computed at synthesis time:
  // -----------------------------------------------------------------------

  DP2CostDataThatDependsOnSPP * dp2CostInfo_;
  tmudr::UDRPlanInfo *udrPlanInfo_;

  const PushDownProperty* pushDownProperty_;

  CurrentFragmentBigMemoryProperty *memoryNeedsinCurrentFragment_;
  NABoolean explodedOcbJoin_;

  NABoolean accessOnePartition_;

  // set in DP2Insert::synthPhysicalProperty.
  // Indicates if the data to be inserted is sorted.
  NABoolean insertedDataIsSorted_;
}; // PhysicalProperty

// -----------------------------------------------------------------------
// Performance goals
//
// Optimize for N rows
//   Choose a plan that offers the lowest cost for returning the 
//   first N rows.
//
// Optimize for first row
//   Choose a plan that offers that offers the lowest first row cost
//
// Optimize for last row
//   Choose a plan that offers that offers the lowest last row cost
//
// Optimize for resource consumption
//   Choose a plan that offers that offers the lowest total cost
//
// -----------------------------------------------------------------------
class PerformanceGoal
{
public:
  virtual ~PerformanceGoal();
  
  virtual NABoolean isOptimizeForFirstRow() const;

  virtual NABoolean isOptimizeForLastRow() const;

  virtual NABoolean isOptimizeForResourceConsumption() const;

private:
}; // class PerformanceGoal

// -- Optimize for N rows
class OptimizeForNRows : public PerformanceGoal
{
public:
  OptimizeForNRows(Lng32 numberOfRows) : rowCount_(numberOfRows) 
                                            { assert(numberOfRows > 0); }
  virtual ~OptimizeForNRows() {}

  virtual NABoolean isOptimizeForFirstRow() const;
  
private:  
  Lng32 rowCount_;
}; // class OptimizeForNRows

// -- Optimize for first row - not used in SQ
class OptimizeForFirstRow : public OptimizeForNRows
{
public:
  OptimizeForFirstRow() : OptimizeForNRows(1)                          { }

  virtual ~OptimizeForFirstRow() {}

}; // class OptimizeForFirstRow

// -- Optimize for last row
class OptimizeForLastRow : public OptimizeForNRows
{
public:
  OptimizeForLastRow() : OptimizeForNRows(INT_MAX)                    { }
  
  virtual ~OptimizeForLastRow() {}

  virtual NABoolean isOptimizeForLastRow() const;
  virtual NABoolean isOptimizeForFirstRow() const;

}; // class OptimizeForLastRow

// -- Optimize for resource consumption - not used in SQ
class OptimizeForResourceConsumption : public PerformanceGoal
{
public:
  virtual ~OptimizeForResourceConsumption() {}

  virtual NABoolean isOptimizeForResourceConsumption() const;

}; // class OptimizeForResourceConsumption


// -----------------------------------------------------------------------
// Required physical properties
// -----------------------------------------------------------------------

class ReqdPhysicalProperty  : public NABasicObject
{

public:

  // ---------------------------------------------------------------------
  //  Constructor, copy constructor, destructor, and assignment operator
  // ---------------------------------------------------------------------

  ReqdPhysicalProperty(
           const ValueIdSet* const arrangedBy = NULL,
           const ValueIdList* const orderedBy = NULL,
           SortOrderTypeEnum sortOrderTypeReq = NO_SOT,
           PartitioningRequirement* dp2SortOrderPartReq = NULL,
           const NABoolean logicalOrderOrArrangement = FALSE,
           PartitioningRequirement* partReq = NULL,
           LogicalPartitioningRequirement* logicalPartReq = NULL,
           const PlanExecutionEnum location = DEFAULT_LOCATION,
           const Lng32 availableCPUs = DEFAULT_SINGLETON,
           const Lng32 pipelinesPerCPU = DEFAULT_SINGLETON,
           const CostWeight* const costWeight = CURRSTMT_OPTDEFAULTS->getDefaultCostWeight(),
           const PerformanceGoal* const perfGoal = CURRSTMT_OPTDEFAULTS->getDefaultPerformanceGoal(),
           RelExpr* mustMatch = NULL,
	   PushDownRequirement* pdp = NULL
  )
    : arrangedBy_(arrangedBy), orderedBy_(orderedBy),
      sortOrderTypeReq_(sortOrderTypeReq),
      dp2SortOrderPartReq_(dp2SortOrderPartReq),
      logicalOrderOrArrangement_(logicalOrderOrArrangement),
      partReq_(partReq),
      logicalPartReq_(logicalPartReq),
      location_(location),
      availableCPUs_(availableCPUs),
      pipelinesPerCPU_(pipelinesPerCPU),
      costWeight_(costWeight),
      perfGoal_(perfGoal),
      mustMatch_(mustMatch),
      pushDownRequirement_(pdp),
      noEspExchangeRequirement_(FALSE),
	  ocbEnabledCostingRequirement_(FALSE)
  {
#ifndef NDEBUG
    performConsistencyCheck();
#endif
  }

  // ---------------------------------------------------------------------
  // NOTE: mustMatch_ is not propagated from one reqd prop to another
  // ---------------------------------------------------------------------
  inline ReqdPhysicalProperty(const ReqdPhysicalProperty& other)
    : arrangedBy_(other.arrangedBy_), orderedBy_(other.orderedBy_), 
      sortOrderTypeReq_(other.sortOrderTypeReq_),
      dp2SortOrderPartReq_(other.dp2SortOrderPartReq_),
      logicalOrderOrArrangement_(other.logicalOrderOrArrangement_),
      partReq_(other.partReq_), 
      logicalPartReq_(other.logicalPartReq_),
      location_(other.location_),
      availableCPUs_(other.availableCPUs_), 
      pipelinesPerCPU_(other.pipelinesPerCPU_),
      costWeight_(other.costWeight_),
      perfGoal_(other.perfGoal_),
      mustMatch_(NULL),
      pushDownRequirement_(other.pushDownRequirement_),
      noEspExchangeRequirement_(other.noEspExchangeRequirement_),
	  ocbEnabledCostingRequirement_(other.ocbEnabledCostingRequirement_)
  {
#ifndef NDEBUG
    performConsistencyCheck();
#endif
  }

  // ---------------------------------------------------------------------
  // NOTE: mustMatch_ is not propagated from one reqd prop to another
  // ---------------------------------------------------------------------
  inline ReqdPhysicalProperty(const ReqdPhysicalProperty& other,
                  const ValueIdSet* const arrangedBy,
                  const ValueIdList* const orderedBy,
                  SortOrderTypeEnum sortOrderTypeReq,
                  PartitioningRequirement* dp2SortOrderPartReq
                             )
    : arrangedBy_(arrangedBy), orderedBy_(orderedBy), 
      sortOrderTypeReq_(sortOrderTypeReq),
      dp2SortOrderPartReq_(dp2SortOrderPartReq),
      logicalOrderOrArrangement_(other.logicalOrderOrArrangement_),
      partReq_(other.partReq_), 
      logicalPartReq_(other.logicalPartReq_),
      location_(other.location_),
      availableCPUs_(other.availableCPUs_), 
      pipelinesPerCPU_(other.pipelinesPerCPU_),
      costWeight_(other.costWeight_),
      perfGoal_(other.perfGoal_),
      mustMatch_(NULL),
      pushDownRequirement_(other.pushDownRequirement_),
      noEspExchangeRequirement_(other.noEspExchangeRequirement_),
	  ocbEnabledCostingRequirement_(other.ocbEnabledCostingRequirement_)
  {
#ifndef NDEBUG
    performConsistencyCheck();
#endif
  }

  // ---------------------------------------------------------------------
  // NOTE: mustMatch_ is not propagated from one reqd prop to another
  // NOTE: The logicalPartitionBoundariesFlag_ is not propagated from one
  // NOTE: required property to another when the partitioning requirement
  // NOTE: is changed
  // ---------------------------------------------------------------------
  ReqdPhysicalProperty(const ReqdPhysicalProperty& other,
                  const ValueIdSet* const arrangedBy,
                  const ValueIdList* const orderedBy,
                  SortOrderTypeEnum sortOrderTypeReq,
                  PartitioningRequirement* dp2SortOrderPartReq,
                  PartitioningRequirement* partReq
			     )
    : arrangedBy_(arrangedBy), orderedBy_(orderedBy), 
      sortOrderTypeReq_(sortOrderTypeReq),
      dp2SortOrderPartReq_(dp2SortOrderPartReq),
      logicalOrderOrArrangement_(other.logicalOrderOrArrangement_),
      partReq_(partReq), 
      logicalPartReq_(other.logicalPartReq_),
      location_(other.location_),
      availableCPUs_(other.availableCPUs_), 
      pipelinesPerCPU_(other.pipelinesPerCPU_),
      costWeight_(other.costWeight_),
      perfGoal_(other.perfGoal_),
      mustMatch_(NULL),
      pushDownRequirement_(other.pushDownRequirement_),
      noEspExchangeRequirement_(other.noEspExchangeRequirement_),
	  ocbEnabledCostingRequirement_(other.ocbEnabledCostingRequirement_)
  {
#ifndef NDEBUG
    performConsistencyCheck();
#endif
  }

  // ---------------------------------------------------------------------
  // NOTE: mustMatch_ is not propagated from one reqd prop to another
  // NOTE: The logicalPartitionBoundariesFlag_ is not propagated from one
  // NOTE: required property to another when the partitioning requirement
  // NOTE: is changed
  // ---------------------------------------------------------------------
  ReqdPhysicalProperty(const ReqdPhysicalProperty &other,
                  const ValueIdSet* const arrangedBy,
                  const ValueIdList* const orderedBy,
                  SortOrderTypeEnum sortOrderTypeReq,
                  PartitioningRequirement* dp2SortOrderPartReq,
                  PartitioningRequirement* partReq,
                  const PlanExecutionEnum location
			     )
    : arrangedBy_(arrangedBy), orderedBy_(orderedBy), 
      sortOrderTypeReq_(sortOrderTypeReq),
      dp2SortOrderPartReq_(dp2SortOrderPartReq),
      logicalOrderOrArrangement_(other.logicalOrderOrArrangement_),
      partReq_(partReq), 
      logicalPartReq_(other.logicalPartReq_),
      location_(location),
      availableCPUs_(other.availableCPUs_), 
      pipelinesPerCPU_(other.pipelinesPerCPU_),
      costWeight_(other.costWeight_),
      perfGoal_(other.perfGoal_),
      mustMatch_(NULL),
      pushDownRequirement_(other.pushDownRequirement_),
      noEspExchangeRequirement_(other.noEspExchangeRequirement_),
	  ocbEnabledCostingRequirement_(other.ocbEnabledCostingRequirement_)
  {
#ifndef NDEBUG
    performConsistencyCheck();
#endif
  }

  // ---------------------------------------------------------------------
  // NOTE: mustMatch_ is not propagated from one reqd prop to another
  // NOTE: The logicalPartitionBoundariesFlag_ is not propagated from one
  // NOTE: required property to another when the partitioning requirement
  // NOTE: is changed
  // ---------------------------------------------------------------------
  ReqdPhysicalProperty(const ReqdPhysicalProperty &other,
                  const ValueIdSet* const arrangedBy,
                  const ValueIdList* const orderedBy,
                  SortOrderTypeEnum sortOrderTypeReq,
                  PartitioningRequirement* dp2SortOrderPartReq,
                  PartitioningRequirement* partReq,
                  const PlanExecutionEnum location,
                  const Lng32 availableCPUs,
                  const Lng32 pipelinesPerCPU
			     )
    : arrangedBy_(arrangedBy), orderedBy_(orderedBy), 
      sortOrderTypeReq_(sortOrderTypeReq),
      dp2SortOrderPartReq_(dp2SortOrderPartReq),
      logicalOrderOrArrangement_(other.logicalOrderOrArrangement_),
      partReq_(partReq), 
      logicalPartReq_(other.logicalPartReq_),
      location_(location),
      availableCPUs_(availableCPUs), 
      pipelinesPerCPU_(pipelinesPerCPU),
      costWeight_(other.costWeight_),
      perfGoal_(other.perfGoal_),
      mustMatch_(NULL),
      pushDownRequirement_(other.pushDownRequirement_),
      noEspExchangeRequirement_(other.noEspExchangeRequirement_),
	  ocbEnabledCostingRequirement_(other.ocbEnabledCostingRequirement_)
  {
#ifndef NDEBUG
    performConsistencyCheck();
#endif
  }

  // create an empty requirement with only a must match in it
  ReqdPhysicalProperty(RelExpr* mustMatch)
    : arrangedBy_(NULL), orderedBy_(NULL),
      sortOrderTypeReq_(NO_SOT),
      dp2SortOrderPartReq_(NULL),
      logicalOrderOrArrangement_(FALSE),
      partReq_(NULL),
      logicalPartReq_(NULL),
      location_(DEFAULT_LOCATION),
      availableCPUs_(DEFAULT_SINGLETON),
      pipelinesPerCPU_(DEFAULT_SINGLETON),
      perfGoal_(CURRSTMT_OPTDEFAULTS->getDefaultPerformanceGoal()),
      costWeight_(CURRSTMT_OPTDEFAULTS->getDefaultCostWeight()),
      mustMatch_(mustMatch),
      pushDownRequirement_(NULL),
      noEspExchangeRequirement_(FALSE),
	  ocbEnabledCostingRequirement_(FALSE)
  {
#ifndef NDEBUG
    performConsistencyCheck();
#endif
  } 

  // ---------------------------------------------------------------------
  // NOTE: mustMatch_ is not propagated from one reqd prop to another
  // NOTE: This constructor is only used to change the "must match" 
  //       attribute of an operator's rpp. This constructor is never
  //       used when creating a new rpp for a child.
  // ---------------------------------------------------------------------
  ReqdPhysicalProperty(const ReqdPhysicalProperty& other,
                              RelExpr* mustMatch
                             )
    : arrangedBy_(other.arrangedBy_), orderedBy_(other.orderedBy_), 
      sortOrderTypeReq_(other.sortOrderTypeReq_),
      dp2SortOrderPartReq_(other.dp2SortOrderPartReq_),
      logicalOrderOrArrangement_(other.logicalOrderOrArrangement_),
      partReq_(other.partReq_), 
      logicalPartReq_(other.logicalPartReq_),
      location_(other.location_),
      availableCPUs_(other.availableCPUs_), 
      pipelinesPerCPU_(other.pipelinesPerCPU_),
      costWeight_(other.costWeight_),
      perfGoal_(other.perfGoal_),
      mustMatch_(mustMatch),
      pushDownRequirement_(other.pushDownRequirement_),
      noEspExchangeRequirement_(other.noEspExchangeRequirement_),
	  ocbEnabledCostingRequirement_(other.ocbEnabledCostingRequirement_)
  {
#ifndef NDEBUG
    performConsistencyCheck();
#endif
  }

  virtual ~ReqdPhysicalProperty();

  // --------------------------------------------------------------------
  // does a given plan satisfy the required property
  // ---------------------------------------------------------------------
  NABoolean satisfied(EstLogPropSharedPtr inputLogProp,
                      const RelExpr * const physExpr,
		      const PhysicalProperty * const physProp) const;

  // ---------------------------------------------------------------------
  // Comparison functions between two required phys. properties
  //
  // Return:
  //
  // LESS          if "this" required physical property requires LESS
  //               than the "other" required property
  // SAME          if both properties require the SAME props
  // MORE          if "this" required physical property requires MORE
  //               than the "other" required property
  // INCOMPATIBLE  if the properties are incompatible (A and B are incom-
  //               patible => no physical property exists that satisfies
  //               both A and B or the two contexts have incompatible
  //               optimization goals, such as optimization for n rows
  //               or statistics for input values)
  // UNDEFINED     can't tell which requires more or less (properties may
  //               in some subtle cases still be incompatible)
  // ---------------------------------------------------------------------
  COMPARE_RESULT compareRequirements(const ReqdPhysicalProperty & other) const;

  // ---------------------------------------------------------------------
  // Accessor/Mutator functions
  // ---------------------------------------------------------------------

  // ---------------------------------------------------------------------
  // Check whether any requirements are specified at all.
  // ---------------------------------------------------------------------
  NABoolean isEmpty() const;

  // ---------------------------------------------------------------------
  // User-specified cost weight.
  // ---------------------------------------------------------------------
  inline const CostWeight* getCostWeight() const { return costWeight_; }

  // ---------------------------------------------------------------------
  // User-specified performance goal.
  // ---------------------------------------------------------------------
  inline const PerformanceGoal* getPerformanceGoal() const
                                                     { return perfGoal_; }
  // ---------------------------------------------------------------------
  // Requirements related to imposing an order on the result.
  // ---------------------------------------------------------------------
  inline const ValueIdSet * getArrangedCols() const { return arrangedBy_; }
  inline const ValueIdList * getSortKey() const     { return orderedBy_; }
  static void initSortOrderTypeCompTab();
  static void initSortOrderTypeContextCompTab();

  //accessors  
  SortOrderTypeEnum getSortOrderTypeReq() const
  { return sortOrderTypeReq_; }
  PartitioningRequirement* getDp2SortOrderPartReq() const
  { return dp2SortOrderPartReq_; }

  
  // mutators
  void setSortOrderTypeReq (SortOrderTypeEnum sortOrderTypeReq)
  { 
    // Check that the required sort order type is within the
    // allowable range for a required sort order type.
    DCMPASSERT((sortOrderTypeReq >= NO_SOT) AND
               (sortOrderTypeReq <= DP2_OR_ESP_NO_SORT_SOT))
    sortOrderTypeReq_ = sortOrderTypeReq;
  }
  void setDp2SortOrderPartReq 
         (PartitioningRequirement* dp2SortOrderPartReq)
  { dp2SortOrderPartReq_ = dp2SortOrderPartReq; }

  NABoolean sortOrderTypeReqAndSynthCompatible
              (const SortOrderTypeEnum synthesizedSortOrderType) const;
  COMPARE_RESULT compareSortOrderTypeReqToReq
              (const SortOrderTypeEnum otherSortOrderTypeReq) const;
  NABoolean dp2SortOrderPartReqAndSynthCompatible
              (const PhysicalProperty* const spp) const;

  inline NABoolean getLogicalOrderOrArrangementFlag() const
                                    { return logicalOrderOrArrangement_; }
  inline void setLogicalOrderOrArrangementFlag(const NABoolean newValue)
                                { logicalOrderOrArrangement_ = newValue; }


  // ---------------------------------------------------------------------
  // Location for plan execution
  // ---------------------------------------------------------------------
  PlanExecutionEnum getPlanExecutionLocation() const
                                                     { return location_; }
  NABoolean executeInDP2() const { return (location_ == EXECUTE_IN_DP2); }

  // ---------------------------------------------------------------------
  // The number of pipelines that can be formed for executing a
  // plan fragment in parallel without (outside of) a DP2.
  // ---------------------------------------------------------------------
  inline Lng32 getCountOfPipelines() const
                             { return availableCPUs_ * pipelinesPerCPU_; }
  inline Lng32 getCountOfAvailableCPUs() const   { return availableCPUs_; }

  // ---------------------------------------------------------------------
  // The partitions, i.e., the number of data streams that should
  // be produced. This is specifed by means of a partitioning requirement.
  // ---------------------------------------------------------------------
  inline NABoolean requiresPartitioning() const 
                                           { return (partReq_ != NULL); }

  inline PartitioningRequirement * getPartitioningRequirement() const 
                                                     { return partReq_; }
  Lng32 getCountOfPartitions() const
                             { return partReq_->getCountOfPartitions(); }

  // --- Read-only access to the partitioning key.
  inline const ValueIdSet & getPartitioningKey() const
                              { return  partReq_->getPartitioningKey(); }

  // ---------------------------------------------------------------------
  // logical partitioning requirement for DP2 fragments
  // ---------------------------------------------------------------------
  LogicalPartitioningRequirement * getLogicalPartRequirement() const
                                               { return logicalPartReq_; }
  void setLogicalPartRequirement(LogicalPartitioningRequirement *lpr)
                                                { logicalPartReq_ = lpr; }

  // ---------------------------------------------------------------------
  // A pattern supplied for enforcing a certain shape on the query
  // tree of the plan.
  // ---------------------------------------------------------------------
  inline const RelExpr * getMustMatch() const       { return mustMatch_; }

  RelExpr* getInputMustMatch(Lng32 childIndex) const;


  void setPushDownRequirement(const PushDownRequirement* pdp) 
 	{ pushDownRequirement_ = pdp; };
  const PushDownRequirement* getPushDownRequirement() const
	{ return pushDownRequirement_ ; } ;
  NABoolean getNoEspExchangeRequirement() const
        { return noEspExchangeRequirement_; } ;
  void setNoEspExchangeRequirement(const NABoolean b)
       { noEspExchangeRequirement_ = b; };
  NABoolean getOcbEnabledCostingRequirement() const
        { return ocbEnabledCostingRequirement_; } ;
  void setOcbEnabledCostingRequirement(const NABoolean b)
       { ocbEnabledCostingRequirement_ = b; };
  // ---------------------------------------------------------------------
  //  Utility functions
  // ---------------------------------------------------------------------
  void print(FILE* ofd = stdout,
	     const char * prefix = DEFAULT_INDENT,
             const char * suffix = "") const;

private:

  // ---------------------------------------------------------------------
  // PRIVATE METHODS
  // ---------------------------------------------------------------------
  void performConsistencyCheck() const
  { 
    DCMPASSERT((availableCPUs_ > 0) AND 
               (pipelinesPerCPU_ > 0) AND
               (costWeight_ != NULL) AND 
               (perfGoal_ != NULL) );

#ifndef NDEBUG
    performSortOrderTypeConsistencyCheck();
#endif
  }

  void performSortOrderTypeConsistencyCheck() const
  {
    if ((arrangedBy_ == NULL) AND (orderedBy_ == NULL))
    {
      DCMPASSERT(sortOrderTypeReq_ == NO_SOT);
      DCMPASSERT(dp2SortOrderPartReq_ == NULL);
    }
    else
    {
      DCMPASSERT((sortOrderTypeReq_ != NO_SOT) OR
                 (location_ == EXECUTE_IN_DP2));
    }

    if ((dp2SortOrderPartReq_ != NULL) OR
        (sortOrderTypeReq_ == DP2_OR_ESP_NO_SORT_SOT) OR
        (sortOrderTypeReq_ == DP2_SOT))
    {
      DCMPASSERT(dp2SortOrderPartReq_ != NULL);
      DCMPASSERT((location_ == EXECUTE_IN_DP2 AND sortOrderTypeReq_ == NO_SOT) OR (sortOrderTypeReq_ == DP2_OR_ESP_NO_SORT_SOT) OR
                 (sortOrderTypeReq_ == DP2_SOT));
    }
  } // performSortOrderTypeConsistencyCheck()

  // ---------------------------------------------------------------------
  // PRIVATE DATA
  // ---------------------------------------------------------------------
  static THREAD_P LookupTable<NABoolean>* sortOrderTypeCompTab_;
  static THREAD_P LookupTable<COMPARE_RESULT>* sortOrderTypeContextCompTab_;

  const CostWeight* const costWeight_;    // weight used for comparing costs

  const PerformanceGoal* const perfGoal_; // the performance goal

  // ---------------------------------------------------------------------
  // The output rows are required to be "arranged" such that they are
  // sorted and the set of "arrangedBy_" values forms a prefix of the
  // sort key.
  // ---------------------------------------------------------------------
  const ValueIdSet* const arrangedBy_;

  // ---------------------------------------------------------------------
  // The output rows are required to be ordered by the given columns.
  // ---------------------------------------------------------------------
  const ValueIdList* const orderedBy_;

  // ---------------------------------------------------------------------
  // The type of sorted order needed: NO_SOT, ESP_NO_SORT_SOT, 
  // ESP_VIA_SORT_SOT, DP2_SOT, ESP_SOT, DP2_OR_ESP_NO_SORT_SOT
  // ---------------------------------------------------------------------
  SortOrderTypeEnum sortOrderTypeReq_;

  // ---------------------------------------------------------------------
  // The required physical partitioning for a sort order type of DP2 to
  // be valid.
  // ---------------------------------------------------------------------
  PartitioningRequirement* dp2SortOrderPartReq_;

  // ---------------------------------------------------------------------
  // Indicates whether any required order or arrangement is a logical one.
  // This flag will be TRUE if the current location is DP2, and there is
  // a required order or arrangement that came from an operator that is
  // not in DP2. A logical order or arrangement requirement has 
  // different rules as to whether the spp satisfies it. See the     
  // "satisfied" method for details.
  // ---------------------------------------------------------------------
  NABoolean logicalOrderOrArrangement_;

  // ---------------------------------------------------------------------
  // The number of instances of a plan fragment that shall execute
  // concurrently, in parallel.
  // ---------------------------------------------------------------------
  const Lng32 availableCPUs_;
  const Lng32 pipelinesPerCPU_;

  // ---------------------------------------------------------------------
  // Specification of the location where the plan must execute.
  // ---------------------------------------------------------------------
  const PlanExecutionEnum location_;

  // ---------------------------------------------------------------------
  // The partition requirement describes the characteristics of the 
  // data streams that are to be produced as output by using a 
  // built-in (system-defined) partitioning requirement. The destination
  // for the data streams could either be a partitioned file set or 
  // even be a set of ESP's. The absence of a partitioning requirement
  // implies that a single output stream must be produced.
  //
  // partReq_->getCountOfPartitions() specifies the number
  // of data streams that must be produced as output. The distribution
  // of rows amongst these data streams is dependant upon information
  // contained in the partitioning requirement.
  //
  // partReq_->getPartitioningKey() yields a set of expressions that 
  // form the partitioning key. The application of the partitioning
  // function to the values contained in the partitioning key columns 
  // decides the data stream (partition number) to which a certain row
  // is assigned.
  // ---------------------------------------------------------------------
  PartitioningRequirement* partReq_;

  // ---------------------------------------------------------------------
  // The logical partitioning requirement applies to contexts that
  // execute in DP2. In this case, logicalPartReq_ describes the
  // requirements of the PA or PAPA exchange above. This helps the
  // DP2 leaf node (scan, insert, update, delete) to perform "logical
  // partitioning", meaning to deal with the fact that multiple PAs or
  // ESPs will share the work for the operation.
  // ---------------------------------------------------------------------
  LogicalPartitioningRequirement *logicalPartReq_;
       
  // ---------------------------------------------------------------------
  // Requirement for matching a given tree shape
  // ---------------------------------------------------------------------
  RelExpr* mustMatch_;

  // PushDown requirement, if any.
  const PushDownRequirement* pushDownRequirement_;

  NABoolean noEspExchangeRequirement_;
  NABoolean ocbEnabledCostingRequirement_;

}; // ReqdPhysicalProperty

// this class collects fragment-wise memory related information
class CurrentFragmentBigMemoryProperty : public NABasicObject
{
public:
   CurrentFragmentBigMemoryProperty():
    currentFileSize_(0),
    cumulativeFileSizeofFragment_(0),
    noBigMemOpsSoFar_(0),
    Op_(NO_OPERATOR_TYPE)
   {};
   virtual ~CurrentFragmentBigMemoryProperty() {};

   void setCurrentFileSize(double d)
    { currentFileSize_=d;
      cumulativeFileSizeofFragment_=d;}

   double getCumulativeFileSize() 
   { return cumulativeFileSizeofFragment_; }

   void incrementCumulativeMemSize(double d)
   { cumulativeFileSizeofFragment_+=d;}

   void setOperatorType(OperatorTypeEnum op)
    { Op_ = op;}

private:
   double currentFileSize_;
   double cumulativeFileSizeofFragment_;
   Int32    noBigMemOpsSoFar_;
   OperatorTypeEnum    Op_;
};


// required push down property

class PushDownCSProperty;
class PushDownColocationProperty;

//
// PushDown property abstract class, which defines the interface
// for producing push-down property and generating push-down 
// requirement. 
//
class PushDownProperty : public NABasicObject
{

public:
   PushDownProperty() {};
   virtual ~PushDownProperty() {};

   // is this propery fully specified?
   virtual NABoolean isEmpty() const = 0;

   // generating a requirement from a propery.
   // used by various createContextForAChild() to echo the
   // requirement to the right child, given the push-down
   // property from the left child.
   virtual const PushDownRequirement* makeRequirement() const = 0;

   // dynamic type checking help function for PushDownColocationProperty
   virtual const PushDownColocationProperty* 
      castToPushDownColocationProperty() const { return NULL; };

   // dynamic type checking help function for PushDownCSProperty
   virtual const
   PushDownCSProperty* castToPushDownCSProperty() const { return NULL; };

private:
};

//
// Push-down colocation checking property.
//
class PushDownColocationProperty : public PushDownProperty
{

public:
   PushDownColocationProperty(const NodeMap* map = 0) : map_(map) {};
   virtual ~PushDownColocationProperty() {};

   const NodeMap* getNodeMap() const { return map_; };
   NABoolean isEmpty() const { return map_ == 0; };

   // generate a PushDownColocationRequirement from the property.
   const PushDownRequirement* makeRequirement() const;

   const PushDownColocationProperty* 
      castToPushDownColocationProperty() const { return this; };

private:
   const NodeMap* map_;
};

//
// Compound statement push down property.
//
class PushDownCSProperty : public PushDownColocationProperty
{

public:
   PushDownCSProperty(const PartitioningFunction* func = 0,
                    const SearchKey* key = 0) :
      PushDownColocationProperty( (func)? func->getNodeMap() : 0),
      partFunc_(func), searchKey_(key) {};
   ~PushDownCSProperty() {};

   // get data members
   const SearchKey* getSearchKey() const { return searchKey_; };
   const PartitioningFunction* getPartFunc() const { return partFunc_; };

   // partFunc will never be NULL for a concrete CS push-down
   // property. searchKey could be empty (e.g., "select * from t" 
   // where t is a single partitioned table)
   NABoolean isEmpty() const { return partFunc_ == 0; };

   // generating a CS push-down requirement.
   const PushDownRequirement* makeRequirement() const;

   // dynamic type checking help function
   const PushDownCSProperty* castToPushDownCSProperty() const { return this; };

private:
   const PartitioningFunction* partFunc_;
   const SearchKey* searchKey_;
};


// Push down requirement (physical always)
class PushDownCSRequirement;
class PushDownColocationRequirement;

//
// PushDown requirement abstract class, which defines the interface
// for verifying whether a push-down property satisfies a push-down 
// requirement.
//
class PushDownRequirement : public NABasicObject
{
public:
   PushDownRequirement() {};
   virtual ~PushDownRequirement() {};

   // check the null state of the requirement (is the requirement fully
   // specified?).
   virtual NABoolean isEmpty() const = 0;

   // verifying a requirement is met by a property.
   virtual NABoolean satisfied(const PushDownProperty&) const = 0;

   // dynamic type checking on PushDownColocationRequirement.
   virtual const PushDownColocationRequirement* 
      castToPushDownColocationRequirement() const { return NULL; };

   // dynamic type checking on PushDownCSRequirement.
   virtual const PushDownCSRequirement* 
      castToPushDownCSRequirement() const { return NULL; };

   virtual COMPARE_RESULT compare(const PushDownRequirement &other) const = 0;

private:
};

//
// Colocation requirement class hierarchy.
//
class PushDownColocationRequirement : public PushDownRequirement
{
public:
   PushDownColocationRequirement(const NodeMap* map = NULL) : map_(map) {};
   ~PushDownColocationRequirement() {};

   // The data member access function
   const NodeMap* getNodeMap() const { return map_; };

   NABoolean isEmpty() const { return map_ == NULL; };

   NABoolean satisfied(const PushDownProperty&) const;

   const PushDownColocationRequirement* 
      castToPushDownColocationRequirement() const { return this; };

   // test whether an instance of PushDownRequirement class is
   // actually a PushDownColocationRequirement.
   static NABoolean isInstanceOf(const PushDownRequirement* x)
     { return (x AND x->castToPushDownColocationRequirement()); };

   COMPARE_RESULT compare(const PushDownRequirement &other) const;

private:
   const NodeMap* map_;
};

//
// Compound statement push down requirement class hierarchy.
//
class PushDownCSRequirement : public PushDownColocationRequirement
{
public:
   PushDownCSRequirement(const PartitioningFunction* func = NULL, 
		    const SearchKey* key = NULL) :
      PushDownColocationRequirement((func)? func->getNodeMap() : NULL),
      partFunc_(func), searchKey_(key) {};

   ~PushDownCSRequirement() {};

   // data member access functions
   const SearchKey* getSearchKey() const { return searchKey_; };
   const PartitioningFunction* getPartFunc() const { return partFunc_; };

   // partFunc will never be NULL for a concrete CS push-down 
   // requirement
   NABoolean isEmpty() const { return partFunc_ == NULL; };

   NABoolean satisfied(const PushDownProperty&) const;

   const PushDownCSRequirement* 
      castToPushDownCSRequirement() const { return this; };

   // test whether an instance of PushDownRequirement class is
   // actually a PushDownCSRequirement.
   static NABoolean isInstanceOf(const PushDownRequirement* x)
     { return (x AND x->castToPushDownCSRequirement()); };

   COMPARE_RESULT compare(const PushDownRequirement &other) const;

private:
   const PartitioningFunction* partFunc_;
   const SearchKey* searchKey_;
};


// -----------------------------------------------------------------------
// Input physical properties
//
// Used by an operator to specify to its child any physical information
// concerning the parent, ancestors, or siblings that could be helpful
// in costing the current operator. It is currently only used by       
// nested join to pass physical information about the left child to the
// right child. If assumeSortedForCosting_ is set then all other fields will be NULL
// and if any of the nj... fields are set assumeSortedForCosting_ is FALSE.
// -----------------------------------------------------------------------

class InputPhysicalProperty : public NABasicObject
{
  public:
    
    // default and standard constructor
    InputPhysicalProperty(
       const ValueIdSet & outerCharOutputs,
       const ValueIdList* const outerOrder = NULL,
       const PartitioningFunction* const outerOrderPartFunc = NULL,
       const PartitioningFunction* const dp2SortOrderPartFunc =NULL,
       const NABoolean assumeSortedForCosting = FALSE,
	   NABoolean explodedOcbJoinForCosting = FALSE)
      : njOuterCharOutputs_(outerCharOutputs),
        njOuterOrder_(outerOrder),
        njOuterOrderPartFunc_(outerOrderPartFunc),
        njDp2OuterOrderPartFunc_(dp2SortOrderPartFunc),
	assumeSortedForCosting_(assumeSortedForCosting),
        njOuterPartFuncForNonUpdates_(outerOrderPartFunc),
		explodedOcbJoinForCosting_(explodedOcbJoinForCosting)
    {}
	// Constructor especially for Exploded Nested Join
	InputPhysicalProperty(
        const NABoolean assumeSortedProbesForCosting,
        NABoolean explodedOcbJoinForCosting = FALSE)
        :  assumeSortedForCosting_(assumeSortedProbesForCosting),
           explodedOcbJoinForCosting_(explodedOcbJoinForCosting),
           njOuterCharOutputs_(NULL),
           njOuterOrder_(NULL),
           njOuterOrderPartFunc_(NULL),
           njOuterPartFuncForNonUpdates_(NULL),
           njDp2OuterOrderPartFunc_(NULL)
    {}
    InputPhysicalProperty(
        const NABoolean assumeSortedProbesForCosting,
        const PartitioningFunction* const njOuterPartFunc,
		NABoolean explodedOcbJoinForCosting = FALSE)
        :  assumeSortedForCosting_(assumeSortedProbesForCosting),
           njOuterPartFuncForNonUpdates_(njOuterPartFunc),
		   explodedOcbJoinForCosting_(explodedOcbJoinForCosting),
           njOuterCharOutputs_(NULL),
           njOuterOrder_(NULL),
           njOuterOrderPartFunc_(NULL),
           njDp2OuterOrderPartFunc_(NULL)
    {}


    // copy constructor
    InputPhysicalProperty(const InputPhysicalProperty& other)
      : njOuterCharOutputs_(other.njOuterCharOutputs_),
        njOuterOrder_(other.njOuterOrder_),
        njOuterOrderPartFunc_(other.njOuterOrderPartFunc_),
        njDp2OuterOrderPartFunc_(other.njDp2OuterOrderPartFunc_),
	assumeSortedForCosting_(other.assumeSortedForCosting_),
        njOuterPartFuncForNonUpdates_(other.njOuterPartFuncForNonUpdates_),
		explodedOcbJoinForCosting_(other.explodedOcbJoinForCosting_)
    {}

    // destructor
    virtual ~InputPhysicalProperty();

    // Accessors
    const ValueIdSet& getNjOuterCharOutputs() const
      { return njOuterCharOutputs_; }

    const ValueIdList* getNjOuterOrder() const
      { return njOuterOrder_; }

    const PartitioningFunction* getNjOuterOrderPartFunc() const
      { return njOuterOrderPartFunc_; }

    const PartitioningFunction* getNjDp2OuterOrderPartFunc() const
      { return njDp2OuterOrderPartFunc_; }

    NABoolean getAssumeSortedForCosting() const
      { return assumeSortedForCosting_; }


    // Comparison method for use when comparing contexts
    COMPARE_RESULT compareInputPhysicalProperties(
                     const InputPhysicalProperty& other) const;

    const PartitioningFunction* getNjOuterOrderPartFuncForNonUpdates() const
      { return njOuterPartFuncForNonUpdates_;}
    NABoolean getExplodedOcbJoinForCosting() const
      { return explodedOcbJoinForCosting_; }

  private:

    // Used to pass the characteristic outputs from the left child
    // of a nested join to the right child. This is so the right
    // child can determine what its equijoin columns are.
    const ValueIdSet  njOuterCharOutputs_;

    // Used to pass the synthesized sort key of the left child of
    // a nested join to the right child for costing purposes.
    const ValueIdList * njOuterOrder_;

    // Used to pass the synthesized logical partitioning function 
    // of the left child of a nested join to the right child for
    // costing purposes.
    const PartitioningFunction* njOuterOrderPartFunc_;


    // Used to pass the synthesized physical partitioning function
    // of the left child access path to the right child, if the
    // sort order type of the left child's sort key was "dp2", 
    // for costing purposes.
    const PartitioningFunction* njDp2OuterOrderPartFunc_;

    // we want to find partition function even when order is not 
    // important. See case2 comment for assumeSortedForCosting_ below.
    const PartitioningFunction* njOuterPartFuncForNonUpdates_;

    // assumeSortedForCosting_ flag is set for two cases:
    // case 1: when input is rowset.
    // Used to pass information that the left child is an Unpack node
    // that is being used to flow input rowsets. We will assume that input rowsets 
    // are sorted with respect to whatever access path is being considered for the
    // right child. This assumption is made only for costing, and not to detrmine the
    // plan. This assumption will help us choose "optimistic" plans for rowset input,
    // assuming that rowset input is appropriately sorted, even though it may not be,
    // as we have no way to infer the sort order of the input rowset.
    // In this case njOuterPartFuncForNonUpdates_ will always NULL.

    // case 2: when left child partFunc njOuterPartFuncForNonUpdates_ is passed for 
    // NJ plan 0. This is only for cost estimation of exchange operator.
    // In this case njOuterPartFuncForNonUpdates_ will always be non-NULL.
    const NABoolean assumeSortedForCosting_ ;
    
	NABoolean explodedOcbJoinForCosting_ ;
}; // InputPhysicalProperty

#endif /* PHYPROP_HDR */