Merge branch 'main' into wjdejidew

Author: reshke

.github/workflows/build-cloudberry-rocky8.yml

@@ -339,6 +339,10 @@ jobs:
               },
               {"test":"ic-cbdb-parallel",
                "make_configs":["src/test/regress:installcheck-cbdb-parallel"]
+              },
+              {"test":"ic-recovery",
+               "make_configs":["src/test/recovery:installcheck"],
+               "enable_core_check":false
               }
             ]
           }'

contrib/pax_storage/src/test/regress/expected/groupingsets_optimizer.out

@@ -949,21 +949,21 @@ select v.c, (select count(*) from gstest2 group by () having v.c)
 explain (costs off)
   select v.c, (select count(*) from gstest2 group by () having v.c)
     from (values (false),(true)) v(c) order by v.c;
-                                QUERY PLAN                                
---------------------------------------------------------------------------
- Sort
-   Sort Key: "*VALUES*".column1
-   ->  Values Scan on "*VALUES*"
-         SubPlan 1
-           ->  Aggregate
-                 Group Key: ()
-                 Filter: "*VALUES*".column1
-                 ->  Result
-                       One-Time Filter: "*VALUES*".column1
-                       ->  Materialize
-                             ->  Gather Motion 3:1  (slice1; segments: 3)
+                             QUERY PLAN
+--------------------------------------------------------------------
+ Result
+   ->  Sort
+         Sort Key: "Values".column1
+         ->  Values Scan on "Values"
+   SubPlan 1
+     ->  Result
+           One-Time Filter: "Values".column1
+           ->  Finalize Aggregate
+                 ->  Materialize
+                       ->  Gather Motion 3:1  (slice1; segments: 3)
+                             ->  Partial Aggregate
                                    ->  Seq Scan on gstest2
- Optimizer: Postgres query optimizer
+ Optimizer: GPORCA
 (13 rows)
 
 -- HAVING with GROUPING queries

devops/build/automation/cloudberry/scripts/parse-results.pl

@@ -110,7 +110,7 @@
 my @ignored_test_list = ();
 
 while (<$fh>) {
-    # Match the summary lines
+    # Match the summary lines (pg_regress format)
     if (/All (\d+) tests passed\./) {
         $status = 'passed';
         $total_tests = $1;
@@ -132,8 +132,22 @@
         $status = 'failed';
         $failed_tests = $1 - $3;
         $ignored_tests = $3;
-        $total_tests = $2;
-        $passed_tests = $2 - $1;
+
+    # TAP/prove summary format: "Files=N, Tests=N, ..."
+    } elsif (/^Files=\d+, Tests=(\d+),/) {
+        $total_tests = $1;
+
+    # TAP/prove result: "Result: PASS" or "Result: FAIL"
+    } elsif (/^Result: PASS/) {
+        $status = 'passed';
+        $passed_tests = $total_tests;
+        $failed_tests = 0;
+    } elsif (/^Result: FAIL/) {
+        $status = 'failed';
+
+    # TAP individual test failure: "  t/xxx.pl (Wstat: ...)"
+    } elsif (/^\s+(t\/\S+\.pl)\s+\(Wstat:/) {
+        push @failed_test_list, $1;
     }
 
     # Capture failed tests
@@ -150,8 +164,15 @@
 # Close the log file
 close $fh;
 
-# Validate failed test count matches found test names
-if ($status eq 'failed' && scalar(@failed_test_list) != $failed_tests) {
+# For TAP format, derive failed/passed counts from collected test names
+if ($status eq 'failed' && $failed_tests == 0 && scalar(@failed_test_list) > 0) {
+    $failed_tests = scalar(@failed_test_list);
+    $passed_tests = $total_tests - $failed_tests if $total_tests > 0;
+}
+
+# Validate failed test count matches found test names (pg_regress format only)
+if ($status eq 'failed' && $failed_tests > 0 && scalar(@failed_test_list) > 0
+    && scalar(@failed_test_list) != $failed_tests) {
     print "Error: Found $failed_tests failed tests in summary but found " . scalar(@failed_test_list) . " failed test names\n";
     print "Failed test names found:\n";
     foreach my $test (@failed_test_list) {

pom.xml

@@ -572,7 +572,6 @@ code or new licensing patterns.
 
             <exclude>src/backend/gporca/cmake/FindXerces.cmake</exclude>
             <exclude>src/backend/gporca/concourse/build_and_test.py</exclude>
-            <exclude>src/backend/gporca/concourse/xerces-c/build_xerces.py</exclude>
             <exclude>src/backend/gporca/concourse/xerces-c/xerces-c-3.1.2.tar.gz.sha256</exclude>
             <exclude>src/backend/gporca/server/fixdxl.sh</exclude>
             <exclude>src/backend/gporca/server/include/unittest/gpopt/operators/CScalarIsDistinctFromTest.h</exclude>

src/backend/access/transam/xact.c

@@ -3036,13 +3036,15 @@ CommitTransaction(void)
 	DoPendingDbDeletes(true);
 
 	/*
-	 * Only QD holds the session level lock this long for a movedb operation.
-	 * This is to prevent another transaction from moving database objects into
-	 * the source database oid directory while it is being deleted. We don't
-	 * worry about aborts as we release session level locks automatically during
-	 * an abort as opposed to a commit.
-	 */
-	if(Gp_role == GP_ROLE_DISPATCH || IS_SINGLENODE())
+	 * Release the session level lock held for a movedb operation. This is to
+	 * prevent another transaction from moving database objects into the source
+	 * database oid directory while it is being deleted. We don't worry about
+	 * aborts as we release session level locks automatically during an abort
+	 * as opposed to a commit. We must also release in utility mode (e.g.
+	 * standalone backends used in TAP tests).
+	 */
+	if (Gp_role == GP_ROLE_DISPATCH || Gp_role == GP_ROLE_UTILITY ||
+		IS_SINGLENODE())
 		MoveDbSessionLockRelease();
 
 	/*

src/backend/commands/tablespace.c

@@ -328,7 +328,7 @@ CreateTableSpace(CreateTableSpaceStmt *stmt)
 	}
 
 	if (!location)
-		location = pstrdup(stmt->location);
+		location = pstrdup(stmt->location ? stmt->location : "");
 
 	if (stmt->filehandler)
 		fileHandler = pstrdup(stmt->filehandler);
@@ -1230,14 +1230,19 @@ destroy_tablespace_directories(Oid tablespaceoid, bool redo)
 	linkloc = pstrdup(linkloc_with_version_dir);
 	get_parent_directory(linkloc);
 
-	/* Remove the symlink target directory if it exists or is valid. */
+	/*
+	 * Remove the symlink target directory if it exists or is valid.
+	 * If linkloc is a directory (e.g. in-place tablespace), readlink()
+	 * will fail with EINVAL, which we can safely skip.
+	 */
 	rllen = readlink(linkloc, link_target_dir, sizeof(link_target_dir));
 	if(rllen < 0)
 	{
-		ereport(redo ? LOG : ERROR,
-				(errcode_for_file_access(),
-					errmsg("could not read symbolic link \"%s\": %m",
-						   linkloc)));
+		if (errno != EINVAL)
+			ereport(redo ? LOG : ERROR,
+					(errcode_for_file_access(),
+						errmsg("could not read symbolic link \"%s\": %m",
+							   linkloc)));
 	}
 	else if(rllen >= sizeof(link_target_dir))
 	{

src/backend/gporca/concourse/xerces-c/build_xerces.py

@@ -308,6 +308,93 @@ CSubqueryHandler::FProjectCountSubquery(CExpression *pexprSubquery,
 }
 
 
+//---------------------------------------------------------------------------
+//	@function:
+//		FContainsEmptyGbAgg
+//
+//	@doc:
+//		Return true if pexpr contains a GbAgg with empty grouping columns
+//		(i.e., GROUP BY ())
+//
+//---------------------------------------------------------------------------
+static BOOL
+FContainsEmptyGbAgg(CExpression *pexpr)
+{
+	if (COperator::EopLogicalGbAgg == pexpr->Pop()->Eopid())
+	{
+		return 0 == CLogicalGbAgg::PopConvert(pexpr->Pop())->Pdrgpcr()->Size();
+	}
+	const ULONG arity = pexpr->Arity();
+	for (ULONG ul = 0; ul < arity; ul++)
+	{
+		CExpression *pexprChild = (*pexpr)[ul];
+		if (pexprChild->Pop()->FLogical() && FContainsEmptyGbAgg(pexprChild))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+//---------------------------------------------------------------------------
+//	@function:
+//		FHasCorrelatedSelectAboveGbAgg
+//
+//	@doc:
+//		Return true if pexpr has a CLogicalSelect with outer references in its
+//		filter predicate that sits above a GROUP BY () aggregate.  This pattern
+//		arises when a correlated scalar subquery has a correlated HAVING clause,
+//		e.g. "SELECT count(*) FROM t GROUP BY () HAVING outer_col".
+//
+//		When such a pattern exists the scalar subquery must NOT be decorrelated
+//		with COALESCE(count,0) semantics: if the HAVING condition is false the
+//		subquery should return NULL (no rows), not 0.
+//
+//---------------------------------------------------------------------------
+static BOOL
+FHasCorrelatedSelectAboveGbAgg(CExpression *pexpr)
+{
+	// Stop recursion at a GbAgg boundary: we are looking for a Select
+	// that sits *above* a GbAgg, so once we reach the GbAgg there is
+	// nothing more to check in this branch.
+	if (COperator::EopLogicalGbAgg == pexpr->Pop()->Eopid())
+	{
+		return false;
+	}
+
+	if (COperator::EopLogicalSelect == pexpr->Pop()->Eopid() &&
+		pexpr->HasOuterRefs())
+	{
+		// The Select has outer references somewhere in its subtree.
+		// Check whether they originate from the filter (child 1) rather
+		// than from the logical child (child 0).  If the logical child has
+		// no outer refs but the Select as a whole does, the outer refs must
+		// come from the filter predicate — exactly the correlated-HAVING
+		// pattern we want to detect.
+		CExpression *pexprLogicalChild = (*pexpr)[0];
+		if (!pexprLogicalChild->HasOuterRefs() &&
+			FContainsEmptyGbAgg(pexprLogicalChild))
+		{
+			return true;
+		}
+	}
+
+	// Recurse into logical children only.
+	const ULONG arity = pexpr->Arity();
+	for (ULONG ul = 0; ul < arity; ul++)
+	{
+		CExpression *pexprChild = (*pexpr)[ul];
+		if (pexprChild->Pop()->FLogical() &&
+			FHasCorrelatedSelectAboveGbAgg(pexprChild))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
 //---------------------------------------------------------------------------
 //	@function:
 //		CSubqueryHandler::SSubqueryDesc::SetCorrelatedExecution
@@ -382,6 +469,21 @@ CSubqueryHandler::Psd(CMemoryPool *mp, CExpression *pexprSubquery,
 	// set flag of correlated execution
 	psd->SetCorrelatedExecution();
 
+	// A correlated scalar subquery of the form
+	//   SELECT count(*) FROM t GROUP BY () HAVING <outer_ref_condition>
+	// must execute as a correlated SubPlan.  After NormalizeHaving() the HAVING
+	// clause becomes a CLogicalSelect with outer refs sitting above the GbAgg.
+	// If we decorrelate such a subquery the join filter replaces the HAVING
+	// condition, but a LEFT JOIN returns 0 (not NULL) for count(*) when no
+	// rows match — which is semantically wrong.  Forcing correlated execution
+	// preserves the correct NULL-when-no-rows semantics.
+	if (!psd->m_fCorrelatedExecution && psd->m_fHasCountAgg &&
+		psd->m_fHasOuterRefs &&
+		FHasCorrelatedSelectAboveGbAgg(pexprInner))
+	{
+		psd->m_fCorrelatedExecution = true;
+	}
+
 	return psd;
 }
 
@@ -753,8 +855,19 @@ CSubqueryHandler::FCreateOuterApplyForScalarSubquery(
 	*ppexprNewOuter = pexprPrj;
 
 	BOOL fGeneratedByQuantified = popSubquery->FGeneratedByQuantified();
+
+	// When GROUP BY () has a correlated HAVING clause (now represented as a
+	// CLogicalSelect with outer refs sitting above the GbAgg), the subquery
+	// must return NULL — not 0 — when the HAVING condition is false.
+	// Applying COALESCE(count,0) would incorrectly convert that NULL to 0,
+	// so we skip the special count(*) semantics in that case.
+	BOOL fCorrelatedHavingAboveEmptyGby =
+		(fHasCountAggMatchingColumn && 0 == pgbAgg->Pdrgpcr()->Size() &&
+		 FHasCorrelatedSelectAboveGbAgg((*pexprSubquery)[0]));
+
 	if (fGeneratedByQuantified ||
-		(fHasCountAggMatchingColumn && 0 == pgbAgg->Pdrgpcr()->Size()))
+		(fHasCountAggMatchingColumn && 0 == pgbAgg->Pdrgpcr()->Size() &&
+		 !fCorrelatedHavingAboveEmptyGby))
 	{
 		CMDAccessor *md_accessor = COptCtxt::PoctxtFromTLS()->Pmda();
 		const IMDTypeInt8 *pmdtypeint8 = md_accessor->PtMDType<IMDTypeInt8>();