ORCA: allow partition table use the append node

Author: jiaqizho

src/backend/gpopt/config/CConfigParamMapping.cpp

@@ -301,15 +301,18 @@ CConfigParamMapping::SConfigMappingElem CConfigParamMapping::m_elements[] = {
 	{EopttraceEnableUseDistributionInDQA,
 	 &optimizer_enable_use_distribution_in_dqa,
 	 false,	 // m_negate_param
-	 GPOS_WSZ_LIT(
-		 "Enable use the distribution key in DQA")},
+	 GPOS_WSZ_LIT("Enable use the distribution key in DQA")},
 	{EopttraceDisableInnerHashJoin, &optimizer_enable_hashjoin,
 	 true,	// m_negate_param
 	 GPOS_WSZ_LIT("Explore hash join alternatives")},
 	{EopttraceDisableInnerNLJ, &optimizer_enable_nljoin,
 	 true,	// m_negate_param
 	 GPOS_WSZ_LIT("Enable nested loop join alternatives")},
 
+	{EopttraceDisableDynamicTableScan, &optimizer_disable_dynamic_table_scan,
+	 false,	 // m_negate_param
+	 GPOS_WSZ_LIT(
+		 "Disable the dynamic seq/bitmap/index scan in partition table")},
 };
 
 //---------------------------------------------------------------------------

src/backend/gpopt/translate/CTranslatorDXLToPlStmt.cpp

@@ -3921,6 +3921,31 @@ CTranslatorDXLToPlStmt::TranslateDXLAppend(
 	GPOS_ASSERT(EdxlappendIndexFirstChild < arity);
 	append->appendplans = NIL;
 
+	// translate table descriptor into a range table entry
+	CDXLPhysicalAppend *phy_append_dxlop =
+		CDXLPhysicalAppend::Cast(append_dxlnode->GetOperator());
+
+	// If this append was create from a DynamicTableScan node in ORCA, it will
+	// contain the table descriptor of the root partitioned table. Add that to
+	// the range table in the PlStmt.
+	if (phy_append_dxlop->GetScanId() != gpos::ulong_max)
+	{
+		GPOS_ASSERT(nullptr != phy_append_dxlop->GetDXLTableDesc());
+
+		// translation context for column mappings in the base relation
+		CDXLTranslateContextBaseTable base_table_context(m_mp);
+
+		(void) ProcessDXLTblDescr(phy_append_dxlop->GetDXLTableDesc(),
+								  &base_table_context);
+
+		OID oid_type =
+			CMDIdGPDB::CastMdid(m_md_accessor->PtMDType<IMDTypeInt4>()->MDId())
+				->Oid();
+		append->join_prune_paramids =
+			TranslateJoinPruneParamids(phy_append_dxlop->GetSelectorIds(),
+									   oid_type, m_dxl_to_plstmt_context);
+	}
+
 	// translate children
 	CDXLTranslateContext child_context(m_mp, false,
 									   output_context->GetColIdToParamIdMap());

src/backend/gporca/libgpopt/include/gpopt/translate/CTranslatorExprToDXL.h

@@ -313,6 +313,13 @@ class CTranslatorExprToDXL
 							CDistributionSpecArray *pdrgpdsBaseTables,
 							ULONG *pulNonGatherMotions, BOOL *pfDML);
 
+	// translate a dynamic scan to append
+	template <class PhysicalScanType>
+	CDXLNode *PdxlnDynamicScanToAppend(
+		CExpression *pexprDTS, CColRefArray *colref_array,
+		CDistributionSpecArray *pdrgpdsBaseTables, CExpression *pexprScalarCond,
+		CDXLPhysicalProperties *dxl_properties);
+
 	// translate a dynamic table scan
 	CDXLNode *PdxlnDynamicTableScan(CExpression *pexprDTS,
 									CColRefArray *colref_array,

src/backend/gporca/libgpopt/src/translate/CTranslatorExprToDXL.cpp

@@ -1351,6 +1351,11 @@ CTranslatorExprToDXL::PdxlnDynamicTableScan(
 	GPOS_ASSERT(nullptr != pexprDTS);
 	GPOS_ASSERT_IFF(nullptr != pexprScalarCond, nullptr != dxl_properties);
 
+	if (GPOS_FTRACE(EopttraceDisableDynamicTableScan)) {
+		return PdxlnDynamicScanToAppend<CPhysicalDynamicTableScan>(pexprDTS, colref_array, 
+			pdrgpdsBaseTables, pexprScalarCond, dxl_properties);
+	}
+
 	CPhysicalDynamicTableScan *popDTS =
 		CPhysicalDynamicTableScan::PopConvert(pexprDTS->Pop());
 	CColRefArray *pdrgpcrOutput = popDTS->PdrgpcrOutput();
@@ -1429,6 +1434,143 @@ CTranslatorExprToDXL::PdxlnDynamicTableScan(
 	return pdxlnDTS;
 }
 
+
+template <class PhysicalScanType>
+CDXLNode *
+CTranslatorExprToDXL::PdxlnDynamicScanToAppend(CExpression *pexprDTS,
+	CColRefArray *colref_array,
+	CDistributionSpecArray *pdrgpdsBaseTables,
+	CExpression *pexprScalarCond,
+	CDXLPhysicalProperties *dxl_properties) {
+	
+	PhysicalScanType *popDTS =
+		PhysicalScanType::PopConvert(pexprDTS->Pop());
+
+	ULongPtrArray *selector_ids = GPOS_NEW(m_mp) ULongPtrArray(m_mp);
+	CPartitionPropagationSpec *pps_reqd =
+		pexprDTS->Prpp()->Pepp()->PppsRequired();
+	if (pps_reqd->Contains(popDTS->ScanId()))
+	{
+		const CBitSet *bs = pps_reqd->SelectorIds(popDTS->ScanId());
+		CBitSetIter bsi(*bs);
+		for (ULONG ul = 0; bsi.Advance(); ul++)
+		{
+			selector_ids->Append(GPOS_NEW(m_mp) ULONG(bsi.Bit()));
+		}
+	}
+
+	// construct plan costs
+	CDXLPhysicalProperties *pdxlpropDTS = GetProperties(pexprDTS);
+
+	if (nullptr != dxl_properties)
+	{
+		CWStringDynamic *rows_out_str = GPOS_NEW(m_mp) CWStringDynamic(
+			m_mp,
+			dxl_properties->GetDXLOperatorCost()->GetRowsOutStr()->GetBuffer());
+		CWStringDynamic *pstrCost = GPOS_NEW(m_mp)
+			CWStringDynamic(m_mp, dxl_properties->GetDXLOperatorCost()
+									->GetTotalCostStr()
+									->GetBuffer());
+
+		pdxlpropDTS->GetDXLOperatorCost()->SetRows(rows_out_str);
+		pdxlpropDTS->GetDXLOperatorCost()->SetCost(pstrCost);
+		dxl_properties->Release();
+	}
+	GPOS_ASSERT(nullptr != pexprDTS->Prpp());
+
+	// construct projection list for top-level Append node
+	CColRefSet *pcrsOutput = pexprDTS->Prpp()->PcrsRequired();
+	CDXLNode *pdxlnPrLAppend = PdxlnProjList(pcrsOutput, colref_array);
+	CDXLTableDescr *root_dxl_table_descr = MakeDXLTableDescr(
+		popDTS->Ptabdesc(), popDTS->PdrgpcrOutput(), pexprDTS->Prpp());
+
+	// Construct the Append node - even when there is only one child partition.
+	// This is done for two reasons:
+	// * Dynamic partition pruning
+	//   Even if one partition is present in the statically pruned plan, we could
+	//   still dynamically prune it away. This needs an Append node.
+	// * Col mappings issues
+	//   When the first selected child partition's cols have different types/order
+	//   than the root partition, we can no longer re-use the colrefs of the root
+	//   partition, since colrefs are immutable. Thus, we create new colrefs for
+	//   this partition. But, if there is no Append (in case of just one selected
+	//   partition), then we also go through update all references above the DTS
+	//   with the new colrefs. For simplicity, we decided to keep the Append
+	//   around to maintain this projection (mapping) from the old root colrefs
+	//   to the first selected partition colrefs.
+	//
+	// GPDB_12_MERGE_FIXME: An Append on a single TableScan can be removed in
+	// CTranslatorDXLToPlstmt since these points do not apply there.
+	CDXLNode *pdxlnAppend = GPOS_NEW(m_mp) CDXLNode(
+		m_mp,
+		GPOS_NEW(m_mp) CDXLPhysicalAppend(m_mp, false, false, popDTS->ScanId(),
+										root_dxl_table_descr, selector_ids));
+	pdxlnAppend->SetProperties(pdxlpropDTS);
+	pdxlnAppend->AddChild(pdxlnPrLAppend);
+	pdxlnAppend->AddChild(PdxlnFilter(nullptr));
+
+	IMdIdArray *part_mdids = popDTS->GetPartitionMdids();
+	for (ULONG ul = 0; ul < part_mdids->Size(); ++ul)
+	{
+		IMDId *part_mdid = (*part_mdids)[ul];
+		const IMDRelation *part = m_pmda->RetrieveRel(part_mdid);
+
+		CTableDescriptor *part_tabdesc =
+			MakeTableDescForPart(part, popDTS->Ptabdesc());
+
+		// Create new colrefs for the child partition. The ColRefs from root
+		// DTS, which may be used in any parent node, can no longer be exported
+		// by a child of the Append node. Thus it is exported by the Append
+		// node itself, and new colrefs are created here.
+		CColRefArray *part_colrefs = GPOS_NEW(m_mp) CColRefArray(m_mp);
+		for (ULONG ul_col = 0; ul_col < part_tabdesc->ColumnCount(); ++ul_col)
+		{
+			const CColumnDescriptor *cd = part_tabdesc->Pcoldesc(ul_col);
+			CColRef *cr = m_pcf->PcrCreate(cd->RetrieveType(),
+										cd->TypeModifier(), cd->Name());
+			part_colrefs->Append(cr);
+		}
+
+		CDXLTableDescr *dxl_table_descr =
+			MakeDXLTableDescr(part_tabdesc, part_colrefs, pexprDTS->Prpp());
+		part_tabdesc->Release();
+
+		CDXLNode *dxlnode = GPOS_NEW(m_mp) CDXLNode(
+			m_mp, GPOS_NEW(m_mp) CDXLPhysicalTableScan(m_mp, dxl_table_descr));
+
+		// GPDB_12_MERGE_FIXME: Compute stats & properties per scan
+		pdxlpropDTS->AddRef();
+		dxlnode->SetProperties(pdxlpropDTS);
+
+		// ColRef -> index in child table desc (per partition)
+		auto root_col_mapping = (*popDTS->GetRootColMappingPerPart())[ul];
+
+		// construct projection list, re-ordered to match root DTS
+		CDXLNode *pdxlnPrL = PdxlnProjListForChildPart(
+			root_col_mapping, part_colrefs, pcrsOutput, colref_array);
+		dxlnode->AddChild(pdxlnPrL);  // project list
+
+		// construct the filter
+		CDXLNode *filter_dxlnode = PdxlnFilter(
+			PdxlnCondForChildPart(root_col_mapping, part_colrefs,
+								popDTS->PdrgpcrOutput(), pexprScalarCond));
+		dxlnode->AddChild(filter_dxlnode);	// filter
+
+		// add to the other scans under the created Append node
+		pdxlnAppend->AddChild(dxlnode);
+
+		// cleanup
+		part_colrefs->Release();
+	}
+
+	CDistributionSpec *pds = pexprDTS->GetDrvdPropPlan()->Pds();
+	pds->AddRef();
+	pdrgpdsBaseTables->Append(pds);
+
+	GPOS_ASSERT(pdxlnAppend);
+	return pdxlnAppend;
+}
+
 //---------------------------------------------------------------------------
 //	@function:
 //		CTranslatorExprToDXL::PdxlnDynamicBitmapTableScan
@@ -1763,6 +1905,11 @@ CTranslatorExprToDXL::PdxlnDynamicForeignScan(
 	GPOS_ASSERT(nullptr != pexprDFS);
 	GPOS_ASSERT_IFF(nullptr != pexprScalarCond, nullptr != dxl_properties);
 
+	if (GPOS_FTRACE(EopttraceDisableDynamicTableScan)) {
+		return PdxlnDynamicScanToAppend<CPhysicalDynamicForeignScan>(pexprDFS, colref_array, 
+			pdrgpdsBaseTables, pexprScalarCond, dxl_properties);
+	}
+
 	CPhysicalDynamicForeignScan *popDFS =
 		CPhysicalDynamicForeignScan::PopConvert(pexprDFS->Pop());
 	CColRefArray *pdrgpcrOutput = popDFS->PdrgpcrOutput();
@@ -1841,6 +1988,7 @@ CTranslatorExprToDXL::PdxlnDynamicForeignScan(
 
 	return pdxlnDFS;
 }
+
 //---------------------------------------------------------------------------
 //	@function:
 //		CTranslatorExprToDXL::PdxlnResult

src/backend/gporca/libnaucrates/include/naucrates/dxl/operators/CDXLPhysicalAppend.h

@@ -49,19 +49,60 @@ class CDXLPhysicalAppend : public CDXLPhysical
 	// TODO:  - Apr 12, 2011; find a better name (and comments) for this variable
 	BOOL m_is_zapped = false;
 
+	// scan id from the CPhysicalDynamicTableScan (a.k.a part_index_id)
+	// when m_scan_id != gpos::ulong_max
+	ULONG m_scan_id = gpos::ulong_max;
+
+	// table descr of the root partitioned table (when translated from a CPhysicalDynamicTableScan)
+	CDXLTableDescr *m_dxl_table_descr = nullptr;
+
+	ULongPtrArray *m_selector_ids = nullptr;
+
 public:
 	CDXLPhysicalAppend(const CDXLPhysicalAppend &) = delete;
 
 	// ctor/dtor
 	CDXLPhysicalAppend(CMemoryPool *mp, BOOL fIsTarget, BOOL fIsZapped);
 
+	// ctor for partitioned table scan
+	CDXLPhysicalAppend(CMemoryPool *mp, BOOL fIsTarget, BOOL fIsZapped,
+					   ULONG scan_id, CDXLTableDescr *dxl_table_desc,
+					   ULongPtrArray *selector_ids);
+
+	// dtor
+	~CDXLPhysicalAppend() override;
+
 	// accessors
 	Edxlopid GetDXLOperator() const override;
 	const CWStringConst *GetOpNameStr() const override;
 
 	BOOL IsUsedInUpdDel() const;
 	BOOL IsZapped() const;
 
+	CDXLTableDescr *
+	GetDXLTableDesc() const
+	{
+		return m_dxl_table_descr;
+	}
+
+	void
+	SetDXLTableDesc(CDXLTableDescr *dxl_table_desc)
+	{
+		m_dxl_table_descr = dxl_table_desc;
+	}
+
+	ULONG
+	GetScanId() const
+	{
+		return m_scan_id;
+	}
+
+	const ULongPtrArray *
+	GetSelectorIds() const
+	{
+		return m_selector_ids;
+	}
+
 	// serialize operator in DXL format
 	void SerializeToDXL(CXMLSerializer *xml_serializer,
 						const CDXLNode *dxlnode) const override;

src/backend/gporca/libnaucrates/include/naucrates/dxl/xml/dxltokens.h

@@ -131,6 +131,8 @@ enum Edxltoken
 
 	EdxltokenDuplicateSensitive,
 
+	EdxltokenPartIndexId,
+	EdxltokenPartIndexIdPrintable,
 	EdxltokenSegmentIdCol,
 
 	EdxltokenScalar,

src/backend/gporca/libnaucrates/include/naucrates/traceflags/traceflags.h

@@ -229,6 +229,9 @@ enum EOptTraceFlag
 	// Ordered Agg
 	EopttraceDisableOrderedAgg = 103047,
 
+	// Disable dynamic seq/bitmap/index scan
+	EopttraceDisableDynamicTableScan = 103048,
+
 	///////////////////////////////////////////////////////
 	///////////////////// statistics flags ////////////////
 	//////////////////////////////////////////////////////

src/backend/gporca/libnaucrates/src/operators/CDXLOperatorFactory.cpp

@@ -366,7 +366,20 @@ CDXLOperatorFactory::MakeDXLAppend(CDXLMemoryManager *dxl_memory_manager,
 												   EdxltokenAppendIsZapped,
 												   EdxltokenPhysicalAppend);
 
-	return GPOS_NEW(mp) CDXLPhysicalAppend(mp, is_target, is_zapped);
+	ULONG scan_id = ExtractConvertAttrValueToUlong(dxl_memory_manager, attrs, EdxltokenPartIndexId,
+												   EdxltokenPhysicalAppend, true /* is_optional */,
+												   gpos::ulong_max /* default_value */);
+											
+	ULongPtrArray *selector_ids = nullptr;
+	if (scan_id != gpos::ulong_max)
+	{
+		selector_ids = ExtractConvertValuesToArray(dxl_memory_manager, attrs,
+												   EdxltokenSelectorIds,
+												   EdxltokenPhysicalAppend);
+	}
+											
+	return GPOS_NEW(mp) CDXLPhysicalAppend(mp, is_target, is_zapped, scan_id,
+												   nullptr, selector_ids);
 }
 
 //---------------------------------------------------------------------------

src/backend/gporca/libnaucrates/src/operators/CDXLPhysicalAppend.cpp

@@ -34,6 +34,25 @@ CDXLPhysicalAppend::CDXLPhysicalAppend(CMemoryPool *mp, BOOL fIsTarget,
 {
 }
 
+CDXLPhysicalAppend::CDXLPhysicalAppend(CMemoryPool *mp, BOOL fIsTarget,
+									   BOOL fIsZapped, ULONG scan_id,
+									   CDXLTableDescr *dxl_table_desc,
+									   ULongPtrArray *selector_ids)
+	: CDXLPhysical(mp),
+	  m_used_in_upd_del(fIsTarget),
+	  m_is_zapped(fIsZapped),
+	  m_scan_id(scan_id),
+	  m_dxl_table_descr(dxl_table_desc),
+	  m_selector_ids(selector_ids)
+{
+}
+
+CDXLPhysicalAppend::~CDXLPhysicalAppend()
+{
+	CRefCount::SafeRelease(m_dxl_table_descr);
+	CRefCount::SafeRelease(m_selector_ids);
+}
+
 //---------------------------------------------------------------------------
 //	@function:
 //		CDXLPhysicalAppend::GetDXLOperator
@@ -113,9 +132,28 @@ CDXLPhysicalAppend::SerializeToDXL(CXMLSerializer *xml_serializer,
 	xml_serializer->AddAttribute(
 		CDXLTokens::GetDXLTokenStr(EdxltokenAppendIsZapped), m_is_zapped);
 
+	if (m_scan_id != gpos::ulong_max)
+	{
+		xml_serializer->AddAttribute(
+			CDXLTokens::GetDXLTokenStr(EdxltokenPartIndexId), m_scan_id);
+
+		CWStringDynamic *serialized_selector_ids =
+			CDXLUtils::Serialize(m_mp, m_selector_ids);
+		xml_serializer->AddAttribute(
+			CDXLTokens::GetDXLTokenStr(EdxltokenSelectorIds),
+			serialized_selector_ids);
+		GPOS_DELETE(serialized_selector_ids);
+	}
 	// serialize properties
 	dxlnode->SerializePropertiesToDXL(xml_serializer);
 
+	if (m_dxl_table_descr != nullptr)
+	{
+		GPOS_ASSERT(m_scan_id != gpos::ulong_max);
+		m_dxl_table_descr->SerializeToDXL(xml_serializer);
+	}
+
+
 	// serialize children
 	dxlnode->SerializeChildrenToDXL(xml_serializer);