greenplumn CTranslatorUtils 源码
greenplumn CTranslatorUtils 代码
文件路径：/src/include/gpopt/translate/CTranslatorUtils.h
//---------------------------------------------------------------------------
// Greenplum Database
// Copyright (C) 2012 EMC Corp.
//
// @filename:
// CTranslatorUtils.h
//
// @doc:
// Class providing utility methods for translating GPDB's PlannedStmt/Query
// into DXL Tree
//
// @test:
//
//---------------------------------------------------------------------------
#ifndef GPDXL_CTranslatorUtils_H
#define GPDXL_CTranslatorUtils_H
#define GPDXL_SYSTEM_COLUMNS 8
extern "C" {
#include "postgres.h"
#include "access/sdir.h"
#include "access/skey.h"
#include "nodes/parsenodes.h"
}
#include "gpos/base.h"
#include "gpos/common/CBitSet.h"
#include "gpopt/translate/CMappingVarColId.h"
#include "naucrates/dxl/CIdGenerator.h"
#include "naucrates/dxl/operators/CDXLIndexDescr.h"
#include "naucrates/dxl/operators/CDXLLogicalSetOp.h"
#include "naucrates/dxl/operators/CDXLLogicalTVF.h"
#include "naucrates/dxl/operators/CDXLPhysicalDML.h"
#include "naucrates/dxl/operators/CDXLPhysicalMotion.h"
#include "naucrates/dxl/operators/CDXLScalarAggref.h"
#include "naucrates/dxl/operators/CDXLScalarSubPlan.h"
#include "naucrates/md/CMDRelationGPDB.h"
#include "naucrates/md/IMDType.h"
#include "naucrates/statistics/IStatistics.h"
// fwd declarations
namespace gpopt
{
class CMDAccessor;
// dynamic array of bitsets
using CBitSetArray = CDynamicPtrArray<CBitSet, CleanupRelease>;
} // namespace gpopt
namespace gpdxl
{
class CDXLTranslateContext;
}
namespace gpdxl
{
using namespace gpopt;
enum DistributionHashOpsKind
{
DistrHashOpsNotDeterminedYet,
DistrUseDefaultHashOps,
DistrUseLegacyHashOps
};
//---------------------------------------------------------------------------
// @class:
// CTranslatorUtils
//
// @doc:
// Class providing methods for translating GPDB's PlannedStmt/Query
// into DXL Tree
//
//---------------------------------------------------------------------------
class CTranslatorUtils
{
private:
// Construct a set of column attnos corresponding to a single grouping set
// from either a plain GROUP BY or one set in a list of grouping sets
static CBitSet *CreateAttnoSetForGroupingSet(CMemoryPool *mp,
List *group_elems,
ULONG num_cols,
UlongToUlongMap *group_col_pos,
CBitSet *group_cols,
bool use_group_clause);
// check if the given mdid array contains any of the polymorphic
// types (ANYELEMENT, ANYARRAY)
static BOOL ContainsPolymorphicTypes(IMdIdArray *mdid_array);
// resolve polymorphic types in the given array of type ids, replacing
// them with the actual types obtained from the query
static IMdIdArray *ResolvePolymorphicTypes(CMemoryPool *mp,
IMdIdArray *return_arg_mdids,
List *input_arg_types,
FuncExpr *funcexpr);
// update grouping col position mappings
static void UpdateGrpColMapping(CMemoryPool *mp,
UlongToUlongMap *grouping_col_to_pos_map,
CBitSet *group_cols, ULONG sort_group_ref);
// create a set of grouping sets for a rollup
static CBitSetArray *CreateGroupingSetsForRollup(
CMemoryPool *mp, const GroupingSet *grouping_set, ULONG num_cols,
CBitSet *group_cols, UlongToUlongMap *group_col_pos);
// create a set of grouping sets for a grouping sets subclause
static CBitSetArray *CreateGroupingSetsForSets(
CMemoryPool *mp, const GroupingSet *grouping_set_node, ULONG num_cols,
CBitSet *group_cols, UlongToUlongMap *group_col_pos);
public:
struct SCmptypeStrategy
{
IMDType::ECmpType comptype;
StrategyNumber strategy_no;
};
// get the GPDB scan direction from its corresponding DXL representation
static ScanDirection GetScanDirection(
EdxlIndexScanDirection idx_scan_direction);
// get the oid of comparison operator
static OID OidCmpOperator(Expr *expr);
// get the opfamily for index key
static OID GetOpFamilyForIndexQual(INT attno, OID oid_index);
// return the type for the system column with the given number
static CMDIdGPDB *GetSystemColType(CMemoryPool *mp, AttrNumber attno);
// find the n-th column descriptor in the table descriptor
static const CDXLColDescr *GetColumnDescrAt(
const CDXLTableDescr *table_descr, ULONG pos);
// return the name for the system column with given number
static const CWStringConst *GetSystemColName(AttrNumber attno);
// returns the length for the system column with given attno number
static const ULONG GetSystemColLength(AttrNumber attno);
// translate the join type from its GPDB representation into the DXL one
static EdxlJoinType ConvertToDXLJoinType(JoinType jt);
// translate the index scan direction from its GPDB representation into the DXL one
static EdxlIndexScanDirection ConvertToDXLIndexScanDirection(
ScanDirection sd);
// create a DXL index descriptor from an index MD id
static CDXLIndexDescr *GetIndexDescr(CMemoryPool *mp,
CMDAccessor *md_accessor, IMDId *mdid);
// translate a RangeTableEntry into a CDXLTableDescr
static CDXLTableDescr *GetTableDescr(CMemoryPool *mp,
CMDAccessor *md_accessor,
CIdGenerator *id_generator,
const RangeTblEntry *rte,
BOOL *is_distributed_table = nullptr);
// translate a RangeTableEntry into a CDXLLogicalTVF
static CDXLLogicalTVF *ConvertToCDXLLogicalTVF(CMemoryPool *mp,
CMDAccessor *md_accessor,
CIdGenerator *id_generator,
const RangeTblEntry *rte);
// get column descriptors from a record type
static CDXLColDescrArray *GetColumnDescriptorsFromRecord(
CMemoryPool *mp, CIdGenerator *id_generator, List *col_names,
List *col_types, List *col_type_modifiers);
// get column descriptors from a record type
static CDXLColDescrArray *GetColumnDescriptorsFromRecord(
CMemoryPool *mp, CIdGenerator *id_generator, List *col_names,
IMdIdArray *out_arg_types);
// get column descriptor from a base type
static CDXLColDescrArray *GetColumnDescriptorsFromBase(
CMemoryPool *mp, CIdGenerator *id_generator, IMDId *mdid_return_type,
INT type_modifier, CMDName *md_name);
// get column descriptors from a composite type
static CDXLColDescrArray *GetColumnDescriptorsFromComposite(
CMemoryPool *mp, CMDAccessor *md_accessor, CIdGenerator *id_generator,
const IMDType *md_type);
// expand a composite type into an array of IMDColumns
static CMDColumnArray *ExpandCompositeType(CMemoryPool *mp,
CMDAccessor *md_accessor,
const IMDType *md_type);
// return the dxl representation of the set operation
static EdxlSetOpType GetSetOpType(SetOperation setop, BOOL is_all);
// construct a dynamic array of sets of column attnos corresponding
// to the group by clause
static CBitSetArray *GetColumnAttnosForGroupBy(
CMemoryPool *mp, List *group_clause, List *grouping_set_list,
ULONG num_cols, UlongToUlongMap *group_col_pos, CBitSet *group_cold);
// return a copy of the query with constant of unknown type being coerced
// to the common data type of the output target list
static Query *FixUnknownTypeConstant(Query *query, List *target_list);
// return the type of the nth non-resjunked target list entry
static OID GetTargetListReturnTypeOid(List *target_list, ULONG col_pos);
// construct an array of DXL column identifiers for a target list
static ULongPtrArray *GenerateColIds(CMemoryPool *mp, List *target_list,
IMdIdArray *input_mdids,
ULongPtrArray *input_nums,
const BOOL *is_outer_ref,
CIdGenerator *colid_generator);
// construct an array of DXL column descriptors for a target list
// using the column ids in the given array
static CDXLColDescrArray *GetDXLColumnDescrArray(CMemoryPool *mp,
List *target_list,
ULongPtrArray *colids,
BOOL keep_res_junked);
// return the positions of the target list entries included in the output
static ULongPtrArray *GetPosInTargetList(CMemoryPool *mp, List *target_list,
BOOL keep_res_junked);
// construct a column descriptor from the given target entry, column identifier and position in the output
static CDXLColDescr *GetColumnDescrAt(CMemoryPool *mp,
TargetEntry *target_entry,
ULONG colid, ULONG pos);
// create a dummy project element to rename the input column identifier
static CDXLNode *CreateDummyProjectElem(CMemoryPool *mp, ULONG colid_input,
ULONG colid_output,
CDXLColDescr *dxl_col_descr);
// construct a list of colids corresponding to the given target list
// using the given attno->colid map
static ULongPtrArray *GetOutputColIdsArray(
CMemoryPool *mp, List *target_list, IntToUlongMap *attno_to_colid_map);
// construct an array of column ids for the given group by set
static ULongPtrArray *GetGroupingColidArray(
CMemoryPool *mp, CBitSet *group_by_cols,
IntToUlongMap *sort_group_cols_to_colid_map);
// return the Colid of column with given index
static ULONG GetColId(INT index, IntToUlongMap *index_to_colid_map);
// return the corresponding ColId for the given varno, varattno and querylevel
static ULONG GetColId(ULONG query_level, INT varno, INT var_attno,
IMDId *mdid, CMappingVarColId *var_colid_mapping);
// check to see if the target list entry is a sorting column
static BOOL IsSortingColumn(const TargetEntry *target_entry,
List *sort_clause_list);
// check to see if the target list entry is used in the window reference
static BOOL IsReferencedInWindowSpec(const TargetEntry *target_entry,
List *window_clause_list);
// check if the project list contains AggRef with ORDER BY
static BOOL HasOrderedAggRefInProjList(CDXLNode *proj_list_dxlnode);
// extract a matching target entry that is a window spec
static TargetEntry *GetWindowSpecTargetEntry(Node *node,
List *window_clause_list,
List *target_list);
// create a scalar const value expression for the given int8 value
static CDXLNode *CreateDXLProjElemFromInt8Const(CMemoryPool *mp,
CMDAccessor *md_accessor,
INT val);
// check to see if the target list entry is a grouping column
static BOOL IsGroupingColumn(const TargetEntry *target_entry,
List *group_clause_list);
// check to see if the target list entry is a grouping column
static BOOL IsGroupingColumn(const TargetEntry *target_entry,
const SortGroupClause *sort_group_clause);
// check if the expression has a matching target entry that is a grouping column
static BOOL IsGroupingColumn(Node *node, List *group_clause_list,
List *target_list);
// extract a matching target entry that is a grouping column
static TargetEntry *GetGroupingColumnTargetEntry(Node *node,
List *group_clause_list,
List *target_list);
// convert a list of column ids to a list of attribute numbers using
// the provided context with mappings
static List *ConvertColidToAttnos(ULongPtrArray *pdrgpul,
CDXLTranslateContext *dxl_translate_ctxt);
// parse string value into a Long Integer
static LINT GetLongFromStr(const CWStringBase *wcstr);
// parse string value into an Integer
static INT GetIntFromStr(const CWStringBase *wcstr);
// check whether the given project list has a project element of the given
// operator type
static BOOL HasProjElem(CDXLNode *project_list_dxlnode, Edxlopid dxl_op_id);
// create a multi-byte character string from a wide character string
static CHAR *CreateMultiByteCharStringFromWCString(const WCHAR *wcstr);
static UlongToUlongMap *MakeNewToOldColMapping(CMemoryPool *mp,
ULongPtrArray *old_colids,
ULongPtrArray *new_colids);
// check if the given tree contains a subquery
static BOOL HasSubquery(Node *node);
// check if the given function is a SIRV (single row volatile) that reads
// or modifies SQL data
static BOOL IsSirvFunc(CMemoryPool *mp, CMDAccessor *md_accessor,
OID func_oid);
// is this a motion sensitive to duplicates
static BOOL IsDuplicateSensitiveMotion(
gpdxl::CDXLPhysicalMotion *dxl_motion);
// construct a project element with a const NULL expression
static CDXLNode *CreateDXLProjElemConstNULL(CMemoryPool *mp,
CMDAccessor *md_accessor,
IMDId *mdid, ULONG colid,
const WCHAR *col_name);
// construct a project element with a const NULL expression
static CDXLNode *CreateDXLProjElemConstNULL(CMemoryPool *mp,
CMDAccessor *md_accessor,
IMDId *mdid, ULONG colid,
CHAR *alias_name);
// create a DXL project element node with a Const NULL of type provided
// by the column descriptor
static CDXLNode *CreateDXLProjElemConstNULL(CMemoryPool *mp,
CMDAccessor *md_accessor,
CIdGenerator *colid_generator,
const IMDColumn *col);
// check required permissions for the range table
static void CheckRTEPermissions(List *range_table_list);
// check if given column ids are outer references in the tree rooted by given node
static void MarkOuterRefs(ULONG *colid, BOOL *is_outer_ref,
ULONG num_columns, CDXLNode *node);
// map DXL Subplan type to GPDB SubLinkType
static SubLinkType MapDXLSubplanToSublinkType(
gpdxl::EdxlSubPlanType dxl_subplan_type);
// map GPDB SubLinkType to DXL Subplan type
static EdxlSubPlanType MapSublinkTypeToDXLSubplan(SubLinkType slink);
// check whether there are triggers for the given operation on
// the given relation
static BOOL RelHasTriggers(CMemoryPool *mp, CMDAccessor *md_accessor,
const IMDRelation *mdrel,
const gpdxl::EdxlDmlType dml_type_dxl);
// check whether the given trigger is applicable to the given DML operation
static BOOL IsApplicableTrigger(CMDAccessor *md_accessor,
IMDId *trigger_mdid,
const gpdxl::EdxlDmlType dml_type_dxl);
// check whether there are NOT NULL or CHECK constraints for the given relation
static BOOL RelHasConstraints(const IMDRelation *rel);
// translate the list of error messages from an assert constraint list
static List *GetAssertErrorMsgs(CDXLNode *assert_constraint_list);
// return the count of non-system columns in the relation
static ULONG GetNumNonSystemColumns(const IMDRelation *mdrel);
// return agg kind as an EdxlAggrefKind
static EdxlAggrefKind GetAggKind(CHAR aggkind);
// return agg kind as a CHAR
static CHAR GetAggKind(EdxlAggrefKind aggkind);
// check if const func returns composite type
static BOOL IsCompositeConst(CMemoryPool *mp, CMDAccessor *md_accessor,
const RangeTblFunction *rtfunc);
};
} // namespace gpdxl
#endif // !GPDXL_CTranslatorUtils_H
// EOF
相关信息
相关文章
greenplumn CContextDXLToPlStmt 源码
greenplumn CContextQueryToDXL 源码
greenplumn CDXLTranslateContext 源码
greenplumn CDXLTranslateContextBaseTable 源码
0
赞
热门推荐
-
2、 - 优质文章
-
3、 gate.io
-
8、 golang
-
9、 openharmony
-
10、 Vue中input框自动聚焦