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)

src/backend/gpopt/CGPOptimizer.cpp

@@ -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,36 +68,41 @@ 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),
-				  errmsg("%s", serialized_error_msg));
+					  errmsg("%s", serialized_error_msg));
 		}
 
 		else if (GPOS_MATCH_EX(ex, gpdxl::ExmaDXL, gpdxl::ExmiOptimizerError) ||
-			NULL != serialized_error_msg)
+				 NULL != serialized_error_msg)
 		{
 			Assert(NULL != serialized_error_msg);
 			errstart(ERROR, ex.Filename(), ex.Line(), NULL, TEXTDOMAIN);
 			errfinish(errcode(ERRCODE_INTERNAL_ERROR),
-					errmsg("%s", serialized_error_msg));
+					  errmsg("%s", serialized_error_msg));
 		}
 		else if (GPOS_MATCH_EX(ex, gpdxl::ExmaGPDB, gpdxl::ExmiGPDBError))
 		{
 			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."));
+					  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/relcache/CMDProviderRelcache.cpp

@@ -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

@@ -31,27 +31,22 @@ 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 =
+	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,35 +58,30 @@ 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));
-	
+
 	m_cte_info = GPOS_NEW(mp) HMSzCTEInfo(mp);
 	const ULONG num_cte = cte_dxl_arr->Size();
-	
+
 	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,18 +96,14 @@ 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)
 	{
-		return NULL; 
+		return NULL;
 	}
-	
+
 	return cte_info->m_cte_producer;
 }
 
@@ -130,18 +116,14 @@ 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)
 	{
-		return NULL; 
+		return NULL;
 	}
-	
+
 	return cte_info->m_target_list;
 }
 
@@ -154,21 +136,20 @@ 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

@@ -33,27 +33,23 @@ using namespace gpdxl;
 //		Ctor
 //
 //---------------------------------------------------------------------------
-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),
-	m_plan_id_counter(plan_id_counter),
-	m_motion_id_counter(motion_id_counter),
-	m_param_id_counter(param_id_counter),
-	m_rtable_entries_list(rtable_entries_list),
-	m_partitioned_tables_list(NULL),
-	m_num_partition_selectors_array(NULL),
-	m_subplan_entries_list(subplan_entries_list),
-	m_result_relation_index(0),
-	m_into_clause(NULL),
-	m_distribution_policy(NULL)
+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),
+	  m_plan_id_counter(plan_id_counter),
+	  m_motion_id_counter(motion_id_counter),
+	  m_param_id_counter(param_id_counter),
+	  m_rtable_entries_list(rtable_entries_list),
+	  m_partitioned_tables_list(NULL),
+	  m_num_partition_selectors_array(NULL),
+	  m_subplan_entries_list(subplan_entries_list),
+	  m_result_relation_index(0),
+	  m_into_clause(NULL),
+	  m_distribution_policy(NULL)
 {
 	m_cte_consumer_info = GPOS_NEW(m_mp) HMUlCTEConsumerInfo(m_mp);
 	m_num_partition_selectors_array = GPOS_NEW(m_mp) ULongPtrArray(m_mp);
@@ -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,15 +332,12 @@ 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);
-	
+
 	m_into_clause = into_clause;
 	m_distribution_policy = distribution_policy;
 }

src/backend/gpopt/translate/CDXLTranslateContext.cpp

@@ -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,
-	BOOL is_child_agg_node,
-	ULongToColParamMap *original
-	)
-	:
-	m_mp(mp),
-	m_is_child_agg_node(is_child_agg_node)
+CDXLTranslateContext::CDXLTranslateContext(CMemoryPool *mp,
+										   BOOL 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

@@ -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

@@ -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

@@ -41,20 +41,16 @@ 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),
-	m_base_table_context(base_table_context),
-	m_child_contexts(child_contexts),
-	m_output_context(output_context),
-	m_dxl_to_plstmt_context(dxl_to_plstmt_context)
+	CContextDXLToPlStmt *dxl_to_plstmt_context)
+	: CMappingColIdVar(mp),
+	  m_base_table_context(base_table_context),
+	  m_child_contexts(child_contexts),
+	  m_output_context(output_context),
+	  m_dxl_to_plstmt_context(dxl_to_plstmt_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)
+		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,14 +217,11 @@ CMappingColIdVarPlStmt::VarFromDXLNodeScId
 		}
 	}
 
-	Var *var = gpdb::MakeVar
-						(
-						varno,
-						attno,
-						CMDIdGPDB::CastMdid(dxlop->MdidType())->Oid(),
-						dxlop->TypeModifier(),
-						0	// varlevelsup
-						);
+	Var *var = gpdb::MakeVar(varno, attno,
+							 CMDIdGPDB::CastMdid(dxlop->MdidType())->Oid(),
+							 dxlop->TypeModifier(),
+							 0	// varlevelsup
+	);
 
 	// set varnoold and varoattno since makeVar does not set them properly
 	var->varnoold = varno_old;

src/backend/gpopt/translate/CMappingElementColIdParamId.cpp

@@ -31,18 +31,14 @@ using namespace gpos;
 //		Ctor
 //
 //---------------------------------------------------------------------------
-CMappingElementColIdParamId::CMappingElementColIdParamId
-	(
-	ULONG colid,
-	ULONG paramid,
-	IMDId *mdid,
-	INT type_modifier
-	)
-	:
-	m_colid(colid),
-	m_paramid(paramid),
-	m_mdid(mdid),
-	m_type_modifier(type_modifier)
+CMappingElementColIdParamId::CMappingElementColIdParamId(ULONG colid,
+														 ULONG paramid,
+														 IMDId *mdid,
+														 INT type_modifier)
+	: m_colid(colid),
+	  m_paramid(paramid),
+	  m_mdid(mdid),
+	  m_type_modifier(type_modifier)
 {
 }
 

src/backend/gpopt/translate/CMappingElementColIdTE.cpp

@@ -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

@@ -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

@@ -40,13 +40,13 @@ 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. "
-			"Evaluation will fail and an exception will be thrown.");
+	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

@@ -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

@@ -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

@@ -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

+../../backend/gpopt/.clang-format
\ No newline at end of file

src/include/gpopt/CGPOptimizer.h

@@ -22,36 +22,30 @@
 
 class CGPOptimizer
 {
-	public:
-
-		// optimize given query using GP optimizer
-		static
-		PlannedStmt *GPOPTOptimizedPlan
-			(
-			Query *query,
-			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);
-
-    // gpopt initialize and terminate
-    static
-    void InitGPOPT();
-
-    static
-    void TerminateGPOPT();
+public:
+	// optimize given query using GP optimizer
+	static PlannedStmt *GPOPTOptimizedPlan(
+		Query *query,
+		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);
+
+	// gpopt initialize and terminate
+	static void InitGPOPT();
+
+	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
+#endif	// CGPOptimizer_H

src/include/gpopt/utils/funcs.h

@@ -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
+#endif	// GPOPT_funcs_H