greenplumn CDXLOperatorFactory 源码

greenplumn CDXLOperatorFactory 代码

文件路径：/src/backend/gporca/libnaucrates/include/naucrates/dxl/operators/CDXLOperatorFactory.h

//---------------------------------------------------------------------------
//	Greenplum Database
//	Copyright (C) 2010 Greenplum, Inc.
//
//	@filename:
//		CDXLOperatorFactory.h
//
//	@doc:
//		Factory for creating DXL tree elements out of parsed XML attributes
//---------------------------------------------------------------------------

#ifndef GPDXL_CDXLOperatorFactory_H
#define GPDXL_CDXLOperatorFactory_H

#include <xercesc/sax2/Attributes.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/XMLStringTokenizer.hpp>
#include <xercesc/util/XMLUniDefs.hpp>

#include "gpos/base.h"
#include "gpos/common/CDouble.h"

#include "naucrates/base/IDatum.h"
#include "naucrates/dxl/operators/CDXLColRef.h"
#include "naucrates/dxl/operators/CDXLCtasStorageOptions.h"
#include "naucrates/dxl/operators/CDXLIndexDescr.h"
#include "naucrates/dxl/operators/CDXLLogical.h"
#include "naucrates/dxl/operators/CDXLPhysical.h"
#include "naucrates/dxl/operators/CDXLPhysicalMotion.h"
#include "naucrates/dxl/operators/CDXLScalarBoolExpr.h"
#include "naucrates/dxl/operators/CDXLScalarBooleanTest.h"
#include "naucrates/dxl/operators/CDXLScalarSubPlan.h"
#include "naucrates/dxl/operators/CDXLScalarWindowFrameEdge.h"
#include "naucrates/dxl/operators/CDXLTableDescr.h"
#include "naucrates/dxl/operators/CDXLWindowFrame.h"
#include "naucrates/dxl/xml/CDXLMemoryManager.h"
#include "naucrates/dxl/xml/dxltokens.h"
#include "naucrates/md/CMDFunctionGPDB.h"
#include "naucrates/md/CMDRelationGPDB.h"
#include "naucrates/md/IMDId.h"
#include "naucrates/md/IMDIndex.h"

// dynamic array of XML strings
using XMLChArray = CDynamicPtrArray<XMLCh, CleanupNULL>;

// fwd decl
namespace gpmd
{
class CMDIdGPDB;
class CMDIdColStats;
class CMDIdRelStats;
class CMDIdCast;
class CMDIdScCmp;
}  // namespace gpmd

namespace gpdxl
{
using namespace gpos;
using namespace gpmd;
using namespace gpnaucrates;

XERCES_CPP_NAMESPACE_USE

//fwd decl
class CDXLMemoryManager;
class CDXLDatum;

//---------------------------------------------------------------------------
//	@class:
//		CDXLOperatorFactory
//
//	@doc:
//		Factory class containing static methods for creating DXL objects
//		from parsed DXL information such as XML element's attributes
//
//---------------------------------------------------------------------------
class CDXLOperatorFactory
{
private:
	// return the LINT value of byte array
	static LINT Value(CDXLMemoryManager *dxl_memory_manager,
					  const Attributes &attrs, Edxltoken target_elem,
					  const BYTE *data);

	// parses a byte array representation of the datum
	static BYTE *GetByteArray(CDXLMemoryManager *dxl_memory_manager,
							  const Attributes &attrs, Edxltoken target_elem,
							  ULONG *length);

public:
	static CDXLDatum *GetDatumOid(CDXLMemoryManager *dxl_memory_manager,
								  const Attributes &attrs,
								  Edxltoken target_elem, IMDId *mdid,
								  BOOL is_const_null);

	static CDXLDatum *GetDatumInt2(CDXLMemoryManager *dxl_memory_manager,
								   const Attributes &attrs,
								   Edxltoken target_elem, IMDId *mdid,
								   BOOL is_const_null);

	static CDXLDatum *GetDatumInt4(CDXLMemoryManager *dxl_memory_manager,
								   const Attributes &attrs,
								   Edxltoken target_elem, IMDId *mdid,
								   BOOL is_const_null);

	static CDXLDatum *GetDatumInt8(CDXLMemoryManager *dxl_memory_manager,
								   const Attributes &attrs,
								   Edxltoken target_elem, IMDId *mdid,
								   BOOL is_const_null);

	static CDXLDatum *GetDatumBool(CDXLMemoryManager *dxl_memory_manager,
								   const Attributes &attrs,
								   Edxltoken target_elem, IMDId *mdid,
								   BOOL is_const_null);

	// parse a dxl datum of type generic
	static CDXLDatum *GetDatumGeneric(CDXLMemoryManager *dxl_memory_manager,
									  const Attributes &attrs,
									  Edxltoken target_elem, IMDId *mdid,
									  BOOL is_const_null);

	// parse a dxl datum of types that need double mapping
	static CDXLDatum *GetDatumStatsDoubleMappable(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs,
		Edxltoken target_elem, IMDId *mdid, BOOL is_const_null);

	// parse a dxl datum of types that need lint mapping
	static CDXLDatum *GetDatumStatsLintMappable(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs,
		Edxltoken target_elem, IMDId *mdid, BOOL is_const_null);

	// create a table scan operator
	static CDXLPhysical *MakeDXLTblScan(CDXLMemoryManager *dxl_memory_manager,
										const Attributes &attrs);

	// create a subquery scan operator
	static CDXLPhysical *MakeDXLSubqScan(CDXLMemoryManager *dxl_memory_manager,
										 const Attributes &attrs);

	// create a result operator
	static CDXLPhysical *MakeDXLResult(CDXLMemoryManager *dxl_memory_manager);

	// create a hashjoin operator
	static CDXLPhysical *MakeDXLHashJoin(CDXLMemoryManager *dxl_memory_manager,
										 const Attributes &attrs);

	// create a nested loop join operator
	static CDXLPhysical *MakeDXLNLJoin(CDXLMemoryManager *dxl_memory_manager,
									   const Attributes &attrs);

	// create a merge join operator
	static CDXLPhysical *MakeDXLMergeJoin(CDXLMemoryManager *dxl_memory_manager,
										  const Attributes &attrs);

	// create a gather motion operator
	static CDXLPhysical *MakeDXLGatherMotion(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs);

	// create a broadcast motion operator
	static CDXLPhysical *MakeDXLBroadcastMotion(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs);

	// create a redistribute motion operator
	static CDXLPhysical *MakeDXLRedistributeMotion(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs);

	// create a routed motion operator
	static CDXLPhysical *MakeDXLRoutedMotion(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs);

	// create a random motion operator
	static CDXLPhysical *MakeDXLRandomMotion(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs);

	// create an append operator
	static CDXLPhysical *MakeDXLAppend(CDXLMemoryManager *dxl_memory_manager,
									   const Attributes &attrs);

	// create a limit operator
	static CDXLPhysical *MakeDXLLimit(CDXLMemoryManager *dxl_memory_manager,
									  const Attributes &attrs);

	// create an aggregation operator
	static CDXLPhysical *MakeDXLAgg(CDXLMemoryManager *dxl_memory_manager,
									const Attributes &attrs);

	// create a sort operator
	static CDXLPhysical *MakeDXLSort(CDXLMemoryManager *dxl_memory_manager,
									 const Attributes &attrs);

	// create a materialize operator
	static CDXLPhysical *MakeDXLMaterialize(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs);

	// create a limit count operator
	static CDXLScalar *MakeDXLLimitCount(CDXLMemoryManager *dxl_memory_manager,
										 const Attributes &attrs);

	// create a limit offset operator
	static CDXLScalar *MakeDXLLimitOffset(CDXLMemoryManager *dxl_memory_manager,
										  const Attributes &attrs);

	// create a scalar comparison operator
	static CDXLScalar *MakeDXLScalarCmp(CDXLMemoryManager *dxl_memory_manager,
										const Attributes &attrs);

	// create a distinct comparison operator
	static CDXLScalar *MakeDXLDistinctCmp(CDXLMemoryManager *dxl_memory_manager,
										  const Attributes &attrs);

	// create a scalar OpExpr
	static CDXLScalar *MakeDXLOpExpr(CDXLMemoryManager *dxl_memory_manager,
									 const Attributes &attrs);

	// create a scalar ArrayComp
	static CDXLScalar *MakeDXLArrayComp(CDXLMemoryManager *dxl_memory_manager,
										const Attributes &attrs);

	// create a BoolExpr
	static CDXLScalar *MakeDXLBoolExpr(CDXLMemoryManager *dxl_memory_manager,
									   const EdxlBoolExprType);

	// create a boolean test
	static CDXLScalar *MakeDXLBooleanTest(CDXLMemoryManager *dxl_memory_manager,
										  const EdxlBooleanTestType);

	// create a subplan operator
	static CDXLScalar *MakeDXLSubPlan(CDXLMemoryManager *dxl_memory_manager,
									  IMDId *mdid,
									  CDXLColRefArray *dxl_colref_array,
									  EdxlSubPlanType dxl_subplan_type,
									  CDXLNode *dxlnode_test_expr);

	// create a NullTest
	static CDXLScalar *MakeDXLNullTest(CDXLMemoryManager *dxl_memory_manager,
									   const BOOL);

	// create a cast
	static CDXLScalar *MakeDXLCast(CDXLMemoryManager *dxl_memory_manager,
								   const Attributes &attrs);

	// create a coerce
	static CDXLScalar *MakeDXLCoerceToDomain(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs);

	// create a CoerceViaIo
	static CDXLScalar *MakeDXLCoerceViaIO(CDXLMemoryManager *dxl_memory_manager,
										  const Attributes &attrs);

	// create a ArrayCoerceExpr
	static CDXLScalar *MakeDXLArrayCoerceExpr(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs);

	// create a scalar identifier operator
	static CDXLScalar *MakeDXLScalarIdent(CDXLMemoryManager *dxl_memory_manager,
										  const Attributes &attrs);

	// create a scalar Const
	static CDXLScalar *MakeDXLConstValue(CDXLMemoryManager *dxl_memory_manager,
										 const Attributes &attrs);

	// create a CaseStmt
	static CDXLScalar *MakeDXLIfStmt(CDXLMemoryManager *dxl_memory_manager,
									 const Attributes &attrs);

	// create a FuncExpr
	static CDXLScalar *MakeDXLFuncExpr(CDXLMemoryManager *dxl_memory_manager,
									   const Attributes &attrs);

	// create a AggRef
	static CDXLScalar *MakeDXLAggFunc(CDXLMemoryManager *dxl_memory_manager,
									  const Attributes &attrs);

	// create a scalar window function (WindowRef)
	static CDXLScalar *MakeWindowRef(CDXLMemoryManager *dxl_memory_manager,
									 const Attributes &attrs);

	// create an array
	static CDXLScalar *MakeDXLArray(CDXLMemoryManager *dxl_memory_manager,
									const Attributes &attr);

	// create a proj elem
	static CDXLScalar *MakeDXLProjElem(CDXLMemoryManager *dxl_memory_manager,
									   const Attributes &attrs);

	// create a hash expr
	static CDXLScalar *MakeDXLHashExpr(CDXLMemoryManager *dxl_memory_manager,
									   const Attributes &attrs);

	// create a sort col
	static CDXLScalar *MakeDXLSortCol(CDXLMemoryManager *dxl_memory_manager,
									  const Attributes &attrs);

	// create an object representing cost estimates of a physical operator
	// from the parsed XML attributes
	static CDXLOperatorCost *MakeDXLOperatorCost(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs);

	// create a table descriptor element
	static CDXLTableDescr *MakeDXLTableDescr(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs);

	// create an index descriptor
	static CDXLIndexDescr *MakeDXLIndexDescr(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attrs);

	// create a column descriptor object
	static CDXLColDescr *MakeColumnDescr(CDXLMemoryManager *dxl_memory_manager,
										 const Attributes &attrs);

	// create a column reference object
	static CDXLColRef *MakeDXLColRef(CDXLMemoryManager *dxl_memory_manager,
									 const Attributes &, Edxltoken);

	// create a logical join
	static CDXLLogical *MakeLogicalJoin(CDXLMemoryManager *dxl_memory_manager,
										const Attributes &attrs);

	// parse an output segment index
	static INT ParseOutputSegId(CDXLMemoryManager *dxl_memory_manager,
								const Attributes &attrs);

	// parse a grouping column id
	static ULONG ParseGroupingColId(CDXLMemoryManager *dxl_memory_manager,
									const Attributes &attrs);

	// extracts the value for the given attribute.
	// if there is no such attribute defined, and the given optional
	// flag is set to false then it will raise an exception
	static const XMLCh *ExtractAttrValue(const Attributes &,
										 Edxltoken target_attr,
										 Edxltoken target_elem,
										 BOOL is_optional = false);

	// extracts the boolean value for the given attribute
	// will raise an exception if value cannot be converted to a boolean
	static BOOL ConvertAttrValueToBool(CDXLMemoryManager *dxl_memory_manager,
									   const XMLCh *xml_val,
									   Edxltoken target_attr,
									   Edxltoken target_elem);

	// converts the XMLCh into LINT
	static LINT ConvertAttrValueToLint(CDXLMemoryManager *dxl_memory_manager,
									   const XMLCh *xml_val,
									   Edxltoken target_attr,
									   Edxltoken target_elem);

	// extracts the LINT value for the given attribute
	static LINT ExtractConvertAttrValueToLint(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem, BOOL is_optional = false,
		LINT default_value = 0);

	// converts the XMLCh into CDouble
	static CDouble ConvertAttrValueToDouble(
		CDXLMemoryManager *dxl_memory_manager, const XMLCh *xml_val,
		Edxltoken target_attr, Edxltoken target_elem);

	// cxtracts the double value for the given attribute
	static CDouble ExtractConvertAttrValueToDouble(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem);

	// converts the XMLCh into ULONG. Will raise an exception if the
	// argument cannot be converted to ULONG
	static ULONG ConvertAttrValueToUlong(CDXLMemoryManager *dxl_memory_manager,
										 const XMLCh *xml_val,
										 Edxltoken target_attr,
										 Edxltoken target_elem);

	// converts the XMLCh into ULLONG. Will raise an exception if the
	// argument cannot be converted to ULLONG
	static ULLONG ConvertAttrValueToUllong(
		CDXLMemoryManager *dxl_memory_manager, const XMLCh *xml_val,
		Edxltoken target_attr, Edxltoken target_elem);

	// converts the XMLCh into INT. Will raise an exception if the
	// argument cannot be converted to INT
	static INT ConvertAttrValueToInt(CDXLMemoryManager *dxl_memory_manager,
									 const XMLCh *xml_val,
									 Edxltoken target_attr,
									 Edxltoken target_elem);

	// parse a INT value from the value for a given attribute
	// will raise an exception if the argument cannot be converted to INT
	static INT ExtractConvertAttrValueToInt(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem, BOOL is_optional = false,
		INT default_val = 0);

	// converts the XMLCh into short int. Will raise an exception if the
	// argument cannot be converted to short int
	static SINT ConvertAttrValueToShortInt(
		CDXLMemoryManager *dxl_memory_manager, const XMLCh *xml_val,
		Edxltoken target_attr, Edxltoken target_elem);

	// parse a short int value from the value for a given attribute
	// will raise an exception if the argument cannot be converted to short int
	static SINT ExtractConvertAttrValueToShortInt(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem, BOOL is_optional = false,
		SINT default_val = 0);

	// converts the XMLCh into char. Will raise an exception if the
	// argument cannot be converted to char
	static CHAR ConvertAttrValueToChar(CDXLMemoryManager *dxl_memory_manager,
									   const XMLCh *xml_val,
									   Edxltoken target_attr,
									   Edxltoken target_elem);

	// converts the XMLCh into oid. Will raise an exception if the
	// argument cannot be converted to OID
	static OID ConvertAttrValueToOid(CDXLMemoryManager *dxl_memory_manager,
									 const XMLCh *xml_val,
									 Edxltoken target_attr,
									 Edxltoken target_elem);

	// parse an oid value from the value for a given attribute
	// will raise an exception if the argument cannot be converted to OID
	static OID ExtractConvertAttrValueToOid(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem, BOOL is_optional = false,
		OID OidDefaultValue = 0);

	// parse a bool value from the value for a given attribute
	static BOOL ExtractConvertAttrValueToBool(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem, BOOL is_optional = false,
		BOOL default_value = false);

	// parse a string value from the value for a given attribute
	static CHAR *ExtractConvertAttrValueToSz(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem, BOOL is_optional = false,
		CHAR *default_value = nullptr);

	// parse a string value from the value for a given attribute
	static CHAR *ConvertAttrValueToSz(CDXLMemoryManager *dxl_memory_manager,
									  const XMLCh *xml_val,
									  Edxltoken target_attr,
									  Edxltoken target_elem);

	// parse a string value from the value for a given attribute
	static CWStringDynamic *ExtractConvertAttrValueToStr(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem);

	// parse a ULONG value from the value for a given attribute
	// will raise an exception if the argument cannot be converted to ULONG
	static ULONG ExtractConvertAttrValueToUlong(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem, BOOL is_optional = false,
		ULONG default_value = 0);

	// parse a ULLONG value from the value for a given attribute
	// will raise an exception if the argument cannot be converted to ULLONG
	static ULLONG ExtractConvertAttrValueToUllong(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem, BOOL is_optional = false,
		ULLONG default_value = 0);

	// parse an mdid object from the given attributes
	static IMDId *ExtractConvertAttrValueToMdId(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem, BOOL is_optional = false,
		IMDId *default_val = nullptr);

	// parse an mdid object from an XMLCh
	static IMDId *MakeMdIdFromStr(CDXLMemoryManager *dxl_memory_manager,
								  const XMLCh *mdid_xml, Edxltoken target_attr,
								  Edxltoken target_elem);

	// parse a GPDB mdid object from an array of its components
	static CMDIdGPDB *GetGPDBMdId(CDXLMemoryManager *dxl_memory_manager,
								  XMLChArray *remaining_tokens,
								  Edxltoken target_attr, Edxltoken target_elem);

	// parse a GPDB CTAS mdid object from an array of its components
	static CMDIdGPDB *GetGPDBCTASMdId(CDXLMemoryManager *dxl_memory_manager,
									  XMLChArray *remaining_tokens,
									  Edxltoken target_attr,
									  Edxltoken target_elem);

	// parse a column stats mdid object from an array of its components
	static CMDIdColStats *GetColStatsMdId(CDXLMemoryManager *dxl_memory_manager,
										  XMLChArray *remaining_tokens,
										  Edxltoken target_attr,
										  Edxltoken target_elem);

	// parse a relation stats mdid object from an array of its components
	static CMDIdRelStats *GetRelStatsMdId(CDXLMemoryManager *dxl_memory_manager,
										  XMLChArray *remaining_tokens,
										  Edxltoken target_attr,
										  Edxltoken target_elem);

	// parse a cast func mdid from the array of its components
	static CMDIdCast *GetCastFuncMdId(CDXLMemoryManager *dxl_memory_manager,
									  XMLChArray *remaining_tokens,
									  Edxltoken target_attr,
									  Edxltoken target_elem);

	// parse a comparison operator mdid from the array of its components
	static CMDIdScCmp *GetScCmpMdId(CDXLMemoryManager *dxl_memory_manager,
									XMLChArray *remaining_tokens,
									Edxltoken target_attr,
									Edxltoken target_elem);

	// parse a dxl datum object
	static CDXLDatum *GetDatumVal(CDXLMemoryManager *dxl_memory_manager,
								  const Attributes &attrs,
								  Edxltoken target_elem);

	// parse a comma-separated list of MDids into a dynamic array
	// will raise an exception if list is not well-formed
	static IMdIdArray *ExtractConvertMdIdsToArray(
		CDXLMemoryManager *dxl_memory_manager, const XMLCh *mdid_list_xml,
		Edxltoken target_attr, Edxltoken target_elem);

	// parse a comma-separated list of unsigned long numbers into a dynamic array
	// will raise an exception if list is not well-formed
	static ULongPtrArray *ExtractConvertValuesToArray(
		CDXLMemoryManager *dxl_memory_manager, const Attributes &attr,
		Edxltoken target_attr, Edxltoken target_elem);

	// parse a comma-separated list of integers numbers into a dynamic array
	// will raise an exception if list is not well-formed
	template <typename T, void (*CleanupFn)(T *),
			  T ValueFromXmlstr(CDXLMemoryManager *, const XMLCh *, Edxltoken,
								Edxltoken)>
	static CDynamicPtrArray<T, CleanupFn> *ExtractIntsToArray(
		CDXLMemoryManager *dxl_memory_manager, const XMLCh *xmlszUl,
		Edxltoken target_attr, Edxltoken target_elem);

	static ULongPtrArray *
	ExtractIntsToUlongArray(CDXLMemoryManager *dxl_memory_manager,
							const XMLCh *xmlszUl, Edxltoken target_attr,
							Edxltoken target_elem)
	{
		return ExtractIntsToArray<ULONG, CleanupDelete,
								  ConvertAttrValueToUlong>(
			dxl_memory_manager, xmlszUl, target_attr, target_elem);
	}

	static IntPtrArray *
	ExtractIntsToIntArray(CDXLMemoryManager *dxl_memory_manager,
						  const XMLCh *xmlszUl, Edxltoken target_attr,
						  Edxltoken target_elem)
	{
		return ExtractIntsToArray<INT, CleanupDelete, ConvertAttrValueToInt>(
			dxl_memory_manager, xmlszUl, target_attr, target_elem);
	}

	// parse a comma-separated list of CHAR partition types into a dynamic array.
	// will raise an exception if list is not well-formed
	static CharPtrArray *ExtractConvertPartitionTypeToArray(
		CDXLMemoryManager *dxl_memory_manager, const XMLCh *xml_val,
		Edxltoken target_attr, Edxltoken target_elem);

	// parse a semicolon-separated list of comma-separated unsigned
	// long numbers into a dynamc array of unsigned integer arrays
	// will raise an exception if list is not well-formed
	static ULongPtr2dArray *ExtractConvertUlongTo2DArray(
		CDXLMemoryManager *dxl_memory_manager, const XMLCh *xml_val,
		Edxltoken target_attr, Edxltoken target_elem);

	// parse a comma-separated list of segment ids into a dynamic array
	// will raise an exception if list is not well-formed
	static IntPtrArray *ExtractConvertSegmentIdsToArray(
		CDXLMemoryManager *dxl_memory_manager, const XMLCh *seg_id_list_xml,
		Edxltoken target_attr, Edxltoken target_elem);

	// parse a comma-separated list of strings into a dynamic array
	// will raise an exception if list is not well-formed
	static StringPtrArray *ExtractConvertStrsToArray(
		CDXLMemoryManager *dxl_memory_manager, const XMLCh *xml_val);

	// parses the input and output segment ids from Xerces attributes and
	// stores them in the provided DXL Motion operator
	// will raise an exception if lists are not well-formed
	static void SetSegmentInfo(CDXLMemoryManager *mp,
							   CDXLPhysicalMotion *motion,
							   const Attributes &attrs, Edxltoken target_elem);

	static EdxlJoinType ParseJoinType(const XMLCh *xmlszJoinType,
									  const CWStringConst *join_name);

	static EdxlIndexScanDirection ParseIndexScanDirection(
		const XMLCh *direction_xml,
		const CWStringConst *pstrIndexScanDirection);

	// parse system id
	static CSystemId Sysid(CDXLMemoryManager *dxl_memory_manager,
						   const Attributes &attrs, Edxltoken target_attr,
						   Edxltoken target_elem);

	// parse the frame boundary
	static EdxlFrameBoundary ParseDXLFrameBoundary(const Attributes &attrs,
												   Edxltoken token_type);

	// parse the frame specification
	static EdxlFrameSpec ParseDXLFrameSpec(const Attributes &attrs);

	// parse the frame exclusion strategy
	static EdxlFrameExclusionStrategy ParseFrameExclusionStrategy(
		const Attributes &attrs);

	// parse comparison operator type
	static IMDType::ECmpType ParseCmpType(const XMLCh *xml_str_comp_type);

	// parse the distribution policy from the given XML string
	static IMDRelation::Ereldistrpolicy ParseRelationDistPolicy(
		const XMLCh *xml_val);

	// parse the storage type from the given XML string
	static IMDRelation::Erelstoragetype ParseRelationStorageType(
		const XMLCh *xml_val);

	// parse the OnCommit action spec for CTAS
	static CDXLCtasStorageOptions::ECtasOnCommitAction ParseOnCommitActionSpec(
		const Attributes &attr);

	// parse index type
	static IMDIndex::EmdindexType ParseIndexType(const Attributes &attrs);
};

// parse a comma-separated list of integers numbers into a dynamic array
// will raise an exception if list is not well-formed
template <typename T, void (*CleanupFn)(T *),
		  T ValueFromXmlstr(CDXLMemoryManager *, const XMLCh *, Edxltoken,
							Edxltoken)>
CDynamicPtrArray<T, CleanupFn> *
CDXLOperatorFactory::ExtractIntsToArray(CDXLMemoryManager *dxl_memory_manager,
										const XMLCh *mdid_list_xml,
										Edxltoken target_attr,
										Edxltoken target_elem)
{
	// get the memory pool from the memory manager
	CMemoryPool *mp = dxl_memory_manager->Pmp();

	CDynamicPtrArray<T, CleanupFn> *pdrgpt =
		GPOS_NEW(mp) CDynamicPtrArray<T, CleanupFn>(mp);

	XMLStringTokenizer mdid_components(mdid_list_xml,
									   CDXLTokens::XmlstrToken(EdxltokenComma));
	const ULONG num_tokens = mdid_components.countTokens();

	for (ULONG ul = 0; ul < num_tokens; ul++)
	{
		XMLCh *xmlszNext = mdid_components.nextToken();

		GPOS_ASSERT(nullptr != xmlszNext);

		T *pt = GPOS_NEW(mp) T(ValueFromXmlstr(dxl_memory_manager, xmlszNext,
											   target_attr, target_elem));
		pdrgpt->Append(pt);
	}

	return pdrgpt;
}
}  // namespace gpdxl

#endif	// !GPDXL_CDXLOperatorFactory_H

// EOF

相关信息

greenplumn 源码目录

相关文章

greenplumn CDXLColDescr 源码

greenplumn CDXLColRef 源码

greenplumn CDXLCtasStorageOptions 源码

greenplumn CDXLDatum 源码

greenplumn CDXLDatumBool 源码

greenplumn CDXLDatumGeneric 源码

greenplumn CDXLDatumInt2 源码

greenplumn CDXLDatumInt4 源码

greenplumn CDXLDatumInt8 源码

greenplumn CDXLDatumOid 源码