Skip to content

G
Gpdb

Greenplum / Gpdb

通知 7
Star 1
Fork 0
G
Gpdb

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 219fe0c4 编写于 作者: J Jesse Zhang
浏览文件
操作

Format ORCA and GPOPT. 

The canonical config file is in src/backend/gpopt/.clang-format (instead
of under the non-existent src/backend/gporca), I've created one (instead
of two) symlink, for GPOPT headers. Care has been taken to repoint the
symlink to the canonical config under gpopt, instead of gpopt as it is
under HEAD.

This is spiritually a cherry-pick of commit 2f7dd76c.
(cherry picked from commit 2f7dd76c)
上级 8b7421b2
展开全部 显示空白变更内容
内联 并排
Showing with 11911 addition and 14407 deletion
src/backend/gpopt/CGPOptimizer.cpp
浏览文件 @ 219fe0c4
......@@ -40,24 +40,26 @@ extern MemoryContext MessageContext;
//
//---------------------------------------------------------------------------
PlannedStmt *
CGPOptimizer::GPOPTOptimizedPlan
(
CGPOptimizer::GPOPTOptimizedPlan(
Query *query,
bool *had_unexpected_failure // output : set to true if optimizer unexpectedly failed to produce plan
)
bool *
had_unexpected_failure // output : set to true if optimizer unexpectedly failed to produce plan
)
{
SOptContext gpopt_context;
PlannedStmt* plStmt = NULL;
PlannedStmt *plStmt = NULL;
GPOS_TRY
{
plStmt = COptTasks::GPOPTOptimizedPlan(query, &gpopt_context, had_unexpected_failure);
plStmt = COptTasks::GPOPTOptimizedPlan(query, &gpopt_context,
had_unexpected_failure);
// clean up context
gpopt_context.Free(gpopt_context.epinQuery, gpopt_context.epinPlStmt);
}
GPOS_CATCH_EX(ex)
{
// clone the error message before context free.
CHAR* serialized_error_msg = gpopt_context.CloneErrorMsg(MessageContext);
CHAR *serialized_error_msg =
gpopt_context.CloneErrorMsg(MessageContext);
// clean up context
gpopt_context.Free(gpopt_context.epinQuery, gpopt_context.epinPlStmt);
......@@ -66,7 +68,8 @@ CGPOptimizer::GPOPTOptimizedPlan
// tries to do something smart with them. Also, ERRCODE_INTERNAL_ERROR
// is handled specially in elog.c, and we don't want that for "normal"
// application errors.
if (GPOS_MATCH_EX(ex, gpdxl::ExmaDXL, gpdxl::ExmiQuery2DXLNotNullViolation))
if (GPOS_MATCH_EX(ex, gpdxl::ExmaDXL,
gpdxl::ExmiQuery2DXLNotNullViolation))
{
errstart(ERROR, ex.Filename(), ex.Line(), NULL, TEXTDOMAIN);
errfinish(errcode(ERRCODE_NOT_NULL_VIOLATION),
......@@ -85,17 +88,21 @@ CGPOptimizer::GPOPTOptimizedPlan
{
PG_RE_THROW();
}
else if (GPOS_MATCH_EX(ex, gpdxl::ExmaDXL, gpdxl::ExmiNoAvailableMemory))
else if (GPOS_MATCH_EX(ex, gpdxl::ExmaDXL,
gpdxl::ExmiNoAvailableMemory))
{
errstart(ERROR, ex.Filename(), ex.Line(), NULL, TEXTDOMAIN);
errfinish(errcode(ERRCODE_INTERNAL_ERROR),
errmsg("No available memory to allocate string buffer."));
}
else if (GPOS_MATCH_EX(ex, gpdxl::ExmaDXL, gpdxl::ExmiInvalidComparisonTypeCode))
else if (GPOS_MATCH_EX(ex, gpdxl::ExmaDXL,
gpdxl::ExmiInvalidComparisonTypeCode))
{
errstart(ERROR, ex.Filename(), ex.Line(), NULL, TEXTDOMAIN);
errfinish(errcode(ERRCODE_INTERNAL_ERROR),
errmsg("Invalid comparison type code. Valid values are Eq, NEq, LT, LEq, GT, GEq."));
errfinish(
errcode(ERRCODE_INTERNAL_ERROR),
errmsg(
"Invalid comparison type code. Valid values are Eq, NEq, LT, LEq, GT, GEq."));
}
}
GPOS_CATCH_END;
......@@ -112,10 +119,7 @@ CGPOptimizer::GPOPTOptimizedPlan
//
//---------------------------------------------------------------------------
char *
CGPOptimizer::SerializeDXLPlan
(
Query *query
)
CGPOptimizer::SerializeDXLPlan(Query *query)
{
return COptTasks::Optimize(query);
}
......@@ -129,9 +133,8 @@ CGPOptimizer::SerializeDXLPlan
//
//---------------------------------------------------------------------------
void
CGPOptimizer::InitGPOPT ()
CGPOptimizer::InitGPOPT()
{
if (optimizer_use_gpdb_allocators)
{
CMemoryPoolPallocManager::Init();
......@@ -153,7 +156,7 @@ CGPOptimizer::InitGPOPT ()
//
//---------------------------------------------------------------------------
void
CGPOptimizer::TerminateGPOPT ()
CGPOptimizer::TerminateGPOPT()
{
gpopt_terminate();
gpdxl_terminate();
......@@ -168,13 +171,9 @@ CGPOptimizer::TerminateGPOPT ()
// Expose GP optimizer API to C files
//
//---------------------------------------------------------------------------
extern "C"
{
PlannedStmt *GPOPTOptimizedPlan
(
Query *query,
bool *had_unexpected_failure
)
extern "C" {
PlannedStmt *
GPOPTOptimizedPlan(Query *query, bool *had_unexpected_failure)
{
return CGPOptimizer::GPOPTOptimizedPlan(query, had_unexpected_failure);
}
......@@ -188,12 +187,9 @@ PlannedStmt *GPOPTOptimizedPlan
// Serialize planned statement to DXL
//
//---------------------------------------------------------------------------
extern "C"
{
char *SerializeDXLPlan
(
Query *query
)
extern "C" {
char *
SerializeDXLPlan(Query *query)
{
return CGPOptimizer::SerializeDXLPlan(query);
}
......@@ -207,9 +203,9 @@ char *SerializeDXLPlan
// Initialize GPTOPT and dependent libraries
//
//---------------------------------------------------------------------------
extern "C"
{
void InitGPOPT ()
extern "C" {
void
InitGPOPT()
{
GPOS_TRY
{
......@@ -234,9 +230,9 @@ void InitGPOPT ()
// Terminate GPOPT and dependent libraries
//
//---------------------------------------------------------------------------
extern "C"
{
void TerminateGPOPT ()
extern "C" {
void
TerminateGPOPT()
{
GPOS_TRY
{
......
src/backend/gpopt/gpdbwrappers.cpp
浏览文件 @ 219fe0c4
此差异已折叠。
src/backend/gpopt/relcache/CMDProviderRelcache.cpp
浏览文件 @ 219fe0c4
......@@ -35,12 +35,7 @@ using namespace gpmd;
// Constructs a file-based metadata provider
//
//---------------------------------------------------------------------------
CMDProviderRelcache::CMDProviderRelcache
(
CMemoryPool *mp
)
:
m_mp(mp)
CMDProviderRelcache::CMDProviderRelcache(CMemoryPool *mp) : m_mp(mp)
{
GPOS_ASSERT(NULL != m_mp);
}
......@@ -54,19 +49,16 @@ CMDProviderRelcache::CMDProviderRelcache
//
//---------------------------------------------------------------------------
CWStringBase *
CMDProviderRelcache::GetMDObjDXLStr
(
CMemoryPool *mp,
CMDAccessor *md_accessor,
IMDId *md_id
)
const
CMDProviderRelcache::GetMDObjDXLStr(CMemoryPool *mp, CMDAccessor *md_accessor,
IMDId *md_id) const
{
IMDCacheObject *md_obj = CTranslatorRelcacheToDXL::RetrieveObject(mp, md_accessor, md_id);
IMDCacheObject *md_obj =
CTranslatorRelcacheToDXL::RetrieveObject(mp, md_accessor, md_id);
GPOS_ASSERT(NULL != md_obj);
CWStringDynamic *str = CDXLUtils::SerializeMDObj(m_mp, md_obj, true /*fSerializeHeaders*/, false /*findent*/);
CWStringDynamic *str = CDXLUtils::SerializeMDObj(
m_mp, md_obj, true /*fSerializeHeaders*/, false /*findent*/);
// cleanup DXL object
md_obj->Release();
......
src/backend/gpopt/translate/CCTEListEntry.cpp
浏览文件 @ 219fe0c4
......@@ -31,26 +31,21 @@ using namespace gpdxl;
// Ctor: single CTE
//
//---------------------------------------------------------------------------
CCTEListEntry::CCTEListEntry
(
CMemoryPool *mp,
ULONG query_level,
CommonTableExpr *cte,
CDXLNode *cte_producer
)
:
m_query_level(query_level),
m_cte_info(NULL)
CCTEListEntry::CCTEListEntry(CMemoryPool *mp, ULONG query_level,
CommonTableExpr *cte, CDXLNode *cte_producer)
: m_query_level(query_level), m_cte_info(NULL)
{
GPOS_ASSERT(NULL != cte && NULL != cte_producer);
m_cte_info = GPOS_NEW(mp) HMSzCTEInfo(mp);
Query *cte_query = (Query*) cte->ctequery;
Query *cte_query = (Query *) cte->ctequery;
#ifdef GPOS_DEBUG
BOOL result =
#endif
m_cte_info->Insert(cte->ctename, GPOS_NEW(mp) SCTEProducerInfo(cte_producer, cte_query->targetList));
m_cte_info->Insert(
cte->ctename,
GPOS_NEW(mp) SCTEProducerInfo(cte_producer, cte_query->targetList));
GPOS_ASSERT(result);
}
......@@ -63,16 +58,9 @@ CCTEListEntry::CCTEListEntry
// Ctor: multiple CTEs
//
//---------------------------------------------------------------------------
CCTEListEntry::CCTEListEntry
(
CMemoryPool *mp,
ULONG query_level,
List *cte_list,
CDXLNodeArray *cte_dxl_arr
)
:
m_query_level(query_level),
m_cte_info(NULL)
CCTEListEntry::CCTEListEntry(CMemoryPool *mp, ULONG query_level, List *cte_list,
CDXLNodeArray *cte_dxl_arr)
: m_query_level(query_level), m_cte_info(NULL)
{
GPOS_ASSERT(NULL != cte_dxl_arr);
GPOS_ASSERT(cte_dxl_arr->Size() == gpdb::ListLength(cte_list));
......@@ -83,14 +71,16 @@ CCTEListEntry::CCTEListEntry
for (ULONG ul = 0; ul < num_cte; ul++)
{
CDXLNode *cte_producer = (*cte_dxl_arr)[ul];
CommonTableExpr *cte = (CommonTableExpr*) gpdb::ListNth(cte_list, ul);
CommonTableExpr *cte = (CommonTableExpr *) gpdb::ListNth(cte_list, ul);
Query *cte_query = (Query*) cte->ctequery;
Query *cte_query = (Query *) cte->ctequery;
#ifdef GPOS_DEBUG
BOOL result =
#endif
m_cte_info->Insert(cte->ctename, GPOS_NEW(mp) SCTEProducerInfo(cte_producer, cte_query->targetList));
m_cte_info->Insert(cte->ctename,
GPOS_NEW(mp) SCTEProducerInfo(
cte_producer, cte_query->targetList));
GPOS_ASSERT(result);
GPOS_ASSERT(NULL != m_cte_info->Find(cte->ctename));
......@@ -106,11 +96,7 @@ CCTEListEntry::CCTEListEntry
//
//---------------------------------------------------------------------------
const CDXLNode *
CCTEListEntry::GetCTEProducer
(
const CHAR *cte_str
)
const
CCTEListEntry::GetCTEProducer(const CHAR *cte_str) const
{
SCTEProducerInfo *cte_info = m_cte_info->Find(cte_str);
if (NULL == cte_info)
......@@ -130,11 +116,7 @@ CCTEListEntry::GetCTEProducer
//
//---------------------------------------------------------------------------
List *
CCTEListEntry::GetCTEProducerTargetList
(
const CHAR *cte_str
)
const
CCTEListEntry::GetCTEProducerTargetList(const CHAR *cte_str) const
{
SCTEProducerInfo *cte_info = m_cte_info->Find(cte_str);
if (NULL == cte_info)
......@@ -154,20 +136,19 @@ CCTEListEntry::GetCTEProducerTargetList
//
//---------------------------------------------------------------------------
void
CCTEListEntry::AddCTEProducer
(
CMemoryPool *mp,
CommonTableExpr *cte,
const CDXLNode *cte_producer
)
CCTEListEntry::AddCTEProducer(CMemoryPool *mp, CommonTableExpr *cte,
const CDXLNode *cte_producer)
{
GPOS_ASSERT(NULL == m_cte_info->Find(cte->ctename) && "CTE entry already exists");
Query *cte_query = (Query*) cte->ctequery;
GPOS_ASSERT(NULL == m_cte_info->Find(cte->ctename) &&
"CTE entry already exists");
Query *cte_query = (Query *) cte->ctequery;
#ifdef GPOS_DEBUG
BOOL result =
#endif
m_cte_info->Insert(cte->ctename, GPOS_NEW(mp) SCTEProducerInfo(cte_producer, cte_query->targetList));
m_cte_info->Insert(
cte->ctename,
GPOS_NEW(mp) SCTEProducerInfo(cte_producer, cte_query->targetList));
GPOS_ASSERT(result);
}
......
src/backend/gpopt/translate/CContextDXLToPlStmt.cpp
浏览文件 @ 219fe0c4
......@@ -33,17 +33,13 @@ using namespace gpdxl;
// Ctor
//
//---------------------------------------------------------------------------
CContextDXLToPlStmt::CContextDXLToPlStmt
(
CMemoryPool *mp,
CContextDXLToPlStmt::CContextDXLToPlStmt(CMemoryPool *mp,
CIdGenerator *plan_id_counter,
CIdGenerator *motion_id_counter,
CIdGenerator *param_id_counter,
List **rtable_entries_list,
List **subplan_entries_list
)
:
m_mp(mp),
List **subplan_entries_list)
: m_mp(mp),
m_plan_id_counter(plan_id_counter),
m_motion_id_counter(motion_id_counter),
m_param_id_counter(param_id_counter),
......@@ -152,11 +148,8 @@ CContextDXLToPlStmt::GetCurrentParamId()
//
//---------------------------------------------------------------------------
void
CContextDXLToPlStmt::AddCTEConsumerInfo
(
ULONG cte_id,
ShareInputScan *share_input_scan
)
CContextDXLToPlStmt::AddCTEConsumerInfo(ULONG cte_id,
ShareInputScan *share_input_scan)
{
GPOS_ASSERT(NULL != share_input_scan);
......@@ -173,7 +166,8 @@ CContextDXLToPlStmt::AddCTEConsumerInfo
#ifdef GPOS_DEBUG
BOOL result =
#endif
m_cte_consumer_info->Insert(key, GPOS_NEW(m_mp) SCTEConsumerInfo(cte_plan));
m_cte_consumer_info->Insert(key,
GPOS_NEW(m_mp) SCTEConsumerInfo(cte_plan));
GPOS_ASSERT(result);
}
......@@ -187,11 +181,7 @@ CContextDXLToPlStmt::AddCTEConsumerInfo
// with the given CTE identifier
//---------------------------------------------------------------------------
List *
CContextDXLToPlStmt::GetCTEConsumerList
(
ULONG cte_id
)
const
CContextDXLToPlStmt::GetCTEConsumerList(ULONG cte_id) const
{
SCTEConsumerInfo *cte_info = m_cte_consumer_info->Find(&cte_id);
if (NULL != cte_info)
......@@ -239,19 +229,16 @@ CContextDXLToPlStmt::GetSubplanEntriesList()
//
//---------------------------------------------------------------------------
void
CContextDXLToPlStmt::AddRTE
(
RangeTblEntry *rte,
BOOL is_result_relation
)
CContextDXLToPlStmt::AddRTE(RangeTblEntry *rte, BOOL is_result_relation)
{
(* (m_rtable_entries_list)) = gpdb::LAppend((*(m_rtable_entries_list)), rte);
(*(m_rtable_entries_list)) = gpdb::LAppend((*(m_rtable_entries_list)), rte);
rte->inFromCl = true;
if (is_result_relation)
{
GPOS_ASSERT(0 == m_result_relation_index && "Only one result relation supported");
GPOS_ASSERT(0 == m_result_relation_index &&
"Only one result relation supported");
rte->inFromCl = false;
m_result_relation_index = gpdb::ListLength(*(m_rtable_entries_list));
}
......@@ -266,14 +253,12 @@ CContextDXLToPlStmt::AddRTE
//
//---------------------------------------------------------------------------
void
CContextDXLToPlStmt::AddPartitionedTable
(
OID oid
)
CContextDXLToPlStmt::AddPartitionedTable(OID oid)
{
if (!gpdb::ListMemberOid(m_partitioned_tables_list, oid))
{
m_partitioned_tables_list = gpdb::LAppendOid(m_partitioned_tables_list, oid);
m_partitioned_tables_list =
gpdb::LAppendOid(m_partitioned_tables_list, oid);
}
}
......@@ -286,10 +271,7 @@ CContextDXLToPlStmt::AddPartitionedTable
//
//---------------------------------------------------------------------------
void
CContextDXLToPlStmt::IncrementPartitionSelectors
(
ULONG scan_id
)
CContextDXLToPlStmt::IncrementPartitionSelectors(ULONG scan_id)
{
// add extra elements to the array if necessary
const ULONG len = m_num_partition_selectors_array->Size();
......@@ -300,7 +282,7 @@ CContextDXLToPlStmt::IncrementPartitionSelectors
}
ULONG *ul = (*m_num_partition_selectors_array)[scan_id];
(*ul) ++;
(*ul)++;
}
//---------------------------------------------------------------------------
......@@ -319,7 +301,8 @@ CContextDXLToPlStmt::GetNumPartitionSelectorsList() const
for (ULONG ul = 0; ul < len; ul++)
{
ULONG *num_partition_selectors = (*m_num_partition_selectors_array)[ul];
partition_selectors_list = gpdb::LAppendInt(partition_selectors_list, *num_partition_selectors);
partition_selectors_list = gpdb::LAppendInt(partition_selectors_list,
*num_partition_selectors);
}
return partition_selectors_list;
......@@ -336,7 +319,8 @@ CContextDXLToPlStmt::GetNumPartitionSelectorsList() const
void
CContextDXLToPlStmt::AddSubplan(Plan *plan)
{
(* (m_subplan_entries_list)) = gpdb::LAppend((*(m_subplan_entries_list)), plan);
(*(m_subplan_entries_list)) =
gpdb::LAppend((*(m_subplan_entries_list)), plan);
}
//---------------------------------------------------------------------------
......@@ -348,11 +332,8 @@ CContextDXLToPlStmt::AddSubplan(Plan *plan)
//
//---------------------------------------------------------------------------
void
CContextDXLToPlStmt::AddCtasInfo
(
IntoClause *into_clause,
GpPolicy *distribution_policy
)
CContextDXLToPlStmt::AddCtasInfo(IntoClause *into_clause,
GpPolicy *distribution_policy)
{
GPOS_ASSERT(NULL != into_clause);
GPOS_ASSERT(NULL != distribution_policy);
......
src/backend/gpopt/translate/CDXLTranslateContext.cpp
浏览文件 @ 219fe0c4
......@@ -26,14 +26,9 @@ using namespace gpos;
// Ctor
//
//---------------------------------------------------------------------------
CDXLTranslateContext::CDXLTranslateContext
(
CMemoryPool *mp,
BOOL is_child_agg_node
)
:
m_mp(mp),
m_is_child_agg_node(is_child_agg_node)
CDXLTranslateContext::CDXLTranslateContext(CMemoryPool *mp,
BOOL is_child_agg_node)
: m_mp(mp), m_is_child_agg_node(is_child_agg_node)
{
// initialize hash table
m_colid_to_target_entry_map = GPOS_NEW(m_mp) ULongToTargetEntryMap(m_mp);
......@@ -48,15 +43,10 @@ CDXLTranslateContext::CDXLTranslateContext
// Ctor
//
//---------------------------------------------------------------------------
CDXLTranslateContext::CDXLTranslateContext
(
CMemoryPool *mp,
CDXLTranslateContext::CDXLTranslateContext(CMemoryPool *mp,
BOOL is_child_agg_node,
ULongToColParamMap *original
)
:
m_mp(mp),
m_is_child_agg_node(is_child_agg_node)
ULongToColParamMap *original)
: m_mp(mp), m_is_child_agg_node(is_child_agg_node)
{
m_colid_to_target_entry_map = GPOS_NEW(m_mp) ULongToTargetEntryMap(m_mp);
m_colid_to_paramid_map = GPOS_NEW(m_mp) ULongToColParamMap(m_mp);
......@@ -100,16 +90,14 @@ CDXLTranslateContext::IsParentAggNode() const
//
//---------------------------------------------------------------------------
void
CDXLTranslateContext::CopyParamHashmap
(
ULongToColParamMap *original
)
CDXLTranslateContext::CopyParamHashmap(ULongToColParamMap *original)
{
// iterate over full map
ULongToColParamMapIter hashmapiter(original);
while (hashmapiter.Advance())
{
CMappingElementColIdParamId *colidparamid = const_cast<CMappingElementColIdParamId *>(hashmapiter.Value());
CMappingElementColIdParamId *colidparamid =
const_cast<CMappingElementColIdParamId *>(hashmapiter.Value());
const ULONG colid = colidparamid->GetColId();
ULONG *key = GPOS_NEW(m_mp) ULONG(colid);
......@@ -127,11 +115,7 @@ CDXLTranslateContext::CopyParamHashmap
//
//---------------------------------------------------------------------------
const TargetEntry *
CDXLTranslateContext::GetTargetEntry
(
ULONG colid
)
const
CDXLTranslateContext::GetTargetEntry(ULONG colid) const
{
return m_colid_to_target_entry_map->Find(&colid);
}
......@@ -145,11 +129,7 @@ CDXLTranslateContext::GetTargetEntry
//
//---------------------------------------------------------------------------
const CMappingElementColIdParamId *
CDXLTranslateContext::GetParamIdMappingElement
(
ULONG colid
)
const
CDXLTranslateContext::GetParamIdMappingElement(ULONG colid) const
{
return m_colid_to_paramid_map->Find(&colid);
}
......@@ -163,11 +143,7 @@ CDXLTranslateContext::GetParamIdMappingElement
//
//---------------------------------------------------------------------------
void
CDXLTranslateContext::InsertMapping
(
ULONG colid,
TargetEntry *target_entry
)
CDXLTranslateContext::InsertMapping(ULONG colid, TargetEntry *target_entry)
{
// copy key
ULONG *key = GPOS_NEW(m_mp) ULONG(colid);
......@@ -190,11 +166,8 @@ CDXLTranslateContext::InsertMapping
//
//---------------------------------------------------------------------------
BOOL
CDXLTranslateContext::FInsertParamMapping
(
ULONG colid,
CMappingElementColIdParamId *colidparamid
)
CDXLTranslateContext::FInsertParamMapping(
ULONG colid, CMappingElementColIdParamId *colidparamid)
{
// copy key
ULONG *key = GPOS_NEW(m_mp) ULONG(colid);
......
src/backend/gpopt/translate/CDXLTranslateContextBaseTable.cpp
浏览文件 @ 219fe0c4
......@@ -27,14 +27,8 @@ using namespace gpos;
// Constructor
//
//---------------------------------------------------------------------------
CDXLTranslateContextBaseTable::CDXLTranslateContextBaseTable
(
CMemoryPool *mp
)
:
m_mp(mp),
m_oid(InvalidOid),
m_rel_index(0)
CDXLTranslateContextBaseTable::CDXLTranslateContextBaseTable(CMemoryPool *mp)
: m_mp(mp), m_oid(InvalidOid), m_rel_index(0)
{
// initialize hash table
m_colid_to_attno_map = GPOS_NEW(m_mp) UlongToIntMap(m_mp);
......@@ -63,10 +57,7 @@ CDXLTranslateContextBaseTable::~CDXLTranslateContextBaseTable()
//
//---------------------------------------------------------------------------
void
CDXLTranslateContextBaseTable::SetOID
(
OID oid
)
CDXLTranslateContextBaseTable::SetOID(OID oid)
{
GPOS_ASSERT(oid != InvalidOid);
m_oid = oid;
......@@ -81,10 +72,7 @@ CDXLTranslateContextBaseTable::SetOID
//
//---------------------------------------------------------------------------
void
CDXLTranslateContextBaseTable::SetRelIndex
(
Index rel_index
)
CDXLTranslateContextBaseTable::SetRelIndex(Index rel_index)
{
GPOS_ASSERT(0 < rel_index);
m_rel_index = rel_index;
......@@ -129,11 +117,7 @@ CDXLTranslateContextBaseTable::GetRelIndex() const
//
//---------------------------------------------------------------------------
INT
CDXLTranslateContextBaseTable::GetAttnoForColId
(
ULONG colid
)
const
CDXLTranslateContextBaseTable::GetAttnoForColId(ULONG colid) const
{
const INT *pi = m_colid_to_attno_map->Find(&colid);
if (NULL != pi)
......@@ -155,11 +139,7 @@ CDXLTranslateContextBaseTable::GetAttnoForColId
//
//---------------------------------------------------------------------------
BOOL
CDXLTranslateContextBaseTable::InsertMapping
(
ULONG dxl_colid,
INT att_no
)
CDXLTranslateContextBaseTable::InsertMapping(ULONG dxl_colid, INT att_no)
{
// copy key and value
ULONG *key = GPOS_NEW(m_mp) ULONG(dxl_colid);
......
src/backend/gpopt/translate/CMappingColIdVar.cpp
浏览文件 @ 219fe0c4
......@@ -25,12 +25,7 @@ using namespace gpdxl;
// Constructor
//
//---------------------------------------------------------------------------
CMappingColIdVar::CMappingColIdVar
(
CMemoryPool *mp
)
:
m_mp(mp)
CMappingColIdVar::CMappingColIdVar(CMemoryPool *mp) : m_mp(mp)
{
}
......
src/backend/gpopt/translate/CMappingColIdVarPlStmt.cpp
浏览文件 @ 219fe0c4
......@@ -41,16 +41,12 @@ using namespace gpmd;
// Constructor
//
//---------------------------------------------------------------------------
CMappingColIdVarPlStmt::CMappingColIdVarPlStmt
(
CMemoryPool *mp,
const CDXLTranslateContextBaseTable *base_table_context,
CMappingColIdVarPlStmt::CMappingColIdVarPlStmt(
CMemoryPool *mp, const CDXLTranslateContextBaseTable *base_table_context,
CDXLTranslationContextArray *child_contexts,
CDXLTranslateContext *output_context,
CContextDXLToPlStmt *dxl_to_plstmt_context
)
:
CMappingColIdVar(mp),
CContextDXLToPlStmt *dxl_to_plstmt_context)
: CMappingColIdVar(mp),
m_base_table_context(base_table_context),
m_child_contexts(child_contexts),
m_output_context(output_context),
......@@ -95,17 +91,15 @@ CMappingColIdVarPlStmt::GetOutputContext()
//
//---------------------------------------------------------------------------
Param *
CMappingColIdVarPlStmt::ParamFromDXLNodeScId
(
const CDXLScalarIdent *dxlop
)
CMappingColIdVarPlStmt::ParamFromDXLNodeScId(const CDXLScalarIdent *dxlop)
{
GPOS_ASSERT(NULL != m_output_context);
Param *param = NULL;
const ULONG colid = dxlop->GetDXLColRef()->Id();
const CMappingElementColIdParamId *elem = m_output_context->GetParamIdMappingElement(colid);
const CMappingElementColIdParamId *elem =
m_output_context->GetParamIdMappingElement(colid);
if (NULL != elem)
{
......@@ -128,10 +122,7 @@ CMappingColIdVarPlStmt::ParamFromDXLNodeScId
//
//---------------------------------------------------------------------------
Var *
CMappingColIdVarPlStmt::VarFromDXLNodeScId
(
const CDXLScalarIdent *dxlop
)
CMappingColIdVarPlStmt::VarFromDXLNodeScId(const CDXLScalarIdent *dxlop)
{
Index varno = 0;
AttrNumber attno = 0;
......@@ -199,14 +190,15 @@ CMappingColIdVarPlStmt::VarFromDXLNodeScId
continue;
}
Var *var = (Var*) target_entry->expr;
Var *var = (Var *) target_entry->expr;
varno = var->varno;
}
}
if (NULL == target_entry)
{
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXL2PlStmtAttributeNotFound, colid);
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXL2PlStmtAttributeNotFound,
colid);
}
attno = target_entry->resno;
......@@ -214,7 +206,7 @@ CMappingColIdVarPlStmt::VarFromDXLNodeScId
// find the original varno and attno for this column
if (IsA(target_entry->expr, Var))
{
Var *var = (Var*) target_entry->expr;
Var *var = (Var *) target_entry->expr;
varno_old = var->varnoold;
attno_old = var->varoattno;
}
......@@ -225,10 +217,7 @@ CMappingColIdVarPlStmt::VarFromDXLNodeScId
}
}
Var *var = gpdb::MakeVar
(
varno,
attno,
Var *var = gpdb::MakeVar(varno, attno,
CMDIdGPDB::CastMdid(dxlop->MdidType())->Oid(),
dxlop->TypeModifier(),
0 // varlevelsup
......
src/backend/gpopt/translate/CMappingElementColIdParamId.cpp
浏览文件 @ 219fe0c4
......@@ -31,15 +31,11 @@ using namespace gpos;
// Ctor
//
//---------------------------------------------------------------------------
CMappingElementColIdParamId::CMappingElementColIdParamId
(
ULONG colid,
CMappingElementColIdParamId::CMappingElementColIdParamId(ULONG colid,
ULONG paramid,
IMDId *mdid,
INT type_modifier
)
:
m_colid(colid),
INT type_modifier)
: m_colid(colid),
m_paramid(paramid),
m_mdid(mdid),
m_type_modifier(type_modifier)
......
src/backend/gpopt/translate/CMappingElementColIdTE.cpp
浏览文件 @ 219fe0c4
......@@ -31,16 +31,9 @@ using namespace gpos;
// Constructor
//
//---------------------------------------------------------------------------
CMappingElementColIdTE::CMappingElementColIdTE
(
ULONG colid,
ULONG query_level,
TargetEntry *target_entry
)
:
m_colid(colid),
m_query_level(query_level),
m_target_entry(target_entry)
CMappingElementColIdTE::CMappingElementColIdTE(ULONG colid, ULONG query_level,
TargetEntry *target_entry)
: m_colid(colid), m_query_level(query_level), m_target_entry(target_entry)
{
}
......
src/backend/gpopt/utils/CCatalogUtils.cpp
浏览文件 @ 219fe0c4
......@@ -65,9 +65,11 @@ CCatalogUtils::GetFunctionOids()
// Return list of all oids_list from the catalog
//
//---------------------------------------------------------------------------
List *CCatalogUtils::GetAllOids()
List *
CCatalogUtils::GetAllOids()
{
return list_concat(list_concat(GetRelationOids(), GetOperatorOids()), GetFunctionOids());
return list_concat(list_concat(GetRelationOids(), GetOperatorOids()),
GetFunctionOids());
}
// EOF
src/backend/gpopt/utils/CConstExprEvaluatorProxy.cpp
浏览文件 @ 219fe0c4
......@@ -40,12 +40,12 @@ using namespace gpos;
//
//---------------------------------------------------------------------------
Var *
CConstExprEvaluatorProxy::CEmptyMappingColIdVar::VarFromDXLNodeScId
(
const CDXLScalarIdent */*scalar_ident*/
)
CConstExprEvaluatorProxy::CEmptyMappingColIdVar::VarFromDXLNodeScId(
const CDXLScalarIdent * /*scalar_ident*/
)
{
elog(LOG, "Expression passed to CConstExprEvaluatorProxy contains variables. "
elog(LOG,
"Expression passed to CConstExprEvaluatorProxy contains variables. "
"Evaluation will fail and an exception will be thrown.");
GPOS_RAISE(gpdxl::ExmaGPDB, gpdxl::ExmiGPDBError);
return NULL;
......@@ -61,31 +61,33 @@ CConstExprEvaluatorProxy::CEmptyMappingColIdVar::VarFromDXLNodeScId
//
//---------------------------------------------------------------------------
CDXLNode *
CConstExprEvaluatorProxy::EvaluateExpr
(
const CDXLNode *dxl_expr
)
CConstExprEvaluatorProxy::EvaluateExpr(const CDXLNode *dxl_expr)
{
// Translate DXL -> GPDB Expr
Expr *expr = m_dxl2scalar_translator.TranslateDXLToScalar(dxl_expr, &m_emptymapcidvar);
Expr *expr = m_dxl2scalar_translator.TranslateDXLToScalar(
dxl_expr, &m_emptymapcidvar);
GPOS_ASSERT(NULL != expr);
// Evaluate the expression
Expr *result = gpdb::EvaluateExpr(expr,
gpdb::ExprType((Node *)expr),
gpdb::ExprTypeMod((Node *)expr));
Expr *result = gpdb::EvaluateExpr(expr, gpdb::ExprType((Node *) expr),
gpdb::ExprTypeMod((Node *) expr));
if (!IsA(result, Const))
{
#ifdef GPOS_DEBUG
elog(NOTICE, "Expression did not evaluate to Const, but to an expression of type %d", result->type);
#endif
#ifdef GPOS_DEBUG
elog(
NOTICE,
"Expression did not evaluate to Const, but to an expression of type %d",
result->type);
#endif
GPOS_RAISE(gpdxl::ExmaConstExprEval, gpdxl::ExmiConstExprEvalNonConst);
}
Const *const_result = (Const *)result;
CDXLDatum *datum_dxl = CTranslatorScalarToDXL::TranslateConstToDXL(m_mp, m_md_accessor, const_result);
CDXLNode *dxl_result = GPOS_NEW(m_mp) CDXLNode(m_mp, GPOS_NEW(m_mp) CDXLScalarConstValue(m_mp, datum_dxl));
Const *const_result = (Const *) result;
CDXLDatum *datum_dxl = CTranslatorScalarToDXL::TranslateConstToDXL(
m_mp, m_md_accessor, const_result);
CDXLNode *dxl_result = GPOS_NEW(m_mp)
CDXLNode(m_mp, GPOS_NEW(m_mp) CDXLScalarConstValue(m_mp, datum_dxl));
gpdb::GPDBFree(result);
gpdb::GPDBFree(expr);
......
src/backend/gpopt/utils/CMemoryPoolPalloc.cpp
浏览文件 @ 219fe0c4
......@@ -24,20 +24,14 @@ extern "C" {
using namespace gpos;
// ctor
CMemoryPoolPalloc::CMemoryPoolPalloc()
: m_cxt(NULL)
CMemoryPoolPalloc::CMemoryPoolPalloc() : m_cxt(NULL)
{
m_cxt = gpdb::GPDBAllocSetContextCreate();
}
void *
CMemoryPoolPalloc::NewImpl
(
const ULONG bytes,
const CHAR *,
const ULONG,
CMemoryPool::EAllocationType eat
)
CMemoryPoolPalloc::NewImpl(const ULONG bytes, const CHAR *, const ULONG,
CMemoryPool::EAllocationType eat)
{
// if it's a singleton allocation, allocate requested memory
if (CMemoryPool::EatSingleton == eat)
......@@ -47,7 +41,8 @@ CMemoryPoolPalloc::NewImpl
// if it's an array allocation, allocate header + requested memory
else
{
ULONG alloc_size = GPOS_MEM_ALIGNED_STRUCT_SIZE(SArrayAllocHeader) + GPOS_MEM_ALIGNED_SIZE(bytes);
ULONG alloc_size = GPOS_MEM_ALIGNED_STRUCT_SIZE(SArrayAllocHeader) +
GPOS_MEM_ALIGNED_SIZE(bytes);
void *ptr = gpdb::GPDBMemoryContextAlloc(m_cxt, alloc_size);
......@@ -56,10 +51,11 @@ CMemoryPoolPalloc::NewImpl
return NULL;
}
SArrayAllocHeader *header = static_cast<SArrayAllocHeader*>(ptr);
SArrayAllocHeader *header = static_cast<SArrayAllocHeader *>(ptr);
header->m_user_size = bytes;
return static_cast<BYTE*>(ptr) + GPOS_MEM_ALIGNED_STRUCT_SIZE(SArrayAllocHeader);
return static_cast<BYTE *>(ptr) +
GPOS_MEM_ALIGNED_STRUCT_SIZE(SArrayAllocHeader);
}
}
......@@ -72,7 +68,8 @@ CMemoryPoolPalloc::DeleteImpl(void *ptr, CMemoryPool::EAllocationType eat)
}
else
{
void* header = static_cast<BYTE*>(ptr) - GPOS_MEM_ALIGNED_STRUCT_SIZE(SArrayAllocHeader);
void *header = static_cast<BYTE *>(ptr) -
GPOS_MEM_ALIGNED_STRUCT_SIZE(SArrayAllocHeader);
gpdb::GPDBFree(header);
}
}
......@@ -96,8 +93,10 @@ ULONG
CMemoryPoolPalloc::UserSizeOfAlloc(const void *ptr)
{
GPOS_ASSERT(ptr != NULL);
void* void_header = static_cast<BYTE*>(const_cast<void*>(ptr)) - GPOS_MEM_ALIGNED_STRUCT_SIZE(SArrayAllocHeader);
const SArrayAllocHeader *header = static_cast<SArrayAllocHeader*>(void_header);
void *void_header = static_cast<BYTE *>(const_cast<void *>(ptr)) -
GPOS_MEM_ALIGNED_STRUCT_SIZE(SArrayAllocHeader);
const SArrayAllocHeader *header =
static_cast<SArrayAllocHeader *>(void_header);
return header->m_user_size;
}
......
src/backend/gpopt/utils/CMemoryPoolPallocManager.cpp
浏览文件 @ 219fe0c4
......@@ -23,9 +23,9 @@ extern "C" {
using namespace gpos;
// ctor
CMemoryPoolPallocManager::CMemoryPoolPallocManager(CMemoryPool *internal, EMemoryPoolType)
:
CMemoryPoolManager(internal, EMemoryPoolExternal)
CMemoryPoolPallocManager::CMemoryPoolPallocManager(CMemoryPool *internal,
EMemoryPoolType)
: CMemoryPoolManager(internal, EMemoryPoolExternal)
{
}
......@@ -37,14 +37,15 @@ CMemoryPoolPallocManager::NewMemoryPool()
}
void
CMemoryPoolPallocManager::DeleteImpl(void* ptr, CMemoryPool::EAllocationType eat)
CMemoryPoolPallocManager::DeleteImpl(void *ptr,
CMemoryPool::EAllocationType eat)
{
CMemoryPoolPalloc::DeleteImpl(ptr, eat);
}
// get user requested size of allocation
ULONG
CMemoryPoolPallocManager::UserSizeOfAlloc(const void* ptr)
CMemoryPoolPallocManager::UserSizeOfAlloc(const void *ptr)
{
return CMemoryPoolPalloc::UserSizeOfAlloc(ptr);
}
......@@ -52,7 +53,8 @@ CMemoryPoolPallocManager::UserSizeOfAlloc(const void* ptr)
GPOS_RESULT
CMemoryPoolPallocManager::Init()
{
return CMemoryPoolManager::SetupGlobalMemoryPoolManager<CMemoryPoolPallocManager, CMemoryPoolPalloc>();
return CMemoryPoolManager::SetupGlobalMemoryPoolManager<
CMemoryPoolPallocManager, CMemoryPoolPalloc>();
}
// EOF
src/backend/gpopt/utils/funcs.cpp
浏览文件 @ 219fe0c4
......@@ -40,8 +40,7 @@ extern "C" {
//---------------------------------------------------------------------------
extern "C" {
Datum
DisableXform(PG_FUNCTION_ARGS)
Datum DisableXform(PG_FUNCTION_ARGS)
{
char *szXform = text_to_cstring(PG_GETARG_TEXT_P(0));
bool is_result = COptTasks::SetXform(szXform, true /*fDisable*/);
......@@ -73,8 +72,7 @@ DisableXform(PG_FUNCTION_ARGS)
//---------------------------------------------------------------------------
extern "C" {
Datum
EnableXform(PG_FUNCTION_ARGS)
Datum EnableXform(PG_FUNCTION_ARGS)
{
char *szXform = text_to_cstring(PG_GETARG_TEXT_P(0));
bool is_result = COptTasks::SetXform(szXform, false /*fDisable*/);
......
src/include/gpopt/.clang-format 0 → 120000
浏览文件 @ 219fe0c4
../../backend/gpopt/.clang-format
\ No newline at end of file
src/include/gpopt/CGPOptimizer.h
浏览文件 @ 219fe0c4
......@@ -22,36 +22,30 @@
class CGPOptimizer
{
public:
public:
// optimize given query using GP optimizer
static
PlannedStmt *GPOPTOptimizedPlan
(
static PlannedStmt *GPOPTOptimizedPlan(
Query *query,
bool *had_unexpected_failure // output : set to true if optimizer unexpectedly failed to produce plan
bool *
had_unexpected_failure // output : set to true if optimizer unexpectedly failed to produce plan
);
// serialize planned statement into DXL
static
char *SerializeDXLPlan(Query *query);
static char *SerializeDXLPlan(Query *query);
// gpopt initialize and terminate
static
void InitGPOPT();
static void InitGPOPT();
static
void TerminateGPOPT();
static void TerminateGPOPT();
};
extern "C"
{
extern "C" {
extern PlannedStmt *GPOPTOptimizedPlan(Query *query, bool *had_unexpected_failure);
extern PlannedStmt *GPOPTOptimizedPlan(Query *query,
bool *had_unexpected_failure);
extern char *SerializeDXLPlan(Query *query);
extern void InitGPOPT ();
extern void TerminateGPOPT ();
extern void InitGPOPT();
extern void TerminateGPOPT();
}
#endif // CGPOptimizer_H
src/include/gpopt/config/CConfigParamMapping.h
浏览文件 @ 219fe0c4
......@@ -25,17 +25,17 @@ using namespace gpos;
namespace gpdxl
{
//---------------------------------------------------------------------------
// @class:
// CConfigParamMapping
//
// @doc:
// Functionality for mapping GPDB config params to traceflags
//
//---------------------------------------------------------------------------
class CConfigParamMapping
{
private:
//---------------------------------------------------------------------------
// @class:
// CConfigParamMapping
//
// @doc:
// Functionality for mapping GPDB config params to traceflags
//
//---------------------------------------------------------------------------
class CConfigParamMapping
{
private:
//------------------------------------------------------------------
// @class:
// SConfigMappingElem
......@@ -66,14 +66,12 @@ namespace gpdxl
// private ctor
CConfigParamMapping(const CConfigParamMapping &);
public:
public:
// pack enabled optimizer config params in a traceflag bitset
static
CBitSet *PackConfigParamInBitset(CMemoryPool *mp, ULONG xform_id);
};
}
static CBitSet *PackConfigParamInBitset(CMemoryPool *mp, ULONG xform_id);
};
} // namespace gpdxl
#endif // ! GPOPT_CGUCMapping_H
// EOF
src/include/gpopt/gpdbwrappers.h
浏览文件 @ 219fe0c4
此差异已折叠。
src/include/gpopt/relcache/CMDProviderRelcache.h
浏览文件 @ 219fe0c4
......@@ -28,58 +28,51 @@
// fwd decl
namespace gpopt
{
class CMDAccessor;
class CMDAccessor;
}
namespace gpmd
{
using namespace gpos;
//---------------------------------------------------------------------------
// @class:
// CMDProviderRelcache
//
// @doc:
// Relcache-based provider of metadata objects.
//
//---------------------------------------------------------------------------
class CMDProviderRelcache : public IMDProvider
{
private:
using namespace gpos;
//---------------------------------------------------------------------------
// @class:
// CMDProviderRelcache
//
// @doc:
// Relcache-based provider of metadata objects.
//
//---------------------------------------------------------------------------
class CMDProviderRelcache : public IMDProvider
{
private:
// memory pool
CMemoryPool *m_mp;
// private copy ctor
CMDProviderRelcache(const CMDProviderRelcache&);
CMDProviderRelcache(const CMDProviderRelcache &);
public:
public:
// ctor/dtor
explicit
CMDProviderRelcache(CMemoryPool *mp);
explicit CMDProviderRelcache(CMemoryPool *mp);
~CMDProviderRelcache()
{
}
// returns the DXL string of the requested metadata object
virtual
CWStringBase *GetMDObjDXLStr(CMemoryPool *mp, CMDAccessor *md_accessor, IMDId *md_id) const;
virtual CWStringBase *GetMDObjDXLStr(CMemoryPool *mp,
CMDAccessor *md_accessor,
IMDId *md_id) const;
// return the mdid for the requested type
virtual
IMDId *MDId
(
CMemoryPool *mp,
CSystemId sysid,
IMDType::ETypeInfo type_info
)
const
virtual IMDId *
MDId(CMemoryPool *mp, CSystemId sysid, IMDType::ETypeInfo type_info) const
{
return GetGPDBTypeMdid(mp, sysid, type_info);
}
};
}
};
} // namespace gpmd
......
src/include/gpopt/translate/CCTEListEntry.h
浏览文件 @ 219fe0c4
......@@ -32,38 +32,33 @@ using namespace gpos;
namespace gpdxl
{
// hash on character arrays
inline
ULONG HashStr
(
const CHAR *str
)
{
// hash on character arrays
inline ULONG
HashStr(const CHAR *str)
{
return gpos::HashByteArray((BYTE *) str, clib::Strlen(str));
}
}
// equality on character arrays
inline
BOOL StrEqual(const CHAR *str_a, const CHAR *str_b)
{
// equality on character arrays
inline BOOL
StrEqual(const CHAR *str_a, const CHAR *str_b)
{
return (0 == clib::Strcmp(str_a, str_b));
}
}
//---------------------------------------------------------------------------
// @class:
// CCTEListEntry
//
// @doc:
// Class representing the list of common table expression defined at a
// query level
//
//---------------------------------------------------------------------------
class CCTEListEntry : public CRefCount
{
private:
//---------------------------------------------------------------------------
// @class:
// CCTEListEntry
//
// @doc:
// Class representing the list of common table expression defined at a
// query level
//
//---------------------------------------------------------------------------
class CCTEListEntry : public CRefCount
{
private:
// pair of DXL CTE producer and target list of the original CTE query
struct SCTEProducerInfo
{
......@@ -71,19 +66,16 @@ namespace gpdxl
List *m_target_list;
// ctor
SCTEProducerInfo
(
const CDXLNode *cte_producer,
List *target_list
)
:
m_cte_producer(cte_producer),
m_target_list(target_list)
{}
SCTEProducerInfo(const CDXLNode *cte_producer, List *target_list)
: m_cte_producer(cte_producer), m_target_list(target_list)
{
}
};
// hash maps mapping CHAR *->SCTEProducerInfo
typedef CHashMap<CHAR, SCTEProducerInfo, HashStr, StrEqual, CleanupNULL, CleanupDelete > HMSzCTEInfo;
typedef CHashMap<CHAR, SCTEProducerInfo, HashStr, StrEqual, CleanupNULL,
CleanupDelete>
HMSzCTEInfo;
// query level where the CTEs are defined
ULONG m_query_level;
......@@ -91,22 +83,24 @@ namespace gpdxl
// CTE producers at that level indexed by their name
HMSzCTEInfo *m_cte_info;
public:
public:
// ctor: single CTE
CCTEListEntry(CMemoryPool *mp, ULONG query_level, CommonTableExpr *cte, CDXLNode *cte_producer);
CCTEListEntry(CMemoryPool *mp, ULONG query_level, CommonTableExpr *cte,
CDXLNode *cte_producer);
// ctor: multiple CTEs
CCTEListEntry(CMemoryPool *mp, ULONG query_level, List *cte_list, CDXLNodeArray *dxlnodes);
CCTEListEntry(CMemoryPool *mp, ULONG query_level, List *cte_list,
CDXLNodeArray *dxlnodes);
// dtor
virtual
~CCTEListEntry()
virtual ~CCTEListEntry()
{
m_cte_info->Release();
};
// the query level
ULONG GetQueryLevel() const
ULONG
GetQueryLevel() const
{
return m_query_level;
}
......@@ -118,18 +112,21 @@ namespace gpdxl
List *GetCTEProducerTargetList(const CHAR *cte_str) const;
// add a new CTE producer for this level
void AddCTEProducer(CMemoryPool *mp, CommonTableExpr *cte, const CDXLNode *cte_producer);
};
void AddCTEProducer(CMemoryPool *mp, CommonTableExpr *cte,
const CDXLNode *cte_producer);
};
// hash maps mapping ULONG -> CCTEListEntry
typedef CHashMap<ULONG, CCTEListEntry, gpos::HashValue<ULONG>, gpos::Equals<ULONG>,
CleanupDelete<ULONG>, CleanupRelease > HMUlCTEListEntry;
// hash maps mapping ULONG -> CCTEListEntry
typedef CHashMap<ULONG, CCTEListEntry, gpos::HashValue<ULONG>,
gpos::Equals<ULONG>, CleanupDelete<ULONG>, CleanupRelease>
HMUlCTEListEntry;
// iterator
typedef CHashMapIter<ULONG, CCTEListEntry, gpos::HashValue<ULONG>, gpos::Equals<ULONG>,
CleanupDelete<ULONG>, CleanupRelease > HMIterUlCTEListEntry;
// iterator
typedef CHashMapIter<ULONG, CCTEListEntry, gpos::HashValue<ULONG>,
gpos::Equals<ULONG>, CleanupDelete<ULONG>, CleanupRelease>
HMIterUlCTEListEntry;
}
} // namespace gpdxl
#endif // !GPDXL_CCTEListEntry_H
//EOF
src/include/gpopt/translate/CDXLTranslateContext.h
浏览文件 @ 219fe0c4
......@@ -29,38 +29,41 @@ struct TargetEntry;
namespace gpdxl
{
using namespace gpos;
using namespace gpos;
// hash maps mapping ULONG -> TargetEntry
typedef CHashMap<ULONG, TargetEntry, gpos::HashValue<ULONG>,
gpos::Equals<ULONG>, CleanupDelete<ULONG>, CleanupNULL>
ULongToTargetEntryMap;
// hash maps mapping ULONG -> TargetEntry
typedef CHashMap<ULONG, TargetEntry, gpos::HashValue<ULONG>, gpos::Equals<ULONG>,
CleanupDelete<ULONG>, CleanupNULL > ULongToTargetEntryMap;
// hash maps mapping ULONG -> CMappingElementColIdParamId
typedef CHashMap<ULONG, CMappingElementColIdParamId, gpos::HashValue<ULONG>,
gpos::Equals<ULONG>, CleanupDelete<ULONG>,
CleanupRelease<CMappingElementColIdParamId> >
ULongToColParamMap;
// hash maps mapping ULONG -> CMappingElementColIdParamId
typedef CHashMap<ULONG, CMappingElementColIdParamId, gpos::HashValue<ULONG>, gpos::Equals<ULONG>,
CleanupDelete<ULONG>, CleanupRelease<CMappingElementColIdParamId> > ULongToColParamMap;
typedef CHashMapIter<ULONG, CMappingElementColIdParamId, gpos::HashValue<ULONG>,
gpos::Equals<ULONG>, CleanupDelete<ULONG>,
CleanupRelease<CMappingElementColIdParamId> >
ULongToColParamMapIter;
typedef CHashMapIter<ULONG, CMappingElementColIdParamId, gpos::HashValue<ULONG>, gpos::Equals<ULONG>,
CleanupDelete<ULONG>, CleanupRelease<CMappingElementColIdParamId> > ULongToColParamMapIter;
//---------------------------------------------------------------------------
// @class:
// CDXLTranslateContext
//
// @doc:
// Class providing access to translation context, such as mappings between
// ColIds and target entries
//
//---------------------------------------------------------------------------
class CDXLTranslateContext
{
private:
//---------------------------------------------------------------------------
// @class:
// CDXLTranslateContext
//
// @doc:
// Class providing access to translation context, such as mappings between
// ColIds and target entries
//
//---------------------------------------------------------------------------
class CDXLTranslateContext
{
private:
CMemoryPool *m_mp;
// private copy ctor
CDXLTranslateContext(const CDXLTranslateContext&);
CDXLTranslateContext(const CDXLTranslateContext &);
// mappings ColId->TargetEntry used for intermediate DXL nodes
ULongToTargetEntryMap *m_colid_to_target_entry_map;
......@@ -78,11 +81,12 @@ namespace gpdxl
// copy the params hashmap
void CopyParamHashmap(ULongToColParamMap *original);
public:
public:
// ctor/dtor
CDXLTranslateContext(CMemoryPool *mp, BOOL is_child_agg_node);
CDXLTranslateContext(CMemoryPool *mp, BOOL is_child_agg_node, ULongToColParamMap *original);
CDXLTranslateContext(CMemoryPool *mp, BOOL is_child_agg_node,
ULongToColParamMap *original);
~CDXLTranslateContext();
......@@ -90,7 +94,8 @@ namespace gpdxl
BOOL IsParentAggNode() const;
// return the params hashmap
ULongToColParamMap *GetColIdToParamIdMap()
ULongToColParamMap *
GetColIdToParamIdMap()
{
return m_colid_to_paramid_map;
}
......@@ -99,19 +104,22 @@ namespace gpdxl
const TargetEntry *GetTargetEntry(ULONG colid) const;
// return the param id corresponding to the given ColId
const CMappingElementColIdParamId *GetParamIdMappingElement(ULONG colid) const;
const CMappingElementColIdParamId *GetParamIdMappingElement(
ULONG colid) const;
// store the mapping of the given column id and target entry
void InsertMapping(ULONG colid, TargetEntry *target_entry);
// store the mapping of the given column id and param id
BOOL FInsertParamMapping(ULONG colid, CMappingElementColIdParamId *pmecolidparamid);
};
BOOL FInsertParamMapping(ULONG colid,
CMappingElementColIdParamId *pmecolidparamid);
};
// array of dxl translation context
typedef CDynamicPtrArray<const CDXLTranslateContext, CleanupNULL> CDXLTranslationContextArray;
}
// array of dxl translation context
typedef CDynamicPtrArray<const CDXLTranslateContext, CleanupNULL>
CDXLTranslationContextArray;
} // namespace gpdxl
#endif // !GPDXL_CDXLTranslateContext_H
......
src/include/gpopt/utils/COptTasks.h
浏览文件 @ 219fe0c4
此差异已折叠。
src/include/gpopt/utils/funcs.h
浏览文件 @ 219fe0c4
......@@ -11,8 +11,7 @@
#define GPOPT_funcs_H
extern "C"
{
extern "C" {
#include "postgres.h"
#include "fmgr.h"
......@@ -21,8 +20,7 @@ extern "C"
extern Datum DisableXform(PG_FUNCTION_ARGS);
extern Datum EnableXform(PG_FUNCTION_ARGS);
extern Datum LibraryVersion();
extern const char * OptVersion(void);
extern const char *OptVersion(void);
}
#endif // GPOPT_funcs_H
src/include/gpopt/utils/gpdbdefs.h
浏览文件 @ 219fe0c4
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或