v4.4.0 Release Notes

Release date: March 2026

Version: v4.4.0

SynxDB v4.4.0 expands GPORCA’s intra-segment parallel execution capabilities, with incremental improvements to data federation, storage, and operational observability, and introduces gpupgrade for in-place major version upgrades.

Query processing and optimization: Extends GPORCA intra-segment parallel execution to support parallel index scans, parallel hash join (Inner, Left Outer, Semi, and Left Anti Semi), hash anti-join, and parallel append for partitioned table scans with an optional parallel partition selector for coordinated dynamic partition elimination; adds CTE-based automatic common subquery elimination to avoid redundant computation in complex analytic queries; broadens the conditions under which parallel hash aggregation applies; and introduces automatic numeric aggregation optimization for numeric(P, 2) columns using 64-bit integer arithmetic.
Data federation and lakehouse integration: Guarantees deterministic row ordering for foreign table insertion and enables HDFS data-locality-aware query planning.
Storage: Adds asynchronous prefetching to PAX micro partition reads and introduces the pax_dump_groups() diagnostic function for inspecting PAX table internal structure.
Observability and reliability: Enhances DBCC with maintenance mode, Blocking Time and Execution Time filters in Query History, improved database parameter configuration management, and proactive table bloat and skew recommendations.
Tools and utilities: Introduces gpupgrade for in-place cluster upgrades, running pg_upgrade across all segments to upgrade to a newer major version without requiring a full data export and reimport.

New features

Database

Category	Feature	User documents
Query processing and optimization	Extends GPORCA intra-segment parallel execution to support parallel index scans, Hash Semi Join, and Hash Left Anti Semi Join.	Execute queries in parallel
Query processing and optimization	Introduces parallel hash join, allowing multiple workers to execute hash join operations concurrently with shared hash tables, supporting Inner Join, Left Outer Join, Semi Join, and Left Anti Semi Join.	Execute queries in parallel
Database maintenance	Adds `analyze_only_modified_relations` to skip `ANALYZE` on unmodified tables, reducing maintenance overhead in large databases.	Skip unmodified relations
Data federation and lakehouse integration	Guarantees deterministic row ordering when inserting into foreign tables using `INSERT INTO ... SELECT ... ORDER BY`.	Write data to a foreign table with ordered insertion
Data federation and lakehouse integration	Adds `datalake.enable_get_block_location` to enable HDFS block location retrieval during directory listing, enabling data-locality-aware query planning for datalake workloads.	Configuration parameters
Storage	Introduces the `pax_dump_groups()` diagnostic UDF to inspect the internal micro partition and group layout of PAX tables.	PAX table format
Query processing and optimization	Introduces parallel append for partitioned table scans, allowing GPORCA to parallelize segment-level scans across partitions. Includes an optional parallel partition selector that coordinates dynamic partition elimination (DPE) across workers using a shared-memory bitmapset.	Query partitioned tables in parallel
Query processing and optimization	Automatically optimizes `SUM` and `AVG` on `numeric(P, 2)` columns (where `P < 17`) by internally converting to 64-bit integer arithmetic, with no configuration required.	Numeric aggregation optimization
Tools and utilities	Introduces `gpupgrade` for in-place cluster upgrades, running `pg_upgrade` across all segments to upgrade to a newer major version without requiring a full data export and reimport.	Upgrade using gpupgrade

Interactive manager DBCC

Feature	User documents
Supports enabling maintenance mode to suspend automatic HA interventions during planned maintenance windows	Manage clusters
Adds Blocking Time and Execution Time filters to the Query History page for more precise query lookup	View SQL monitoring information
Introduces a scheduled scan task that collects table bloat and skew metrics, with results displayed on the Recommendations page	View recommendations

New feature details

Query processing and optimization

GPORCA parallel index scan: GPORCA now supports parallel index scans, enabling multiple workers to execute an index scan concurrently within each segment. When a query has a selective predicate on an indexed column, GPORCA evaluates whether a parallel index scan is more cost-effective than a parallel sequential scan and selects the plan accordingly. This optimization applies to standard B-tree indexes and a wide range of query patterns, including queries with LIMIT, ORDER BY with LIMIT, multiple join types, IN subqueries, and aggregations. In addition, GPORCA extends intra-segment parallel execution to Hash Semi Join (used in EXISTS subqueries) and Hash Left Anti Semi Join (used in NOT IN subqueries), allowing these join types to utilize multiple CPU cores per segment.

See Execute queries in parallel.
GPORCA parallel hash join: GPORCA now supports parallel hash join, allowing multiple workers within each segment to execute hash join operations concurrently using shared hash tables. This reduces join execution time for large datasets by fully leveraging available CPU cores. Supported join types include Inner Join, Left Outer Join, Semi Join (used in EXISTS subqueries), and Left Anti Semi Join (used in NOT IN subqueries).

See Execute queries in parallel.
GPORCA parallel hash anti-join: GPORCA introduces a dedicated CPhysicalParallelLeftAntiSemiHashJoin operator that extends the parallel hash join framework to support Hash Left Anti Semi Join. This enables multiple workers within each segment to execute anti-join operations concurrently, improving performance for large-scale exclusion queries that use NOT IN subqueries.
GPORCA common subquery elimination via CTE: GPORCA can now automatically detect shareable common subqueries (SPJ) within a query and rewrite them as CTEs, so each shared subquery is evaluated only once. This eliminates redundant computation in complex analytic workloads such as TPC-DS Q188, reducing both planning and execution time.
GPORCA parallel hash aggregation enhancements: GPORCA’s parallel hash aggregation now supports local aggregates with proper worker-level distribution and context validation, and is no longer disabled when optimizer_force_multistage_agg is enabled. This broadens the scenarios where parallel aggregation can be applied, improving throughput for GROUP BY-heavy analytic queries.
GPORCA parallel append for partitioned table scans: GPORCA can now generate parallel append paths for partitioned table scans, parallelizing segment-level scans across partitions to improve performance on large partitioned tables. When enabled, GPORCA can additionally generate a parallel partition selector node that coordinates dynamic partition elimination (DPE) across workers using a shared-memory bitmapset, preventing redundant partition scans. Both features are cost-based — GPORCA selects a parallel plan only when it estimates that parallelism is more efficient than the default dynamic scan path.

See Query partitioned tables in parallel and Parallel append for partitioned table scans.
Numeric aggregation optimization for numeric(P, 2): SUM and AVG aggregate functions on numeric(P, 2) columns where P < 17 are now automatically optimized by converting them to efficient 64-bit integer arithmetic internally. This improves analytic query performance for workloads that aggregate monetary amounts, prices, or similar fixed-decimal values. The optimization is fully transparent — query results remain identical and no configuration is required.

See Numeric aggregation optimization.

Database maintenance

Skip ANALYZE on unmodified relations: Adds the analyze_only_modified_relations parameter (default: off). When enabled, ANALYZE checks the changes_since_analyze counter for each relation before analyzing it and skips any relation with no inserts, updates, or deletes since the last analyze. This significantly reduces unnecessary overhead when running scheduled maintenance on large databases where most tables are static. The optimization applies to regular tables, individual leaf partitions of partitioned tables, and VACUUM (ANALYZE) operations.

See Skip unmodified relations.

Data federation and lakehouse integration

Ordered insertion into foreign tables: In SynxDB’s MPP architecture, standard INSERT ... SELECT queries cannot preserve the row order defined by ORDER BY because data is redistributed and written in parallel across segments. For foreign tables, SynxDB now automatically injects an explicit sort operator into the execution plan before the final insertion step when INSERT INTO ... SELECT ... ORDER BY is used. This guarantees deterministic output ordering for ETL pipelines that require sorted data to be written to external tables.

See Write data to a foreign table with ordered insertion.
HDFS block location retrieval for data locality: Adds the datalake.enable_get_block_location parameter (default: off). When enabled, SynxDB retrieves HDFS block location information during directory listing operations, allowing the query planner to assign scan tasks to segments based on data locality. This reduces cross-node data transfer and improves query performance for datalake workloads on HDFS. The parameter has no effect on non-HDFS storage types.

See Configuration parameters.

Storage

PAX prefetch for micro partition reads: PAX storage now prefetches micro partition readers and the first group of each file asynchronously, overlapping I/O with query execution. This reduces read latency for sequential PAX table scans by hiding storage access time behind compute.
pax_dump_groups() diagnostic UDF: Introduces a new diagnostic function that returns the micro partition and group layout of a PAX table, including micro partition ID, number of columns, group index, and row count per group. This allows administrators to evaluate whether storage parameters such as pax.max_tuples_per_group and pax.max_tuples_per_file are appropriately sized, identify uneven data distribution across micro partitions, and debug storage-related performance issues.

See PAX table format.

Observability and reliability

DBCC maintenance mode: DBCC now supports enabling maintenance mode on a cluster, which suspends all automatic high-availability interventions (such as Coordinator restart or Standby activation) while the mode is active. This prevents DBCC from interfering with planned operations such as software upgrades or scheduled database stops, giving administrators full control during maintenance windows.

See Manage clusters.
Query History blocking and execution time filters: The Query History page now supports filtering by Blocking Time and Execution Time ranges, in addition to the existing Query ID, User, Database, and Submitted Time filters. This makes it easier to locate slow or queued queries during performance investigations.

See View SQL monitoring information.
DBCC database parameter configuration improvements: The database parameter configuration page in DBCC now supports sorting by key, more accurate modification tracking, input validation for statement_mem and max_statement_mem, and fixes for comparison and recommended value calculation errors, enabling more reliable and auditable parameter tuning.
DBCC table bloat and skew recommendations: Introduces a configurable scheduled task that periodically scans tables to collect bloat ratio and data skew metrics, with results displayed on the new Recommendations page. This helps administrators proactively identify tables that need VACUUM or redistribution before they impact query performance or storage efficiency.

See View recommendations and Configure scan table task.

Tools and utilities

gpupgrade in-place cluster upgrade: gpupgrade is an in-place upgrade tool for SynxDB clusters that runs pg_upgrade across all segments to upgrade to a newer major version, without requiring a full data export and reimport. The upgrade runs in three stages — initialize, execute, and finalize — allowing administrators to verify compatibility and revert the upgrade before finalization if needed.

See Upgrade using gpupgrade.

Product change information

GUC configuration parameters

Newly added GUCs

The following configuration parameters are added in v4.4.0:

analyze_only_modified_relations: default off. When enabled, ANALYZE skips tables that have not been modified since the last analyze, reducing unnecessary overhead in large databases. See Skip ANALYZE on unmodified relations.
datalake.enable_get_block_location: default off. When enabled, SynxDB retrieves HDFS block location information during directory listing, allowing the query planner to assign scan tasks based on data locality. See Configuration parameters.
fixeddecimal.enable_optimizer: default off. Enables internal arithmetic optimizations for fixeddecimal aggregates.
optimizer_enable_parallel_part_selector: default on. Enables the parallel partition selector for parallel append plans in ORCA.
optimizer_valuescan_threshold: default 100. Sets the maximum number of values per query for which ORCA generates a plan for INSERT INTO ... VALUES statements. When the VALUES list exceeds this threshold, ORCA falls back to the PostgreSQL planner, avoiding a planning overhead regression (measured at over 10×) for bulk inserts.
pg_query_state.enable: default on. Enables the pg_query_state module for tracking in-progress query execution state.
pg_query_state.enable_buffers: default off. Enables buffer usage collection in pg_query_state reports.
pg_query_state.enable_timing: default off. Enables per-node timing data collection in pg_query_state reports.

Changed GUCs

The default value of join_collapse_limit has been changed from 20 to 13. This prevents the PostgreSQL planner from spending excessive time exploring join permutations for queries with approximately 20 joins.
ORCA now refuses to generate parallel plans when statement_mem is below 32 MB per worker (for example, below 64 MB total for two workers). This is a behavioral change: plans that would cause heavy spilling due to insufficient per-worker memory are excluded from parallel execution even though the statement_mem default is unchanged.

Components

Added liburing2 as a runtime dependency. pax.so links against liburing.so.2, and the package now declares this dependency explicitly to prevent runtime link failures.

Bug fixes

Query optimizer and executor

Fixed an assertion failure (ulParallelWorkers > 0) in ORCA triggered when optimizer_enable_parallel_append is disabled, preventing unexpected fallback to the PostgreSQL planner.
Fixed GroupAggregate incorrectly inheriting all pathkeys from its subpath. Only pathkeys that GroupAggregate can maintain are now preserved, preventing wrong results in DISTINCT + GROUP BY queries.
Fixed a null pointer check and a typo in ORCA parallel partition propagation code, preventing potential crashes in ORCA-generated plans.
Fixed a logical operator bug in CPhysicalParallelAppendTableScan::FValidContext that allowed invalid parallel execution contexts to pass validation.
Fixed two issues in CDistributionSpecWorkerRandom conversion to random distribution that could produce incorrect query results in parallel plans.
Added a safety check in CJoinOrderDPv2::PopulateDPEInfo to skip DPE optimization when the derived output column count mismatches the table descriptor (for example, dropped columns or inheritance hierarchies), preventing optimizer crashes on such tables.
Implemented EpetRewindability() for CPhysicalDynamicTableScan to handle rewindability enforcement, eliminating assertion failures during plan context validation.
Corrected storage type detection logic in ORCA to properly identify mixed storage when foreign and non-foreign partitions coexist in a partitioned table.
Fixed DXL translation to use PdxlnParallelAppendTableScan() for PhysicalParallelAppendTableScan nodes in UNION/INTERSECT/EXCEPT queries, preventing incorrect plan translation.
Changed ORCA to rethrow exceptions occurring inside its catch block (for example, OOM during CloneErrorMsg) to the PostgreSQL error handler instead of calling std::terminate, converting fatal server process crashes to recoverable errors.
Added hash function existence validation in ORCA using get_op_hash_functions() before generating HashAgg plans, eliminating runtime could not find hash function errors for operators with oprcanhash=true but no actual hash function.
Added a guard in CPhysicalHashJoin to verify non-empty selector_ids before computing DPE join predicates on partition keys, reducing planning time and avoiding invalid memory accesses in complex DPE + hash join plans.
Fixed a memory leak in CWindowOids by adding a destructor to release three CMDIdGPDB objects (m_MDIdRowNumber, m_MDIdRank, m_MDDenseRank), improving long-running stability for queries using window functions.
Fixed incorrect varno construction when building runtime filters under APPEND operators, ensuring correct data filtering for subplans with mixed varno values.
Reverted parallel plan support under WindowAgg that caused double-free memory corruption when combined with parallel append on partitioned tables.

Storage and access methods

Fixed three bugs in PAX bitmap scan: lossy TBMIterateResult was not handled, invisible tuples incorrectly skipped subsequent tuples in the same file, and toast files were not handled. These issues could cause incorrect query results for bitmap index scans on PAX tables.
Ensured opened directories are properly closed in LocalFileSystem::ListDirectory, including on exception paths, preventing file descriptor leaks in PAX.
Fixed incorrect end_index increment in the PAX parallel iterator that caused a worker to skip a micro partition when processing consecutive scan ranges, preventing silent data loss in parallel PAX scans.
Ensured the future object in PAX TableReader is always consumed when Close() is called, even if reading stopped before the micro partition was fully scanned, preventing resource leaks and potential hangs on early-terminated reads.
Fixed incorrect use of a stack array for abi::__cxa_demangle output in PAX exception handling, which must be heap-allocated because it might be extended by realloc, preventing undefined behavior and crashes.
Removed local files from PaxResourceList management because C++ RAII correctly handles their lifecycle, simplifying resource management and reducing risk of double-free errors.

Processes and concurrency

Fixed static variable inheritance and contamination in forked processes, preventing subtle data corruption or incorrect behavior caused by shared static state being inherited across fork boundaries.
Fixed gpcheckresgroupv2impl failing on segment hosts by retrieving cgroup_parent from the master database and passing it via CLI argument, removing the incorrect localhost:5432 connection attempt on segments. This allows gpconfig to correctly apply resource group v2 settings across all segment hosts.
Updated gpstop and gpstart to use a shared helper for coordinator data directory detection, providing clearer error messages when COORDINATOR_DATA_DIRECTORY is unset or invalid.

Security

Backported the fix for CVE-2022-41862: properly NULL-terminates the GSS receive buffer on error packet reception, preventing potential crash or memory disclosure when a malicious server sends an unterminated error string via the GSS protocol.
Backported the fix for CVE-2023-5868: moved aggargtypes collection to after DISTINCT handling in transformAggregateCall(), preventing a type mismatch that could expose server memory when DISTINCT aggregate calls use unknown-type literals.
Backported the fix for CVE related to extended statistics permissions: corrected the column permission check by applying pull_varattnos to the correct pointer and accounting for attnum offset, preventing unrecognized node type errors in extended statistics permission checks.

Tools and utilities

Fixed gplogfilter memory growth caused by StringIO.truncate(0) without a preceding seek(0), which caused csv.writer to append at ever-increasing offsets, growing the buffer indefinitely.
Fixed pg_upgrade and pg_dump to include database type and version information, distinguishing different catalog formats and resolving several issues encountered during upgrade workflows.
Fixed LD_LIBRARY_PATH in gpupgrade invocation by adding $GPHOME/lib, preventing runtime library loading errors during database upgrade operations.
Added #!/usr/bin/env bash shebang to failover shell scripts that lacked it, ensuring scripts are packaged correctly in RPM builds and remain executable after installation.
Fixed PAX build failure on GCC 8.x (Rocky Linux 8) by removing the -Werror=pessimizing-move flag unavailable on GCC 8.x, adding missing <unistd.h>, and defining a uring_likely fallback for older liburing versions.

Observability

Added a divide-by-zero guard in gpmmon aggregate computations, preventing crashes in the performance monitoring daemon when aggregate denominators are zero.
Added a pre-check to ensure the gp_toolkit extension exists before DBCC attempts to scan tables, preventing DBCC failures on databases where gp_toolkit is not installed.
Adjusted the repeat interval for standby and segment health alerts to reduce alert noise and duplicate notifications.
Fixed distributor switching in DBCC by correctly setting distributor parameters in the build environment and adding aliases for logo and icon asset paths.
Fixed internationalization and display rendering bugs in the DBCC UI.