greenplumn CJobGroupExpressionOptimization 源码

  • 2022-08-18
  • 浏览 (5)

greenplumn CJobGroupExpressionOptimization 代码

文件路径:/src/backend/gporca/libgpopt/include/gpopt/search/CJobGroupExpressionOptimization.h

//---------------------------------------------------------------------------
//	Greenplum Database
//	Copyright (C) 2011 EMC Corp.
//
//	@filename:
//		CJobGroupExpressionOptimization.h
//
//	@doc:
//		Explore group expression job
//---------------------------------------------------------------------------
#ifndef GPOPT_CJobGroupExpressionOptimization_H
#define GPOPT_CJobGroupExpressionOptimization_H

#include "gpos/base.h"

#include "gpopt/base/COptimizationContext.h"
#include "gpopt/search/CJobGroupExpression.h"
#include "gpopt/search/CJobStateMachine.h"

namespace gpopt
{
using namespace gpos;

// prototypes
class CCostContext;

//---------------------------------------------------------------------------
//	@class:
//		CJobGroupExpressionOptimization
//
//	@doc:
//		Group expression optimization job
//
//		Responsible for finding the best plan rooted by a given group
//		expression, such that the identified plan satisfies given required plan
//		properties. Note that a group optimization job entails running a group
//		expression optimization job for each group expression in the underlying
//		group.
//
//---------------------------------------------------------------------------
class CJobGroupExpressionOptimization : public CJobGroupExpression
{
public:
	// transition events of group expression optimization
	enum EEvent
	{
		eevOptimizingChildren,	// child groups optimization is in progress
		eevChildrenOptimized,	// done with children optimization
		eevCheckingEnfdProps,	// check enforceable properties
		eevOptimizingSelf,		// cost computation is in progress
		eevSelfOptimized,		// done with costing group expression
		eevFinalized,			// done with optimization

		eevSentinel
	};

	// states of group expression optimization
	enum EState
	{
		estInitialized = 0,		// initial state
		estOptimizingChildren,	// child groups are under optimization
		estChildrenOptimized,	// child groups are optimized
		estEnfdPropsChecked,	// enforceable properties are checked
		estSelfOptimized,		// group expression cost is computed
		estCompleted,			// done optimization

		estSentinel
	};


private:
	// shorthand for job state machine
	using JSM = CJobStateMachine<EState, estSentinel, EEvent, eevSentinel>;

	// job state machine
	JSM m_jsm;

	// optimization context of the job
	COptimizationContext *m_poc;

	// optimization request number
	ULONG m_ulOptReq;

	// array of child groups optimization contexts
	COptimizationContextArray *m_pdrgpoc;

	// stats context to be used during costing
	IStatisticsArray *m_pdrgpstatCurrentCtxt;

	// array of derived properties of optimal implementations of child groups
	CDrvdPropArray *m_pdrgpdp;

	// optimization order of children
	CPhysical::EChildExecOrder m_eceo;

	// counter of next child group to be optimized
	ULONG m_ulChildIndex;

	// number of children
	ULONG m_ulArity;

	// flag to indicate if optimizing a child has failed
	BOOL m_fChildOptimizationFailed;

	// flag to indicate if current job optimizes a Sequence operator that captures a CTE
	BOOL m_fOptimizeCTESequence;

	// plan properties required from CTE producer based on consumer derived plan properties
	CReqdPropPlan *m_prppCTEProducer;

	// flag to indicate if a child job for optimizing CTE has been scheduled
	BOOL m_fScheduledCTEOptimization;

	// a handle object for required plan properties computation
	CExpressionHandle *m_pexprhdlPlan;

	// a handle object for required relational property computation
	CExpressionHandle *m_pexprhdlRel;

	// initialization routine for child groups optimization
	void InitChildGroupsOptimization(CSchedulerContext *psc);

	// derive plan properties and stats of the child previous to the one being optimized
	void DerivePrevChildProps(CSchedulerContext *psc);

	// compute required plan properties for current child
	void ComputeCurrentChildRequirements(CSchedulerContext *psc);

	// initialize action
	static EEvent EevtInitialize(CSchedulerContext *psc, CJob *pj);

	// optimize child groups action
	static EEvent EevtOptimizeChildren(CSchedulerContext *psc, CJob *pj);

	// add enforcers to the owning group
	static EEvent EevtAddEnforcers(CSchedulerContext *psc, CJob *pj);

	// optimize group expression action
	static EEvent EevtOptimizeSelf(CSchedulerContext *psc, CJob *pj);

	// finalize action
	static EEvent EevtFinalize(CSchedulerContext *psc, CJob *pj);

	// schedule a new group expression optimization job for CTE optimization
	static BOOL FScheduleCTEOptimization(CSchedulerContext *psc,
										 CGroupExpression *pgexpr,
										 COptimizationContext *poc,
										 ULONG ulOptReq, CJob *pjParent);

protected:
	// schedule transformation jobs for applicable xforms
	void
	ScheduleApplicableTransformations(CSchedulerContext *  // psc
									  ) override
	{
		// no transformations are applicable to this job
	}

	// schedule optimization jobs for all child groups
	void ScheduleChildGroupsJobs(CSchedulerContext *psc) override;

public:
	CJobGroupExpressionOptimization(const CJobGroupExpressionOptimization &) =
		delete;

	// ctor
	CJobGroupExpressionOptimization();

	// dtor
	~CJobGroupExpressionOptimization() override;

	// initialize job
	void Init(CGroupExpression *pgexpr, COptimizationContext *poc,
			  ULONG ulOptReq, CReqdPropPlan *prppCTEProducer = nullptr);

	// cleanup internal state
	void Cleanup() override;

	// schedule a new group expression optimization job
	static void ScheduleJob(CSchedulerContext *psc, CGroupExpression *pgexpr,
							COptimizationContext *poc, ULONG ulOptReq,
							CJob *pjParent);

	// job's function
	BOOL FExecute(CSchedulerContext *psc) override;

#ifdef GPOS_DEBUG

	// print function
	IOstream &OsPrint(IOstream &os) const override;

	// dump state machine diagram in graphviz format
	virtual IOstream &
	OsDiagramToGraphviz(CMemoryPool *mp, IOstream &os,
						const WCHAR *wszTitle) const
	{
		(void) m_jsm.OsDiagramToGraphviz(mp, os, wszTitle);

		return os;
	}

	// compute unreachable states
	void
	Unreachable(CMemoryPool *mp, EState **ppestate, ULONG *pulSize) const
	{
		m_jsm.Unreachable(mp, ppestate, pulSize);
	}


#endif	// GPOS_DEBUG

	// conversion function
	static CJobGroupExpressionOptimization *
	PjConvert(CJob *pj)
	{
		GPOS_ASSERT(nullptr != pj);
		GPOS_ASSERT(EjtGroupExpressionOptimization == pj->Ejt());

		return dynamic_cast<CJobGroupExpressionOptimization *>(pj);
	}

};	// class CJobGroupExpressionOptimization

}  // namespace gpopt

#endif	// !GPOPT_CJobGroupExpressionOptimization_H


// EOF

相关信息

greenplumn 源码目录

相关文章

greenplumn CBinding 源码

greenplumn CGroup 源码

greenplumn CGroupExpression 源码

greenplumn CGroupProxy 源码

greenplumn CJob 源码

greenplumn CJobFactory 源码

greenplumn CJobGroup 源码

greenplumn CJobGroupExploration 源码

greenplumn CJobGroupExpression 源码

greenplumn CJobGroupExpressionExploration 源码

0  赞