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