greenplumn COptimizationContext 源码

greenplumn COptimizationContext 代码

文件路径：/src/backend/gporca/libgpopt/include/gpopt/base/COptimizationContext.h

//---------------------------------------------------------------------------
//	Greenplum Database
//	Copyright (C) 2011 EMC Corp.
//
//	@filename:
//		COptimizationContext.h
//
//	@doc:
//		Optimization context object stores properties required to hold
//		on the plan generated by the optimizer
//---------------------------------------------------------------------------
#ifndef GPOPT_COptimizationContext_H
#define GPOPT_COptimizationContext_H

#include "gpos/base.h"
#include "gpos/common/DbgPrintMixin.h"
#include "gpos/task/CAutoTraceFlag.h"

#include "gpopt/base/CReqdPropPlan.h"
#include "gpopt/base/CReqdPropRelational.h"
#include "gpopt/search/CJobQueue.h"
#include "naucrates/statistics/IStatistics.h"

#define GPOPT_INVALID_OPTCTXT_ID gpos::ulong_max

namespace gpopt
{
using namespace gpos;

// forward declarations
class CGroup;
class CGroupExpression;
class CCostContext;
class COptimizationContext;
class CDrvdPropPlan;

// optimization context pointer definition
using OPTCTXT_PTR = COptimizationContext *;

// array of optimization contexts
using COptimizationContextArray =
	CDynamicPtrArray<COptimizationContext, CleanupRelease>;

//---------------------------------------------------------------------------
//	@class:
//		COptimizationContext
//
//	@doc:
//		Optimization context
//
//---------------------------------------------------------------------------
class COptimizationContext : public CRefCount,
							 public DbgPrintMixin<COptimizationContext>
{
public:
	// states of optimization context
	enum EState
	{
		estUnoptimized,	 // initial state

		estOptimizing,	// ongoing optimization
		estOptimized,	// done optimization

		estSentinel
	};

private:
	// memory pool
	CMemoryPool *m_mp{nullptr};

	// private copy ctor
	COptimizationContext(const COptimizationContext &);

	// unique id within owner group, used for debugging
	ULONG m_id{GPOPT_INVALID_OPTCTXT_ID};

	// back pointer to owner group, used for debugging
	CGroup *m_pgroup{nullptr};

	// required plan properties
	CReqdPropPlan *m_prpp{nullptr};

	// required relational properties -- used for stats computation during costing
	CReqdPropRelational *m_prprel{nullptr};

	// stats of previously optimized expressions
	IStatisticsArray *m_pdrgpstatCtxt{nullptr};

	// index of search stage where context is generated
	ULONG m_ulSearchStageIndex{0};

	// best cost context under the optimization context
	CCostContext *m_pccBest{nullptr};

	// optimization context state
	EState m_estate{estUnoptimized};

	// is there a multi-stage Agg plan satisfying required properties
	BOOL m_fHasMultiStageAggPlan{false};

	// context's optimization job queue
	CJobQueue m_jqOptimization;

	// internal matching function
	BOOL FMatchSortColumns(const COptimizationContext *poc) const;

	// private dummy ctor; used for creating invalid context
	COptimizationContext() = default;

	// check if Agg node should be optimized for the given context
	static BOOL FOptimizeAgg(CMemoryPool *mp, CGroupExpression *pgexprParent,
							 CGroupExpression *pgexprAgg,
							 COptimizationContext *poc, ULONG ulSearchStages);

	// check if Sort node should be optimized for the given context
	static BOOL FOptimizeSort(CMemoryPool *mp, CGroupExpression *pgexprParent,
							  CGroupExpression *pgexprSort,
							  COptimizationContext *poc, ULONG ulSearchStages);

	// check if Motion node should be optimized for the given context
	static BOOL FOptimizeMotion(CMemoryPool *mp, CGroupExpression *pgexprParent,
								CGroupExpression *pgexprMotion,
								COptimizationContext *poc,
								ULONG ulSearchStages);

	// check if NL join node should be optimized for the given context
	static BOOL FOptimizeNLJoin(CMemoryPool *mp, CGroupExpression *pgexprParent,
								CGroupExpression *pgexprMotion,
								COptimizationContext *poc,
								ULONG ulSearchStages);

public:
	// ctor
	COptimizationContext(
		CMemoryPool *mp, CGroup *pgroup, CReqdPropPlan *prpp,
		CReqdPropRelational *
			prprel,	 // required relational props -- used during stats derivation
		IStatisticsArray
			*stats_ctxt,  // stats of previously optimized expressions
		ULONG ulSearchStageIndex)
		: m_mp(mp),
		  m_pgroup(pgroup),
		  m_prpp(prpp),
		  m_prprel(prprel),
		  m_pdrgpstatCtxt(stats_ctxt),
		  m_ulSearchStageIndex(ulSearchStageIndex)
	{
		GPOS_ASSERT(nullptr != pgroup);
		GPOS_ASSERT(nullptr != prpp);
		GPOS_ASSERT(nullptr != prprel);
		GPOS_ASSERT(nullptr != stats_ctxt);
	}

	// dtor
	~COptimizationContext() override;

	// best group expression accessor
	CGroupExpression *PgexprBest() const;

	// match optimization contexts
	BOOL Matches(const COptimizationContext *poc) const;

	// get id
	ULONG
	Id() const
	{
		return m_id;
	}

	// group accessor
	CGroup *
	Pgroup() const
	{
		return m_pgroup;
	}

	// required plan properties accessor
	CReqdPropPlan *
	Prpp() const
	{
		return m_prpp;
	}

	// required relatoinal properties accessor
	CReqdPropRelational *
	GetReqdRelationalProps() const
	{
		return m_prprel;
	}

	// stats of previously optimized expressions
	IStatisticsArray *
	Pdrgpstat() const
	{
		return m_pdrgpstatCtxt;
	}

	// search stage index accessor
	ULONG
	UlSearchStageIndex() const
	{
		return m_ulSearchStageIndex;
	}

	// best cost context accessor
	CCostContext *
	PccBest() const
	{
		return m_pccBest;
	}

	// optimization job queue accessor
	CJobQueue *
	PjqOptimization()
	{
		return &m_jqOptimization;
	}

	// state accessor
	EState
	Est() const
	{
		return m_estate;
	}

	// is there a multi-stage Agg plan satisfying required properties
	BOOL
	FHasMultiStageAggPlan() const
	{
		return m_fHasMultiStageAggPlan;
	}

	// set optimization context id
	void
	SetId(ULONG id)
	{
		GPOS_ASSERT(m_id == GPOPT_INVALID_OPTCTXT_ID);

		m_id = id;
	}

	// set optimization context state
	void
	SetState(EState estNewState)
	{
		GPOS_ASSERT(estNewState == (EState)(m_estate + 1));

		m_estate = estNewState;
	}

	// set best cost context
	void SetBest(CCostContext *pcc);

	// comparison operator for hashtables
	BOOL
	operator==(const COptimizationContext &oc) const
	{
		return oc.Matches(this);
	}

	// debug print
	IOstream &OsPrint(IOstream &os) const;
	IOstream &OsPrintWithPrefix(IOstream &os, const CHAR *szPrefix) const;

	// check equality of optimization contexts
	static BOOL
	Equals(const COptimizationContext &ocLeft,
		   const COptimizationContext &ocRight)
	{
		return ocLeft == ocRight;
	}

	// hash function for optimization context
	static ULONG
	HashValue(const COptimizationContext &oc)
	{
		GPOS_ASSERT(nullptr != oc.Prpp());

		return oc.Prpp()->HashValue();
	}

	// equality function for cost contexts hash table
	static BOOL
	Equals(const OPTCTXT_PTR &pocLeft, const OPTCTXT_PTR &pocRight)
	{
		if (pocLeft == m_pocInvalid || pocRight == m_pocInvalid)
		{
			return pocLeft == m_pocInvalid && pocRight == m_pocInvalid;
		}

		return *pocLeft == *pocRight;
	}

	// hash function for cost contexts hash table
	static ULONG
	HashValue(const OPTCTXT_PTR &poc)
	{
		GPOS_ASSERT(m_pocInvalid != poc);

		return HashValue(*poc);
	}

	// hash function used for computing stats during costing
	static ULONG
	UlHashForStats(const COptimizationContext *poc)
	{
		GPOS_ASSERT(m_pocInvalid != poc);

		return HashValue(*poc);
	}

	// equality function used for computing stats during costing
	static BOOL FEqualForStats(const COptimizationContext *pocLeft,
							   const COptimizationContext *pocRight);

	// return true if given group expression should be optimized under given context
	static BOOL FOptimize(CMemoryPool *mp, CGroupExpression *pgexprParent,
						  CGroupExpression *pgexprChild,
						  COptimizationContext *pocChild, ULONG ulSearchStages);

	// compare array of contexts based on context ids
	static BOOL FEqualContextIds(COptimizationContextArray *pdrgpocFst,
								 COptimizationContextArray *pdrgpocSnd);

	// compute required properties to CTE producer based on plan properties of CTE consumer
	static CReqdPropPlan *PrppCTEProducer(CMemoryPool *mp,
										  COptimizationContext *poc,
										  ULONG ulSearchStages);

	// link for optimization context hash table in CGroup
	SLink m_link;

	// invalid optimization context, needed for hash table iteration
	static const COptimizationContext m_ocInvalid;

	// invalid optimization context pointer, needed for cost contexts hash table iteration
	static const OPTCTXT_PTR m_pocInvalid;

};	// class COptimizationContext
}  // namespace gpopt


#endif	// !GPOPT_COptimizationContext_H

// EOF

相关信息

greenplumn 源码目录

相关文章

greenplumn CAutoOptCtxt 源码

greenplumn CCTEInfo 源码

greenplumn CCTEMap 源码

greenplumn CCTEReq 源码

greenplumn CCastUtils 源码

greenplumn CColConstraintsArrayMapper 源码

greenplumn CColConstraintsHashMapper 源码

greenplumn CColRef 源码

greenplumn CColRefComputed 源码

greenplumn CColRefSet 源码