ADBDEV-3999: ORCA generates incorrect plan with exists clause for partitioned table

src/backend/gporca/libgpopt/include/gpopt/base/CColRefSet.h

@@ -86,6 +86,9 @@ class CColRefSet : public CBitSet, public DbgPrintMixin<CColRefSet>
 	// return first member
 	CColRef *PcrFirst() const;
 
+	// return first used member
+	CColRef *PcrFirstUsed() const;
+
 	// include column
 	void Include(const CColRef *colref);
 

src/backend/gporca/libgpopt/src/base/CColRefSet.cpp

@@ -126,6 +126,38 @@ CColRefSet::PcrFirst() const
 	return NULL;
 }
 
+//---------------------------------------------------------------------------
+//	@function:
+//		CColRefSet::PcrFirstUsed
+//
+//	@doc:
+//		Return first used member
+//
+//---------------------------------------------------------------------------
+CColRef *
+CColRefSet::PcrFirstUsed() const
+{
+	CColRefSetIter crsi(*this);
+	while (crsi.Advance())
+	{
+		CColRef *pcr = crsi.Pcr();
+
+		if (CColRef::EUsed == pcr->GetUsage())
+		{
+			return pcr;
+		}
+	}
+
+	CColRef *pcr = PcrFirst();
+
+	if (NULL != pcr)
+	{
+		pcr->MarkAsUsed();
+	}
+
+	return pcr;
+}
+
 //---------------------------------------------------------------------------
 //	@function:
 //		CColRefSet::Include

src/backend/gporca/libgpopt/src/xforms/CSubqueryHandler.cpp

@@ -1300,8 +1300,9 @@ CSubqueryHandler::FCreateCorrelatedApplyForExistentialSubquery(
 	CExpression *pexprInner = (*pexprSubquery)[0];
 
 	// for existential subqueries, any column produced by inner expression
-	// can be used to check for empty answers; we use first column for that
-	CColRef *colref = pexprInner->DeriveOutputColumns()->PcrFirst();
+	// can be used to check for empty answers;
+	// we use first used (referenced in the query) column for that
+	CColRef *colref = pexprInner->DeriveOutputColumns()->PcrFirstUsed();
 
 	pexprInner->AddRef();
 	if (EsqctxtFilter == esqctxt)
@@ -1932,8 +1933,9 @@ CSubqueryHandler::FRemoveExistentialSubquery(
 		GPOS_ASSERT(EsqctxtFilter == esqctxt);
 
 		// for existential subqueries, any column produced by inner expression
-		// can be used to check for empty answers; we use first column for that
-		CColRef *colref = pexprInner->DeriveOutputColumns()->PcrFirst();
+		// can be used to check for empty answers;
+		// we use first used (referenced in the query) column for that
+		CColRef *colref = pexprInner->DeriveOutputColumns()->PcrFirstUsed();
 
 		if (COperator::EopScalarSubqueryExists == op_id)
 		{

src/test/regress/expected/qp_correlated_query.out

@@ -3910,6 +3910,55 @@ DROP TABLE skip_correlated_t3;
 DROP TABLE skip_correlated_t4;
 reset optimizer_join_order;
 reset optimizer_trace_fallback;
+--------------------------------------------------------------------------------
+-- Ensure ORCA generates the correct plan with the exists clause
+-- for the partitioned table.
+--------------------------------------------------------------------------------
+CREATE TABLE offers (
+    id int,
+    product int,
+    date date
+) DISTRIBUTED BY (id);
+INSERT INTO offers SELECT 0, 0, '2023-01-01';
+CREATE TABLE contacts (
+    contact text,
+    id int,
+    date date
+) DISTRIBUTED BY (id) PARTITION BY RANGE(date) (START (date '2023-01-01') INCLUSIVE END (date '2023-02-01') EXCLUSIVE EVERY (INTERVAL '1 month'));
+NOTICE:  CREATE TABLE will create partition "contacts_1_prt_1" for table "contacts"
+INSERT INTO contacts SELECT '0', 0, '2023-01-01';
+EXPLAIN (COSTS off, VERBOSE on)
+SELECT id FROM offers WHERE EXISTS (
+    SELECT id FROM contacts WHERE product = 0 OR contacts.id = offers.id
+);
+                                                 QUERY PLAN                                                 
+------------------------------------------------------------------------------------------------------------
+ Gather Motion 3:1  (slice3; segments: 3)
+   Output: offers.id
+   ->  HashAggregate
+         Output: offers.id
+         Group Key: offers.ctid, offers.gp_segment_id
+         ->  Redistribute Motion 3:3  (slice2; segments: 3)
+               Output: offers.id, offers.ctid, offers.gp_segment_id
+               Hash Key: offers.ctid
+               ->  Nested Loop
+                     Output: offers.id, offers.ctid, offers.gp_segment_id
+                     Join Filter: ((offers.product = 0) OR (contacts_1_prt_1.id = offers.id))
+                     ->  Append
+                           ->  Seq Scan on qp_correlated_query.contacts_1_prt_1
+                                 Output: contacts_1_prt_1.id
+                     ->  Materialize
+                           Output: offers.id, offers.product, offers.ctid, offers.gp_segment_id
+                           ->  Broadcast Motion 3:3  (slice1; segments: 3)
+                                 Output: offers.id, offers.product, offers.ctid, offers.gp_segment_id
+                                 ->  Seq Scan on qp_correlated_query.offers
+                                       Output: offers.id, offers.product, offers.ctid, offers.gp_segment_id
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(22 rows)
+
+DROP TABLE offers;
+DROP TABLE contacts;
 -- ----------------------------------------------------------------------
 -- Test: teardown.sql
 -- ----------------------------------------------------------------------

src/test/regress/expected/qp_correlated_query_optimizer.out

@@ -4050,6 +4050,58 @@ DROP TABLE skip_correlated_t3;
 DROP TABLE skip_correlated_t4;
 reset optimizer_join_order;
 reset optimizer_trace_fallback;
+--------------------------------------------------------------------------------
+-- Ensure ORCA generates the correct plan with the exists clause
+-- for the partitioned table.
+--------------------------------------------------------------------------------
+CREATE TABLE offers (
+    id int,
+    product int,
+    date date
+) DISTRIBUTED BY (id);
+INSERT INTO offers SELECT 0, 0, '2023-01-01';
+CREATE TABLE contacts (
+    contact text,
+    id int,
+    date date
+) DISTRIBUTED BY (id) PARTITION BY RANGE(date) (START (date '2023-01-01') INCLUSIVE END (date '2023-02-01') EXCLUSIVE EVERY (INTERVAL '1 month'));
+NOTICE:  CREATE TABLE will create partition "contacts_1_prt_1" for table "contacts"
+INSERT INTO contacts SELECT '0', 0, '2023-01-01';
+EXPLAIN (COSTS off, VERBOSE on)
+SELECT id FROM offers WHERE EXISTS (
+    SELECT id FROM contacts WHERE product = 0 OR contacts.id = offers.id
+);
+                                                 QUERY PLAN                                                  
+-------------------------------------------------------------------------------------------------------------
+ Result
+   Output: offers.id
+   ->  Result
+         Output: offers.id, offers.product
+         Filter: (SubPlan 1)
+         ->  Gather Motion 3:1  (slice1; segments: 3)
+               Output: offers.id, offers.product
+               ->  Seq Scan on qp_correlated_query.offers
+                     Output: offers.id, offers.product
+         SubPlan 1  (slice0)
+           ->  Result
+                 Output: contacts.id
+                 Filter: ((offers.product = 0) OR (contacts.id = offers.id))
+                 ->  Materialize
+                       Output: contacts.id
+                       ->  Gather Motion 3:1  (slice2; segments: 3)
+                             Output: contacts.id
+                             ->  Sequence
+                                   Output: contacts.id
+                                   ->  Partition Selector for contacts (dynamic scan id: 1)
+                                         Partitions selected: 1 (out of 1)
+                                   ->  Dynamic Seq Scan on qp_correlated_query.contacts (dynamic scan id: 1)
+                                         Output: contacts.id
+ Optimizer: Pivotal Optimizer (GPORCA)
+ Settings: optimizer=on
+(25 rows)
+
+DROP TABLE offers;
+DROP TABLE contacts;
 -- ----------------------------------------------------------------------
 -- Test: teardown.sql
 -- ----------------------------------------------------------------------

src/test/regress/expected/subselect_gp_optimizer.out

@@ -509,7 +509,6 @@ explain SELECT * FROM csq_r WHERE exists (SELECT * FROM csq_f(csq_r.a));
          SubPlan 1  (slice1; segments: 3)
            ->  Result  (cost=0.00..0.00 rows=1 width=1)
                  ->  Result  (cost=0.00..0.00 rows=1 width=1)
-                       ->  Result  (cost=0.00..0.00 rows=1 width=1)
  Optimizer: Pivotal Optimizer (GPORCA) version 2.55.21
 (8 rows)
 
@@ -529,7 +528,6 @@ explain SELECT * FROM csq_r WHERE not exists (SELECT * FROM csq_f(csq_r.a));
          SubPlan 1  (slice1; segments: 3)
            ->  Result  (cost=0.00..0.00 rows=1 width=1)
                  ->  Result  (cost=0.00..0.00 rows=1 width=1)
-                       ->  Result  (cost=0.00..0.00 rows=1 width=1)
  Optimizer: Pivotal Optimizer (GPORCA) version 2.55.21
 (8 rows)
 

src/test/regress/sql/qp_correlated_query.sql

@@ -834,6 +834,28 @@ DROP TABLE skip_correlated_t4;
 reset optimizer_join_order;
 reset optimizer_trace_fallback;
 
+--------------------------------------------------------------------------------
+-- Ensure ORCA generates the correct plan with the exists clause
+-- for the partitioned table.
+--------------------------------------------------------------------------------
+CREATE TABLE offers (
+    id int,
+    product int,
+    date date
+) DISTRIBUTED BY (id);
+INSERT INTO offers SELECT 0, 0, '2023-01-01';
+CREATE TABLE contacts (
+    contact text,
+    id int,
+    date date
+) DISTRIBUTED BY (id) PARTITION BY RANGE(date) (START (date '2023-01-01') INCLUSIVE END (date '2023-02-01') EXCLUSIVE EVERY (INTERVAL '1 month'));
+INSERT INTO contacts SELECT '0', 0, '2023-01-01';
+EXPLAIN (COSTS off, VERBOSE on)
+SELECT id FROM offers WHERE EXISTS (
+    SELECT id FROM contacts WHERE product = 0 OR contacts.id = offers.id
+);
+DROP TABLE offers;
+DROP TABLE contacts;
 -- ----------------------------------------------------------------------
 -- Test: teardown.sql
 -- ----------------------------------------------------------------------