/**********************************************************************
// @@@ 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 RELSAMPLE_H
#define RELSAMPLE_H
/* -*-C++-*-
******************************************************************************
*
* File:         RelSample.h
* Description:  Class definitions for the classes RelSample
*               and PhysSample
* Created:      9/24/98
* Language:     C++
*
*
*
*
******************************************************************************
*/

#include "RelExpr.h"

///////////////////////////////////////////////////////////////////////////////
//
//             The RelSample class
//
//
///////////////////////////////////////////////////////////////////////////////

// Class RelSample

class RelSample : public RelExpr
{
public:
  enum SampleTypeEnum
  {
    RANDOM,
    PERIODIC,
    FIRSTN,
    CLUSTER,
    ANY
  };

  // the constructor
  RelSample (RelExpr *child,
                    SampleTypeEnum sampleType = ANY,
                    ItemExpr *balanceExpr = NULL,
                    ItemExpr *requiredOrder = NULL,
                    CollHeap *oHeap = CmpCommon::statementHeap());

  // the desctructor
  virtual ~RelSample ();

  // RelSample operator has only one child
  virtual Int32 getArity () const { return 1; };

  virtual const NAString getText() const {return "Sample";};

  ValueIdList mapSortKey(const ValueIdList &sortKey) const;

  // Method to return data members
  //
  // Accessor methods
  inline ValueIdList & requiredOrder() { return requiredOrder_; };
  inline const ValueIdList & requiredOrder() const { return requiredOrder_; }

  inline SampleTypeEnum sampleType () const { return sampleType_; };

  inline void sampleType (SampleTypeEnum type) {sampleType_ = type; };

  inline NABoolean sampleScanSucceeded () {return sampleScanSucceeded_; };

  inline void setSampleScanSucceeded (NABoolean b) {sampleScanSucceeded_ = b;};

  inline ItemExpr *&balanceExprTree() { return balanceExprTree_; };

  inline const ItemExpr *balanceExprTree() const { return balanceExprTree_; };

  inline ValueIdSet & balanceExpr() { return balanceExpr_; };

  inline const ValueIdSet & balanceExpr() const { return balanceExpr_; };

  inline ValueIdSet & sampledColumns() { return sampledColumns_; };

  inline const ValueIdSet & sampledColumns() const { return sampledColumns_; };

  virtual HashValue topHash();

  virtual NABoolean duplicateMatch(const RelExpr & other) const;

  virtual RelExpr *copyTopNode(RelExpr *derivedNode, CollHeap *outHeap);

  virtual void addLocalExpr(LIST(ExprNode *) &xlist,
                            LIST(NAString) &llist) const;

  virtual void getPotentialOutputValues(ValueIdSet & outputValues) const;

  virtual void pushdownCoveredExpr(const ValueIdSet & outputExprOnOperator,
                                   const ValueIdSet &newExternalInputs,
                                   ValueIdSet &predicatesOnParent,
				   const ValueIdSet * setOfValuesReqdByParent = NULL,
                                   Lng32 childIndex = (-MAX_REL_ARITY)
                                  );

  ItemExpr *removeBalanceExprTree();

  virtual void transformNode(NormWA &normWARef,
                             ExprGroupId &locationOfPointerToMe);

  virtual void rewriteNode(NormWA & normWARef);

  virtual RelExpr *normalizeNode(NormWA & normWARef);

  virtual RelExpr * semanticQueryOptimizeNode(NormWA & normWARef);

  virtual void pullUpPreds();

  virtual void recomputeOuterReferences();

  CostScalar computeResultSize(const CostScalar &childCardinality);

  virtual void synthEstLogProp(const EstLogPropSharedPtr& inputEstLogProp);

  virtual void synthLogProp(NormWA * normWAPtr = NULL);

  virtual Context* createContextForAChild(Context* myContext,
                                          PlanWorkSpace* pws,
                                          Lng32& childIndex);

  virtual RelExpr *bindNode(BindWA *bindWA);

  NABoolean isSimpleRandomRelative() const;

  Float32 getSamplePercent() const;

  Lng32 getClusterSize() const;

private:
  // Return a pointer to the required order tree after
  // setting it to NULL.
  //
  ItemExpr *removeRequiredOrderTree();

  // An ItemExpr list of columns representing the reqired sort order
  // for this node.
  //
  ItemExpr *requiredOrderTree_;

  // The bound version of requiredOrderTree_.
  //
  ValueIdList requiredOrder_;

  // Sample type is one of RANDOM, PERIODIC, FIRSTN, CLUSTER
  SampleTypeEnum sampleType_;

  // Used by optimizer to avoid firing PhysicalSampleRule for CLUSTER
  // samples which have already succesfully fired the SampleScanRule.
  // If the SampleScanRule has not successfully fired, we want the
  // PhysicalSampleRule to fire so that an appropriate error message
  // can be produced in the generator.  This data member is initially
  // set to FALSE and is set to TRUE by the SampleScanRule.
  //
  NABoolean sampleScanSucceeded_;

  // The balance expression is a list of balance itemexprs
  //
  ItemExpr *balanceExprTree_;

  // The bound balance expression
  ValueIdSet balanceExpr_;

  // The output columns
  ValueIdSet sampledColumns_;

};

// Class PhysSample ----------------------------------------------------
// The PhysSample node replaces the logical RelSample node through the
// application of the PhysSampleRule. This transformation is
// designed to present a purely physical verison of this operator
// that is both a logical and physical node.
// -----------------------------------------------------------------------
class PhysSample : public RelSample
{
public:

  // The constructor
  //
  PhysSample(RelExpr *child = NULL,
                    RelSample::SampleTypeEnum type = ANY,
		    CollHeap *oHeap = CmpCommon::statementHeap())
    : RelSample(child, type, NULL, NULL, oHeap)
  {
  };

  // The destructor.
  //
  virtual ~PhysSample();

  // methods to do code generation of the physical node.
  //
  virtual RelExpr * preCodeGen(Generator * generator,
			       const ValueIdSet & externalInputs,
			       ValueIdSet &pulledNewInputs);
  virtual short codeGen(Generator*);

  // generate CONTROL QUERY SHAPE fragment for this node.
  //
  virtual short generateShape(CollHeap * space, char * buf, NAString * shapeStr = NULL);

  // Copy a chain of derived nodes (Calls UnPackRows::copyTopNode).
  // Needs to copy all relevant fields (in this case no fields
  // need to be copied)
  // Used by the Cascades engine.
  //
  virtual RelExpr * copyTopNode(RelExpr *derivedNode = NULL,
				CollHeap *outHeap = NULL);

  // cost functions
  //
  virtual PhysicalProperty *synthPhysicalProperty(const Context *context,
                                                  const Lng32 planNumber,
                                                  PlanWorkSpace  *pws);
  virtual CostMethod* costMethod() const;

  // Redefine these virtual methods to declare this node as a
  // physical node.
  //
  virtual NABoolean isLogical() const {return FALSE;};
  virtual NABoolean isPhysical() const {return TRUE;};

  ExplainTuple *addSpecificExplainInfo(ExplainTupleMaster *explainTuple,
					      ComTdb * tdb,
					      Generator *generator);
}; // class PhysSample


#endif