All Products
Search

This Product

    PolarDB:Release notes for PolarDB for MySQL 8.0.1

    Document Center

    PolarDB:Release notes for PolarDB for MySQL 8.0.1

    Last Updated:Jul 07, 2026

    This topic provides the release notes for PolarDB for MySQL 8.0.1.

    2026

    8.0.1.1.55.1 (2026-06-28) & 8.0.1.1.55 (2026-06-18)

    New features

    Description

    • Adds the incremental refresh for materialized views feature. This feature is an evolution of full materialized view refresh, supports incremental refreshes, and significantly improves materialized view refresh performance.

    • In-Memory Column Index (IMCI) full-text indexes now support custom dictionaries, allowing you to use business-specific dictionaries to improve the retrieval quality for Chinese text and proper nouns.

    • Orca (Redis-compatible) supports the Redis multi-DB feature, with support for up to 16 logical DBs.

    • Materialized views now support building an In-Memory Column Index (IMCI) with sort keys to further optimize their query performance.

    • A new switch is added to enable the Data Cleanup (TTL) feature to write to binary logs. This switch is disabled by default. When enabled, it lets you synchronize TTL deletion events to downstream systems using binary logging to ensure data consistency between upstream and downstream systems.

    • Orca (Redis-compatible) adds five blocking commands (BLMOVE, BLMPOP, BZMPOP, BZPOPMAX, and BZPOPMIN) to enhance Redis protocol compatibility.

    • Added a feature that allows IMCI queries to push down GROUP BY during the optimization phase to optimize query performance by pushing down aggregation operations.

    • Adds the EXPLAIN ANALYZE IMCI syntax. This helps diagnose the intermediate states of SQL execution plans and identify why an SQL statement fails to use a vectorized engine execution plan.

    • Added support for using adaptive selection of ordered indexes multiple times in a statement and fixed an issue where adaptive ordering crashed in specific scenarios.

    Performance optimizations

    Description

    • IMCI storage, with local dictionary encoding enabled by default, supports query rewrite and optimization for string columns that use this encoding, improving columnstore query performance.

    • Optimizes the execution efficiency of SQL statements that follow the GROUP BY ... ORDER BY ... LIMIT k pattern. The TopAgg operator is used to prune grouping and aggregation operations, keeping only K elements. This significantly reduces query time in scenarios with large data volumes and grouping.

    • Enhanced the In-Memory Column Index (IMCI) EXPLAIN ANALYZE performance analysis capabilities by adding metrics such as the join spill-to-disk ratio and join key length to facilitate slow query identification.

    • Optimized the performance of In-Memory Column Index (IMCI) HashJoin by converting the intermediate results of the join to a row format to reduce materialization overhead.

    Bug fixes

    Description

    • Fixes a potential crash that occurred when an incremental materialized view read partition metadata in a hybrid partitioned table.

    • Fixes a potential crash of the mysqld process. This issue was caused by the incorrect reuse of memory related to SQL hints, such as SET_VAR, when a stored procedure was called multiple times.

    • Fixes a failure that occurred when running an Online DDL statement on a table with a virtual column index.

    • Fixed an issue where LRU_RB_BLOCK memory could leak from the IMCI RowBuf cache on an insert failure path, preventing the RowBuf Block Cache memory from continuously growing beyond its expected capacity.

    • Fixed a process crash caused by concurrent access to an MDL Ticket during Elastic Parallel Query execution.

    • Fixed an issue where multiple threads could deadlock inside a B-tree when parallel query is enabled on the primary node.

    • Fixes an issue where a failed LOAD DATA operation caused an abnormal session state, leading to errors in subsequent valid INSERT statements.

    • Fixes a memory leak that could occur in rare cases when Parallel Parse was enabled.

    • Fixes an issue where filesort was sometimes incorrectly skipped for a TempTable with a sorted index, resulting in an incorrect result order.

    • Fixes an issue where the total disk usage control for temporary tables did not exclude users with Super permissions.

    • Fixes a parsing failure in the DTS synchronization link to a downstream PolarDB cluster. This issue occurred when extended PolarDB ALTER syntax, such as converting a single table to a partitioned table, was encapsulated by DMS comments.

    • Fixes an issue with inaccurate adaptive rate limiting for DDL Bulk Load and optimizes the adaptive rate limiting algorithm.

    • Fixed an issue where an error in page size overflow routing during IMCI RowBuf metadata cleanup caused dirty writes, which led to subsequent background tasks triggering an Assert or a crash.

    • Fixed an issue where the High-Compression Engine (X-Engine) crashed when you manually executed ANALYZE TABLE on a partitioned table to collect statistics.

    • Fixes an issue where the declared order in an ORDER BY clause was not applied in some scenarios. This release also optimizes predicate handling for Loose Index Scan (LIS) in grouped queries.

    • Fixes an issue where a local read-only node in a Multi-master Cluster failed to skip the redo logs of other master nodes when Parallel Parse was enabled.

    • Fixed an issue where the In-Memory Column Index (IMCI) became invalid and unavailable after a DDL statement was executed on a partitioned table to modify the table comment, add an In-Memory Column Index (IMCI), and simultaneously add a regular secondary index.

    • Fixed an issue where a column store query using Hybrid Index Search with a LIMIT clause could fall back to a row store when the LIMIT OFFSET was too large.

    • Fixes an issue where INSTANT ADD COLUMN could cause apply exceptions on a read-only (RO) node when the dummy_index sharing optimization was enabled.

    • Fixed an issue in In-Memory Column Index (IMCI) where a Hybrid Plan could cause the cluster to crash when a Read View was revoked.

    • Fixed an issue where incompletely applied Redo logs could cause data inconsistency for the High-compression Engine (X-Engine) during database and table recovery (such as PITR and cloning), ensuring data integrity after restoration.

    • Fixes various incompatibility issues that occurred in Multi-master Clusters when Parallel Parse was enabled.

    • Fixes an incorrect string escaping issue that could occur when PolarDB AutoETL created a search view containing an ETL_UDF.

    • Fixed an issue where the table row lock wait time for the X-Engine engine was not included in the system slow query log lock wait time.

    • Fixes an issue with suboptimal execution plans. This was caused by an incorrect threshold estimation when a column store query with a multi-column IN list, such as WHERE (a,b) IN (...), was converted to a semi-join.

    • Fixed an issue where history records for Data cleanup (TTL) tasks failed to be written during a cluster upgrade, ensuring that TTL history information can be viewed and cleaned up.

    • Fixes an issue where purging binary logs during the startup of MySQL Community Edition could lead to an incorrect Previous_gtid.

    • Fixed an issue where the Query Cache prematurely triggered an InnoDB global consistency (high-performance mode) wait, which caused replication delay timeouts on In-Memory Column Index (IMCI) read-only nodes.

    • Fixed an issue in Orca (Redis-compatible) where Lua scripts could cause a memory leak under sporadic error conditions.

    • Fixes a potential error in parallel query results when the query contained an IS NULL condition.

    • Fixed an issue where Orca (Redis-protocol compatible) Hash Field-TTL could incorrectly update metadata during the Purge phase.

    • Fixed an issue with the Orca (compatible with the Redis protocol) feature where the result of the DUMP command was not recognized by earlier versions of Redis (<7.4.0).

    • Fixes a crash in MySQL Community Edition. This was caused by an exception when updating a spatial index that was also a secondary index.

    8.0.1.1.54.1 (2026-05-08)

    Bug fixes

    Description

    • A new parameter, mm_enable_wait_binlog_flush, is added to allow the Multi-master Cluster (Limitless) Edition to wait for the binary log to be flushed to disk, which resolves potential data consistency issues caused by asynchronous binary log flushing.

    • Fixed an issue where a Multi-master Cluster (Limitless) Edition crashed when DROP TABLE was executed on a CSV table that used the cold data archiving feature.

    8.0.1.1.54 (2026-03-24)

    New features

    Description

    • Added the Search View feature for PolarSearch, which enables Auto-ETL from PolarDB for MySQL to PolarSearch and streamlines data synchronization.

    • The traditional InnoDB compressed table format poses a risk of data corruption when BLOCK_SIZE is less than 4. The polar_compressed_table_policy system variable is added to control the compression policy for new tables.

      • NATIVE: Executes the operation as is.

      • ADJUST_KEY_BLOCK_SIZE (default): Allows table creation and automatically corrects the KEY_BLOCK_SIZE if it is less than 4.

      • AUTO_CONVERT_ROW_FORMAT: Silently converts the table to the default row format.

      • REJECTED: Rejects the operation and reports an error.

      Note

      • This policy applies only to new compressed tables. Existing compressed tables are not affected.

      • For clusters with a kernel version earlier than 8.0.1.1.54, we recommend that you do not create InnoDB compressed tables with a BLOCK_SIZE of less than 4.

    • You can now use the ask_polar expression to connect directly to Alibaba Cloud Model Studio.

    • The Data Cleanup (TTL) feature now supports DATETIME fields (previously, only TIMESTAMP fields were supported).

    Performance optimizations

    Description

    Bug fixes

    Description

    • Fixed an issue where, when using the transaction status preservation feature for failover with hot replica, occasional transaction loss in columnstore index (IMCI) caused data inconsistency.

    • Fixed an issue where a memory exception during an asynchronous instant column addition operation with a long string default value caused the default value to become invalid.

    • Fixes an issue where the optimized histogram sampling process continuously blocked DML operations.

    • Fixed an issue in IMCI where a filter condition was incorrectly pushed down past a `LIMIT` clause, which could cause incorrect results.

    • Fixed an issue where the latest results could not be read immediately after a full refresh of a materialized view when Query Cache is enabled.

    • Fixed an issue where an error might occur when collecting statistics for In-Memory Column Index (IMCI) with the low-cardinality column sampling enhancement (imci_stats_scan_max_ndv) enabled, which prevented the statistics from being updated correctly.

    • Fixes a crash caused by pushing down an expression containing Item_trigger_field into the inner side of a derived table.

    • Fixes a potential SQL statement parsing error when using dbms_outln.add_optimizer_outline_sharding on a sharded table.

    • Fixes an error that occurred when running ALTER TABLE ... ADD COLUMN ... DEFAULT with binary logging enabled.

    • Fixes an issue where the cardinality statistics seen with the SHOW INDEX syntax for a partitioned table were NULL.

    • Fixed an issue that could cause Orca (compatible with the Redis protocol) to crash when cleaning up expired keys with pcur by replacing the pcur method with a key storage method.

    • Fixed an issue where Concurrency Control (CCL) did not take effect for the DELETE xx FROM ... syntax (this does not affect the DELETE FROM ... syntax).

    • Fixes a crash that could occasionally occur with JSON_TABLE in the execution path of a trigger.

    • Fixed an issue where an INT integer overflow in the In-Memory Column Index (IMCI) NCI file system after a prolonged runtime led to an out-of-bounds memory access, causing the IMCI transaction replay to get stuck.

    8.0.1.1.53.1 (2026-07-02) & 8.0.1.1.53 (2026-01-24)

    New features

    Description

    Performance optimizations

    Description

    • Optimized the metadata management mechanism for the high-compression engine (X-Engine). By periodically releasing the manifest log and old versions of the manifest checkpoint, this optimization prevents extra storage consumption caused by the continuous growth of metadata files.

    • Optimizes the I/O read and write efficiency of binary log index files. This optimization prevents transaction commit delays or stuttering caused by I/O contention when a cluster has many binary log files.

    • Optimized the query performance of IMCI for queries that contain an IN-list of extra-long strings.

    • Optimizes the execution efficiency of grouping and aggregation (HashGroupby). By introducing a vectorized operation to probe the hash table, this optimization improves the performance of grouping and aggregation while slightly reducing memory consumption during computation.

    • Optimizes the query plan search process to speed up the search for the join order of multiple tables. This reduces the overall optimization time for complex SQL statements.

    • Removes the limit on the number of partitioned tables.

    Bug fixes

    Description

    • Fixed an issue in IMCI where the high-performance HashJoin operator could cause a loss of rows in the result set when processing a RIGHT JOIN and data is spilled to disk.

    • Fixes an issue where the optimizer inaccurately estimated the number of rows for an ordered index scan in certain query paths.

    • Fixes an issue where statistics might not be collected as expected for string columns with wide character sets, such as utf8, even if they were defined with a short length.

    • Fixed an issue where replication on a columnstore index read-only node occasionally stalled during frequent DDL operations, leading to data latency on the node.

    • Fixes an out-of-bounds memory access issue that could occur with a LIMIT BY ? statement containing a placeholder when using the binary protocol.

    • Fixed a potential cluster crash that occurred when accessing an high-compression engine (X-Engine) partitioned table with the query cache enabled.

    • Fixed an issue where the PCU of a Serverless node for In-Memory Column Index (IMCI) could repeatedly scale up and down when the node had low specifications and no load.

    2025

    8.0.1.1.52 (2025-12-12)

    New features

    Description

    • Added the Search View and ETL Stored Procedure feature. This feature automatically synchronizes data from PolarDB for MySQL to search nodes to enhance the capabilities for data synchronization and aggregated analysis of massive data.

    • Introduced the Redo log compression feature for DDL operations. This feature significantly reduces the amount of Redo logs generated during DDL execution and improves Redo operation efficiency.

    • Added support for specifying the execution node for refresh tasks that perform a full refresh of a materialized view.

    • Adds the feature for aggregation nodes in a Multi-master Cluster to asynchronously read Redo logs. This feature improves the rate at which aggregation nodes merge Redo logs.

    • Added a monitoring metric for the number of pending tasks in Orca (compatible with the Redis protocol). This metric shows the number of tasks in the task queue that are waiting to be executed. This helps you analyze and monitor task latency.

    • Added support for specific SQL patterns for IMCI. Now, complex queries that contain ROLLUP and have functions in their projection columns that include subqueries with aggregate functions can also be pushed down to IMCI for acceleration.

    • Added support for full-text indexes to In-Memory Column Index (IMCI), which significantly improves the performance of fuzzy searches.

    • Added multiple core monitoring metrics for Orca (compatible with the Redis protocol), such as active connections, New Connections, and memory usage, to enhance cluster observability.

    • Adds a dynamic switch to control the cursor position adjustment feature on read-only (RO) nodes.

    Performance optimizations

    Description

    • Optimized the query execution policy for In-Memory Column Index (IMCI) and enabled adaptive grouping and aggregation execution by default. This feature automatically selects the most efficient aggregation algorithm based on data distribution and query characteristics to improve the performance of analytical queries that contain a GROUP BY clause.

    • Improved the execution efficiency of the Hash Join operator in In-Memory Column Index (IMCI). This enhancement improves the performance of all queries that use Hash Join, with significant improvements for Semi Join scenarios.

    • Optimized the performance of Binlog large transaction optimization in external XA transaction scenarios.

    • Optimized the metadata management mechanism of the X-Engine by periodically releasing manifest log and old versions of manifest checkpoint to prevent additional storage usage caused by the continuous growth of metadata files.

    • Optimizes the performance overhead of switching binary log files. This prevents transaction commit blocking in scenarios where many binary log files are retained.

    • Optimized the internal command processing structure and locking path for Orca (compatible with the Redis protocol). This refactoring improved its overall read and write performance by about 10%.

    Bug fixes

    Description

    • Fixed an issue in Orca (compatible with the Redis protocol) where writing a key immediately after deleting it caused the dbsize statistics information to be inaccurate.

    • Fixed an issue where IMCI did not support queries that contain system variable fields.

    • Fixes a potential failure in statistics collection on tables with frequent update and delete operations, and improves the efficiency of data sampling.

    • Fixed an issue where the restore command of Orca (compatible with the Redis protocol) failed to preserve TTL information when restoring an expired Hash field.

    • Fixed an issue where the serverless feature for In-Memory Column Index (IMCI) could cause an out-of-memory (OOM) error in scenarios of rapid scale-up followed by rapid scale-down, because the cache quota was not revoked in a timely manner.

    • Fixed an issue where restarting an IMCI node for column index recovery could result in a slow startup because an excessive number of irrelevant NCI files were loaded.

    • Fixes an issue where an incorrect result set could be returned when the WHERE condition of a query contained multiple IN-lists with ORDER BY sorting.

    • Fixes an issue where a Duplicate entry error could be reported when performing DDL operations such as RENAME TABLE on a table containing a view after a high-availability (HA) switchover.

    • Fixed an issue where the NCI purge page operation for IMCI interfered with the efficiency of the flush page operation in rare cases.

    • Fixes a data synchronization anomaly in the aggregation node of a Multi-master Cluster after enabling the async reader feature. This was caused by an incorrect calculation of the parse offset.

    • Fixed an issue where the auto-scaling of the serverless feature for In-Memory Column Index (IMCI) was continuously triggered due to an abnormal index status.

    • Fixed an issue in Multi-master Cluster (Limitless) Edition where a read/write node might fail when refreshing a scheduled materialized view created by another read/write node.

    • Fixes a performance issue where a single CPU core's usage was maxed out due to the excessive time taken by the find_cloned_select_lex function when a UNION query contained many query_blocks.

    • Fixes an issue where the query optimizer failed to perform partition pruning on an inner partitioned table when processing a nested join query. This improves the query performance of partitioned tables in related scenarios.

    • Fixed an issue where In-Memory Column Index (IMCI) could return incorrect multiplication results when processing DECIMAL data with more than 16 digits after the decimal point.

    • Fixed an issue that prevented a query from being pushed down to In-Memory Column Index (IMCI) for execution when the SELECT statement contained both an IN-List and an aggregate function with DISTINCT.

    • Fixes multiple issues that could trigger a cluster crash when the buffer pool size was much smaller than the memory required for materialized tables.

    • Fixed an issue in the Multi-master Cluster (Limitless) Edition where deleting a read/write node after an endpoint switch could cause background tasks to be interrupted.

    • Fixes a potential hang issue on a standby node during the recovery phase in point-in-time restore (PITR) and database/table restoration scenarios.

    • Fixed an issue where the ETL feature of IMCI did not support the JSON_TABLE function, and optimized the out-of-memory error message for IMCI queries.

    • Fixes an issue where released memory was still being used after a failed function-based index creation and rollback.

    • Fixes an issue where a read-only node returned a The JSON binary value contains invalid data error when querying the length of a JSON object under specific boundary conditions after the innodb_blob_slave_read_consistent parameter was enabled.

    • Fixes an issue where statistics for integer columns other than BIGINT could be inaccurate, causing the query optimizer to fail to generate an optimal execution plan.

    • Fixed an issue where queries with recursive Common Table Expressions (CTEs) could not be pushed down to the In-Memory Column Index (IMCI) for execution.

    • Fixes a rare crash that could occur when executing queries on older cluster versions with the adaptive aggregation feature enabled.

    • Fixes an issue where existing Binlog dump connections could get stuck and affect Binlog cleanup after a read-only node was switched to a primary node.

    • Fixed an issue that prevented the automatic scale-out mechanism from being triggered when an NCI insertion into the lru cache for In-Memory Column Index (IMCI) failed.

    • Fixes a data inconsistency issue that could occur on a read-only node when reading large JSON fields or frequently partially updated JSON fields in specific scenarios.

    • Fixed an issue in Elastic Parallel Query that could cause a process to crash when multiple subqueries referenced the same field from an outer query but used different pushdown policies.

    • Fixes an issue where some queries failed with an OOMError due to inaccurate memory usage calculation.

    • Fixes a processing exception that could occur when adding a columnstore index to a table that has no primary key but contains a unique key.

    • Fixes an out-of-memory (OOM) issue on read/write nodes caused by the default batch write mechanism when performing an Online DDL on a table with a columnstore index.

    8.0.1.1.51.2 (2025-11-05)

    Performance optimizations

    Description

    Optimizes the efficiency of switching binary log files in scenarios where many binary log files are retained. This reduces the switching time and prevents transaction commits from being blocked.

    Bug fixes

    Description

    • Fixed an issue that occurred when the Thread Pool feature was dynamically shut down (by setting the loose_thread_pool_enabled parameter to OFF), which could cause connections to become stuck after a DDL execution was complete.

    • Fixed an issue where the columnstore index read-only node consumed excessive memory after large transactions were executed.

    8.0.1.1.51.1 (2025-10-16)

    New features

    Description

    Adds a dynamic switch to control the cursor position adjustment feature on read-only (RO) nodes.

    Bug fixes

    Description

    • Fixed an issue where queries unexpectedly fell back to row store execution when using Hybrid Plan acceleration for wide table queries with In-Memory Column Index (IMCI), because a query optimization converted the AVG function to SUM/COUNT.

    • Fixes an issue of excessive time consumption when creating a partitioned table on the primary node (RW) with the Parallel Parse feature enabled.

    8.0.1.1.51 (2025-09-29)

    New features

    Description

    • Adds support for full materialized views. This feature provides faster query responses for reporting and analysis scenarios on static or quasi-static aggregated data under large data volumes by pre-calculating and storing complex query results.

    • Adds support for the Orca (compatible with the Redis protocol) feature, which is compatible with Redis 7.0 and earlier protocols. Orca is a built-in in-memory database service in PolarDB that lets you access the database using the Redis protocol. This feature is suitable for scenarios that require high-performance key-value caching to accelerate application access. The database __orca_in_polardb_m_ that is created by default for this feature does not consume storage space when not in use.

    • Added support for AUTH password authentication for Orca (compatible with the Redis protocol) based on the default account. When the default account is configured, clients can use the standard Redis AUTH command for identity verification, which enhances the access security of the Orca service.

    • Added support in the adaptive execution plan switching feature for Index Condition Pushdown (ICP) scenarios.

    • Adds the rds_max_tmp_disk_space parameter to limit the total disk space that can be occupied by temporary tables created by all sessions in a single cluster.

    • Added a fast recovery feature for the row-column mapping module of the In-Memory Column Index (IMCI). This feature significantly reduces the time that a column index spends in the LOADING_NCI state after a column store node is restarted, enabling restoration of the column index within seconds.

    Performance optimizations

    Description

    • Optimizes the BLOB page allocation strategy. When Serialized Dictionary Information (SDI) is enabled, BLOB page pre-allocation is disabled to avoid unnecessary storage space waste caused by frequent SDI updates, which improves space utilization efficiency.

    • Optimized the metadata loading mechanism for IMCI nodes. This resolved the potential out-of-memory (OOM) issue caused by an excessively long metadata list during node restarts in massive data scenarios.

    • Standardized the naming convention for local files related to columnstore index (IMCI) across all node roles, which simplifies file management during high-availability (HA) switchovers.

    Bug fixes

    Description

    • Fixes an error that occurred when a newly created read-only (RO) node executed a DDL statement after a high-availability switchover. The error was caused by a failure to modify Serialized Dictionary Information (SDI). This ensures the stability of cluster DDL operations after a high-availability switchover.

    • Fixed an issue where the primary and secondary nodes of a Multi-master Cluster (Limitless) Edition might cause the cluster to crash during a high availability (HA) switch.

    • Fixed an issue that could cause wild pointer access when an index is released while executing INSTANT DDL on an IMCI.

    • Fixes a potential crash during a high-availability (HA) switchover under high write pressure after scaling out without initialization.

    • Fixes an occasional failure of point-in-time restore tasks when the Parallel Parse feature is enabled.

    • Fixed an issue where adding a columnstore index (IMCI) to a table that has no primary key but has a unique key could cause an error.

    • Fixed an issue where a Multi-master Cluster (Limitless) Edition cluster might fail to start or data persistence might fail after a high availability (HA) switchover.

    • Fixed an issue in Multi-master Cluster (Limitless) Edition where gaps occurred in gtid_executed after a CREATE ... IF NOT EXISTS statement was executed on an aggregation node.

    • Fixed an issue in Multi-master Cluster (Limitless) Edition where, after a local read-only (RO) node was hot-switched to a read-write (RW) node, performing DML operations on a table with an In-Memory Column Index (IMCI) could cause the RW node to crash.

    • Fixed an issue where the Delta module of IMCI could access a null pointer during serialization due to incomplete logic for identifying rolled-back rows, which could cause a cluster crash.

    • Fixed an issue where data cleanup (TTL) information was lost during a CREATE PARTITION TABLE operation because the primary Data Dictionary (DD) information was not updated.

    • Fixed an issue where an IMCI query that contains both the DISTINCT and AVG aggregate functions might return an incorrect result.

    • Fixed an issue where the query performance of Multi-master Cluster (Limitless) Edition might degrade under heavy load.

    • Fixes an issue where some queries could not be pushed down to the columnstore index for execution when the imci_implicit_orderby_rollup parameter was enabled.

    • Fixed an issue where IMCI read-only nodes might experience replication delay in scenarios with high-frequency DDL operations.

    8.0.1.1.50.2 (2025-08-26)

    Bug fixes

    Description

    • Fixes a rare issue where a background purge process could cause secondary index corruption during a transaction rollback.

    • Fixes an issue where a read-only node could temporarily fail to query some records during a B-tree index structure adjustment triggered by a high write load.

    8.0.1.1.50.1 (2025-08-12)

    Bug fixes

    Description

    • Fixed an issue in the In-Memory Column Index (IMCI) feature where a node could crash when the deltastore executes a swap task, because the length of a pax page overflowed uint32 or a null pointer was encountered.

    • Fixed an issue where one-write, multiple-read follower file operations for IMCI were unexpectedly prohibited due to an improper initialization order of global variables.

    8.0.1.1.50 (2025-07-17)

    New features

    Description

    • Extends the functionality of window functions to support the FRAME clause. This lets you define the calculation range more precisely in both ROWS and RANGE modes, which enhances the flexibility of complex analytical queries.

    • Added a new query-level Pruner statistical metric for In-Memory Column Index (IMCI). You can query the INFORMATION_SCHEMA.IMCI_SQL_PROFILING view to understand the data block pruning efficiency of the TableScan operator during execution to more accurately analyze and optimize query performance.

    • You can now use Online DDL to modify the auto-increment column values of the high-compression engine (X-Engine). This update lets you make the modification without blocking DML operations, ensuring business continuity.

    • The query pushdown capability for In-Memory Column Index (IMCI) has been enhanced. It now supports complex SQL queries that contain ROLLUP and subqueries with aggregate functions in the projection columns. This allows more types of analytical and reporting queries to benefit from the performance improvements of IMCI.

    • IMCI now supports the JSON_ARRAYAGG expression. This function aggregates multiple rows from query results into a single JSON array, enhancing the capabilities for processing JSON data.

    Performance optimizations

    Description

    • The scheduling mechanism of the background elastic thread pool for IMCI is optimized, significantly reducing its CPU usage when retrieving task status, thereby reducing system overhead and freeing up more compute resources for core services.

    • Improves the efficiency of Page Apply during physical replication. By avoiding physical replication delays caused by secondary nodes reading cold data, this reduces the possibility of occasional jitter and enhances data synchronization stability.

    • Optimizes the offline logic for column store nodes. By making the cleanup of junk files asynchronous and optimizing flow control, the node offline process is smoother, which reduces the impact on running services.

    • Merging window functions that have the same PARTITION BY definition improves the execution efficiency of In-Memory Column Index (IMCI) when processing complex analytical queries.

    • Enhanced the performance of the HashJoin operator in In-Memory Column Index (IMCI). Optimizing the creation process and specific implementation of its internal Hash table accelerates the processing of join queries.

    • In In-Memory Column Index (IMCI), the Hybrid Plan now supports executing queries on tables without an explicitly defined primary key. This expands the applicability of hybrid row-column storage, allowing you to leverage its performance advantages even if the table schema does not contain a primary key.

    • Adds the adaptive_digest_length_multiplier parameter. This parameter can be used to adjust the memory size pre-allocated for the SQL digest by setting an appropriate SQL text length coefficient to optimize memory usage efficiency.

    • Reduces the lock granularity in the snapshot retention feature of read-only columnstore index nodes. This effectively avoids occasional stuttering of monitoring information caused by long lock waits and improves system observability.

    Bug fixes

    Description

    • Fixed an issue where some qualifying queries were not correctly dispatched to IMCI for execution when the imci_implicit_orderby_rollup parameter was enabled, ensuring the stability of the query acceleration feature.

    • Fixed an issue where the table_name cache in the INFORMATION_SCHEMA view for the In-Memory Column Index (IMCI) was not updated in a timely manner after a RENAME operation was performed on a partitioned table, ensuring metadata consistency.

    • Fixes an issue where update tasks based on old version columnstore index information could trigger an assertion failure after an INSTANT DDL commit. This improves the stability of the INSTANT DDL feature.

    • Fixes an issue where string types might incorrectly use the collation information of character_set_client when using the PREPARE EXECUTE mode. This ensures the correctness of character set handling.

    • Fixes an issue in Sharding Outline where a defect in the token calculation logic prevented correct support for table aliases and ORDER BY/LIMIT BY clauses.

    • Fixed an issue where some statements in PREPARE STATEMENT mode could not be correctly routed to IMCI for execution, ensuring that prepared statements can also benefit from performance acceleration.

    • Fixed an issue where the In-Memory Column Index (IMCI) Delta module accessed a null pointer and caused a cluster crash because the module failed to check for rolled-back rows when serializing data.

    • Fixed an issue where an Index Join in a Hybrid Plan for In-Memory Column Index (IMCI) occasionally caused an Assertion failed: false error when you query partitioned tables.

    • Fixes an issue where an invalid json error could be returned in some scenarios when reading JSON data on a read-only (RO) node. This ensures data format consistency between read/write and read-only nodes.

    • Fixed an issue where IMCI and the row store could return inconsistent query results when the first parameter of the json_valid function is of the varchar type.

    • Fixed an issue where updating a NULL value to an empty string could cause a cluster crash in a table that uses the REDUNDANT row format and contains second-level DDL.

    • Fixed an issue that caused occasional inaccurate timing when you analyze In-Memory Column Index (IMCI) queries using the Analyze In-Memory Column Index query performance (imci_analyze_query) function, which improves the reliability of the performance analysis tool.

    • Fixed an issue where after you use the Database and Table Restoration feature to restore a partitioned table that contains Second-level DDL and has 10 or more partitions, an error might occur when you access the table.

    • Fixed an issue where adaptive distribution incorrectly routed queries with unsupported user-defined functions to IMCI, causing execution errors.

    • Fixed an issue where IMCI might return an out-of-memory (OOM) error when processing GROUP BY operations on variable-length strings with extremely large data volumes.

    • Fixes a potential cluster crash during a Batched Nested Loop (BNL) execution when a CTE was executed together with SEMI JOIN DuplicateWeedout.

    • Fixed a memory leak in the internal thread pool of the In-Memory Column Index (IMCI) during elastic scale-in, which prevents memory leaks when the PCUs of a Serverless cluster are adjusted.

    • Fixes a deadlock issue caused by adding unnecessary unique key (UK) index transaction locks. This improves system stability in high-concurrency scenarios.

    • Fixed an issue where the concurrent execution of DROP INDEX while an IMCI was executing LOADING_NCI could cause the loading task to hang.

    • Fixed an issue where queries would occasionally fail to use the Hybrid Plan when global consistency (high-performance mode) was enabled, ensuring that the correct query plan is selected in high-performance mode.

    8.0.1.1.49.2 (2025-06-11)

    Bug fixes

    Description

    • Fixes an issue where point-in-time restore operations might not be idempotent in parallel parsing mode.

    • Fixed an issue where In-Memory Column Index (IMCI) could cause data inaccuracies during Online DDL operations in versions 8.0.1 and later.

    • Fixed an issue where the IMCI Hybrid Plan's Index Join could cause a crash when executing an Anti Semi Join pattern with a Post Filter.

    • Fixes an issue where the Window Function feature could cause an abnormal result set when internal temporary table data was written to disk.

    • Fixed an issue where a crash could occur during Data Cleanup (TTL) if a deadlock caused a transaction rollback.

    • Fixed an issue where the Data Cleanup (TTL) thread could cause a crash if it failed to release a transaction (trx) object during shutdown.

    • Fixed an out-of-memory (OOM) issue that could be triggered when an In-Memory Column Index (IMCI) performs a sort compaction.

    8.0.1.1.49.1 (2025-05-21)

    Bug fixes

    Description

    Fixed a memory leak in the internal thread pool of the In-Memory Column Index (IMCI) during the elastic scale-in process. This fix effectively prevents memory leaks in serverless clusters when PCUs (PolarDB Capacity Units) are dynamically adjusted.

    8.0.1.1.49 (2025-04-25)

    New features

    Description

    • The TTL feature now supports setting an expiration time. Data automatically expires after the specified time.

    • Added the EXPLAIN DDL feature, which lets you query the execution features of specific DDL statements.

    • The read-only nodes (RO) of the Serverless feature now include a feature for reclaiming unused memory from the `parse buf` (memory block for parsing logs), which reduces memory usage.

    • Added support for redo log asynchronous I/O and redo log partition I/O (Partition IO) in Multi-master Cluster (Limitless) Edition.

    • Added a setting to control the cost threshold for the adaptive execution of automatic request distribution between row and column store nodes.

    • In In-Memory Column Index (IMCI), the Hybrid Plan's Index Join now supports Semi Join and Anti Semi Join modes.

    Performance optimizations

    Description

    • Improved the performance of IMCI queries that use IN lists.

    • Optimized the Hash Groupby implementation mechanism in IMCI to automatically select partitioning policies and algorithms based on data distribution characteristics to improve query performance.

    • Optimized the query optimizer's logic for handling subqueries to significantly improve the performance of IMCI for complex IN and EXISTS subqueries.

    • Optimizes an issue where database performance degraded when using the max_execution_time parameter under high concurrency.

    Bug fixes

    Description

    • Fixed an issue where memory blocks occasionally accumulated in ImciFollower in a multi-node shared architecture of In-Memory Column Index (IMCI).

    • Fixes an issue where WITH ROLLUP might not correctly output NULL values when the column in the GROUP BY clause contained an expression.

    • Fixes a rare issue where a column store node accessed cached data from before a DDL operation.

    • Fixed a compatibility issue with the Fast import feature when used with partitioned tables and Instant Columns.

    • Fixed an issue where IMCI could not use the imci_implicit_orderby_rollup parameter to control the sorting of query results when processing queries with `ROLLUP`.

    • Fixes an issue where accessing a spatial index on a read-only node could retrieve duplicate data.

    • Fixed a scale-in issue for In-Memory Column Index (IMCI) on Serverless clusters with large primary node specifications.

    • Fixed an issue where In-Memory Column Index (IMCI) did not support the LIMIT 1 clause in SQL subqueries.

    • Fixed an issue where the In-Memory Column Index (IMCI) mixed materialization Mixoutput did not perform timezone conversion when reading timestamp data.

    • Fixes a rare ROW LOG read/write out-of-bounds issue when performing ONLINE DDL on a table with a virtual list.

    • Fixes a potential error in parallel query results when a subquery contained a Having keyword.

    • Fixes an issue where the Redo Cache feature could read dirty data when reading edge Redo logs. This issue would cause the Redo log validity check to fail, leading to a cluster crash.

    • Fixes a potential cluster crash under high concurrency when the parallel query (PQ) and performance_schema features were used.

    • Fixes a potential crash on a secondary node of a Multi-master Cluster when switching the database or object endpoint before the node.

    • Fixes a potential index corruption issue on a secondary index created on a Virtual Column.

    • Fixed a compatibility issue between the database and table recovery feature and the file space parameter name extension feature.

    • Fixes a startup failure of a new read/write node in a Multi-master Cluster when a global read-only node was present.

    • Fixes an issue where an IMPORT TABLESPACE operation could not be performed due to an unexpected crash during an optimized BLOB write.

    • Fixed an issue where the database and table recovery job flow could be interrupted if an extension parameter name contained a space.

    • Fixes a potential task interruption when the source table for database and table restoration had a columnstore index.

    • Fixes an error where a read-only node reported that a file did not exist when executing Show Binlog Events.

    • Fixes a rare issue where a statement could not exit normally when killing the corresponding connection for a DDL in a non-blocking DDL cluster.

    • Fixed a compatibility issue for In-Memory Column Index (IMCI) that occurred when executing SELECT DISTINCT queries in non-full-groupby scenarios.

    • Fixed a series of issues with the memory elasticity of In-Memory Column Index (IMCI) to improve memory utilization efficiency and cluster stability.

    • Fixes a potential cluster crash when a materialized table with sorting was merged into an outer query in a parallel query scenario.

    • Fixed an issue that caused read-only (RO) nodes in a Serverless cluster to be scaled in to 0.25 PCU during specification synchronization with read/write (RW) nodes.

    • Fixes a cluster crash when creating a temporary table with a CREATE TABLE AS SELECT statement.

    8.0.1.1.48.1 (2025-03-20)

    Bug fixes

    Description

    Fixes an issue where read requests on a read-only (RO) node would slow down in scenarios with a low Redo load when the multi-version engine feature was enabled.

    8.0.1.1.48 (2025-02-21)

    New features

    Description

    • The Delete statement now supports Index Hints, allowing the use of specific indexes through USE INDEX, FORCE INDEX, or IGNORE INDEX syntax.

    • Adds support for sending RedoLog logs to column store nodes over the network, reducing the IOPS consumption of column store nodes.

    • Adds encryption functions SM4_encrypt()/SM4_decrypt() to implement field-level access encryption with the SM4 algorithm.

    • Adds a feature to parse Redo in parallel for physical replication, improving physical replication performance.

    • The Explain result now displays the called Outline ID. Multiple Outline IDs called by the same statement are separated by commas.

    • X-Engine adds support for the large wide table feature, supporting a maximum of 10,000 columns per table.

    • Added the Resource Management User Guide feature, which implements CPU resource isolation at the User and Database levels.

    • Multi-master Cluster (Limitless) Edition now supports the local read-only node feature, which provides read workload distribution and high availability switchover.

    Performance optimizations

    Description

    • Optimizes the global mutex lock for SHOW VARIABLES, improving performance under high concurrency.

    • Optimized the High-compression Engine (X-Engine) by automatically enabling the pre-commit feature in DDL scenarios.

    Bug fixes

    Description

    • Fixed an issue that prevented read-only (RO) nodes in a Serverless cluster from scaling down to the 0.25 PCU lower limit during specification synchronization with read/write (RW) nodes.

    • Fixed an issue where shutting down the Hybrid Plan at runtime in In-Memory Column Index (IMCI) could cause a crash.

    • Fixes a rare issue of columnstore index data redundancy that could occur if a cluster restarted during a large transaction on a column store node and a crash recovery was performed.

    • Fixes a potential exception that could be triggered when all data in a stored data block was identical.

    • Enables Session-level binlog_rows_query_log_events permission to support SQL backup and rollback using DMS.

    • Fixes an issue where the Online DDL process for columnstore indexes in a Multi-master Cluster scene did not adapt to the Logical Log Sequence Number (LLSN) logic, resulting in missed replay of columnstore Redo logs.

    • Fixed an issue where old tablespaces leaked during reclamation after a DDL change in X-Engine.

    • Fixes an index selection error in IMCI for constant range filtering (const between field1 and field2) scenarios.

    • Fixed a crash in IMCI that occurred during a query on a partitioned table when an Explain for Connection statement for the query was executed in another session.

    • Removes an unnecessary restriction in algorithm selection. Now, some correlated subqueries can choose the efficient HASH JOIN algorithm for query execution.

    • Fixes an issue where IMCI I_S (IMCI-related views in the Information_Schema database) query results with a name filter were incomplete due to the use of a case-insensitive string comparison function.

    • Fixes an issue where an MDL lock could not be obtained during the DDL SCAN phase, only displaying an error message without being able to recover the columnstore index data.

    • Fixes an issue where the gtid_purged variable on a read-only node was not synchronized with the primary node.

    • Fixes an issue where deleting a database in a Multi-master Cluster could cause the entire cluster to hang.

    • Fixed an issue where the variables for global consistency (high-performance mode) were changed to the Connection level, adding support for enabling or disabling the feature through a proxy endpoint.

    • Fixes an issue where executing TRUNCATE and RENAME table commands in a Multi-master Cluster could cause the entire cluster to hang.

    • Fixes an issue where the XEngine engine unexpectedly cleared metadata of data blocks when a read-only node was restarted.

    • Fixes a potential anomaly in the MDL lock system when the number of connections exceeds 65536.

    • Fixes a situation where a Multi-master Cluster could cause a read/write node to become unserviceable when the number of tables in the database was large.

    • Fixes an issue where setting a flagset type variable, such as (optimizer_switch), no longer reports an error if there are duplicate items.

    • Fixes an issue where earlier community versions failed to correctly optimize the join order in multi-table update statements.

    • Fixed an issue in IMCI where the state was set incorrectly when multiple runtime filters were pushed down to the same table.

    • Fixes a potential crash when processing the empty string output of GROUP_CONCAT with the SUBSTRING_INDEX expression, and the separator length is greater than 1.

    8.0.1.1.47.1 (2025-01-07)

    Bug fixes

    Description

    Fixed an issue where reading JSON or GIS large objects using the In-Memory Column Index (IMCI) could occasionally fail.

    2024

    8.0.1.1.47 (2024-12-19)

    New features

    Description

    • Adds support for table sharding scenarios in Outline. A single Outline can match all statements with the same template, applicable to different sharded tables.

    • Adds the ability to dynamically adjust the selection result of Order Index based on actual conditions during execution.

    • Adds a feature to parse Redo in parallel for physical replication, improving physical replication performance.

    • Adds the variable ignore_use_force_index. When enabled, it ignores all use or force index in statements and Outlines (but does not affect Index() in Hints).

    • Adds string conversion functions convert_sys_to_filename() and convert_filename_to_sys() for conversion between system_charset_info encoding and my_charset_filename encoding.

    • Added support for setting transparent data encryption (TDE) for cold data in OSS.

    • Added support for asymmetric MTT buffering for RW and RO instances, allowing you to enable MTT optimization for both in a coordinated manner.

    • The IMCI i_s.imci_index_stats table adds a PRUNED_PERCENT field, which indicates the Data Skipping ratio for each columnstore index.

    • Adds a feature to the SHOW ProcessList result to display whether a session is waiting for thread pool scheduling.

    • Supports direct rebuilding of a columnstore index by modifying the pack_shift in the COMMENT without prior deletion.

    Performance optimizations

    Description

    • Optimizes the dynamic Buffer Pool scale-in process to reduce lock conflicts.

    • Optimized SQL Trace to correctly record SQL and execution plans when Call procedure is used.

    • Optimizes the memory overhead of columnstore wide tables.

    • Optimizes the startup speed of read-only columnstore nodes, supporting independent startup of the columnstore engine from the columnstore snapshot offset.

    • Optimizes the thread startup and destruction code for logical pre-reading, simplifying the memory check logic.

    • Optimized the long startup time of column store nodes in scenarios with massive tables.

    • Optimizes the performance and memory usage of large transactions in IMCI.

    • Optimizes the performance of materializing HASH KEY expressions in IMCI.

    • The Serverless flow for column store nodes is optimized so that new column store nodes are added to the Proxy node to handle service traffic only after their indexes are ready.

    • Optimizes the statistics sampling mechanism of IMCI, increasing the sampling frequency and the proportion of sampled data.

      Optimizes the sampling logic for low-cardinality columns to avoid situations where inaccurate statistics lead to queries not being fully optimized.

    • Optimizes the Simulated-AIO asynchronous performance blocking module.

    Bug fixes

    Description

    • Fixes an issue where DDL could report an error or not take effect on a table with a view after an HA (node switchover).

    • Fixes an issue where an RO node might continuously fail to provide service after reconnecting to the RW node.

    • Fixes a process crash caused by the CAST(REGEXP_SUBSTR(...)) AS DECIMAL statement.

    • Fixes an issue where REGEXP_SUBSTR might return an incorrect NULL flag.

    • Fixes an issue where the table creation statement for the dlm_policies system table was recorded in the BINLOG, causing downstream synchronization to fail.

    • Fixes an issue where unique indexes were not fully utilized for acceleration in some queries.

    • Fixes an issue of residual metadata when deleting multiple full-text indexes (FTS) simultaneously using the ALTER TABLE DROP statement.

    • Fixes an issue of unnecessary index rebuilding when extending the length of a VARCHAR column with a specified DEFAULT value.

    • Fixed issues for IMCI Serverless, including compatibility issues with internal memory elasticity and scaling abnormalities.

    • Fixes an issue where full-text index searches on read-only nodes would get stuck after a DDL operation.

    • Fixed an issue in Adaptive Execution where specific types of queries could not be routed correctly.

    • Fixed an issue where rebuilding an In-Memory Column Index (IMCI) online was not supported, which caused availability issues.

    • Fixed an issue where a multi-write cluster crashed when you add columnstore indexes in batches due to improper handling of the DDL global lock.

    • Fixes a query crash in JSON_TABLE scenarios with NULL Fields.

    • Fixes a conflict between Multi-master Buffer Pool Resize and transaction access to blocks, and optimizes the performance of Multi-master Buffer Pool RDMA register or unregister.

    • Fixes an issue where Digest CCL did not support the PS (Prepared Statements) protocol.

    • Fixes a potential crash on RO nodes during the HA (node switchover) phase after the RO No Sync feature is enabled.

    • Fixes an issue where transaction rollbacks required a pessimistic lock to delete an index when using a Spatial Index, leading to an infinite loop and prolonged lock holding.

    • Fixes a rare task interruption that could occur during an upgrade from a historical version to 8.0.1.1.45.1.

    • Fixes a rare issue where a query error was reported due to accessing invalid data when accessing string data types during columnstore execution.

    • Fixes an issue where IMCI would fall back to row store when processing an expression containing multiple subqueries with SUM.

    • Fixed a circular wait issue that occurred during asynchronous column index rebuilding in IMCI single-write, multiple-read scenarios when the Use Hybrid Plan to accelerate wide table queries feature was enabled.

    • Fixes an issue where modifying the innodb_bulk_load_page_grained_redo_enable parameter within a certain time window during parallel DDL execution caused incorrect Redo writes for some pages.

    • Fixes a potential deadlock in BLINK for batch data deletion scenarios on tables with LOB fields.

    • Fixed an issue where concurrent high-frequency INSTANT DDL operations and background Compaction tasks caused the migrate process to crash.

    • Fixes an issue where GROUP BY could cause a temporary table to report a table is full error.

    • Fixes an issue where an index join in IMCI could lead to unstable results when using a constant as a join condition.

    8.0.1.1.46.2 (2024-11-19)

    Bug fixes

    Description

    • Fixes an issue where the table Autoinc value would roll back after an RO node was switched to an RW node and an INSERT ... ON DUPLICATE KEY UPDATE statement was executed.

    • Fixed compatibility issues with internal memory elasticity and scaling exceptions in IMCI Serverless.

    • Fixes a bug that caused a crash when the number of tables in a query transformation exceeded 61. In such scenarios, query rewrite is not performed.

    8.0.1.1.46.1 (2024-11-06)

    Bug fixes

    Description

    • Fixes an issue where full-text index searches on read-only nodes would get stuck after a DDL.

    • Fixes an incompatibility between the backward index scan capability and optimizations like ICP. A new polar_optimizer_switch is added for control.

    8.0.1.1.46 (2024-10-28)

    New features

    Description

    Adds the variable ignore_use_force_index. When enabled, it ignores all use/force index in statements and Outlines (but does not affect index() in hints).

    Performance optimizations

    Description

    • In IMCI, the INFORMATION_SCHEMA.IMCI_INDEX_STATS table now includes a PRUNED_PERCENT field that indicates the data skipping ratio for each column index.

    • Optimizes SQL trace so that when the type is set to SLOW LOG, SQL trace will also apply to statements specified by DEMAND.

    • Optimizes RW and RO to support asymmetric MTT buffers. Supports linked enabling of MTT between RO and RW.

    • Optimizes the Serverless process for column store nodes.

      Allows new column store nodes to serve traffic only after their indexes are ready, reducing slow queries caused by SQL statements being routed to the new nodes and executing with row store plans during this period.

    • Reduced the performance overhead of saving partition information for IMCI during SQL execution to improve the query performance of partitioned tables.

    Bug fixes

    Description

    • Fixes a cluster crash during Undo initialization when Force recovery is enabled.

    • Fixed an issue where the asynchronous rebuilding of column indexes led to a deadlock in IMCI one-write, multiple-read scenarios when Hybrid Plan was enabled.

    • Fixes an error when re-importing the same data into a partitioned table with the UNIQUE CHECK IGNORE attribute using LOAD DATA with REPLACE.

    • Fixes an issue where dirty data could be introduced into recent_written when the CRC calculation value of incoming data was exactly 0 in a three-zone deployment.

    • Fixes an issue where RO nodes could get stuck during the HA (node switchover) phase, preventing excessively long user HA times.

    • Fixes B-tree corruption caused by adding an auto-increment column and creating a descending primary key index on that column.

    • Fixes an issue where IMCI would fall back to row store when processing an expression containing multiple subqueries with SUM.

    • Fixes a rare memory residue issue when an error is encountered during parallel primary key rebuilding.

    • Fixes a potential crash when processing LOB fields in a GROUP BY query using the Temptable engine.

    • Fixes a potential error in parallel query results when the predicate condition contained a subquery.

    • Fixes a potential query crash in JSON_TABLE scenarios with NULL Fields.

    • Fixes an NCI encoding anomaly during DDL operations of type EQUAL_PACK_LENGTH when modifying a PRIMARY KEY field.

    • Fixed an issue where a conflict between Proxy advanced transaction splitting and Fast Query Cache affected the result set.

    • Fixes an issue where results could be incorrect when using a JSON_ARRAY expression in a subquery with IMCI enabled.

    • Fixed an issue that caused the new flow for database and table recovery to be interrupted when the same table was recovered multiple times.

    • Fixed a memory leak issue that occurred during the dynamic enabling of the RDMA log transfer feature.

    • Fixed an issue where In-Memory Column Index (IMCI) did not support online rebuilding, which caused the IMCI to become unavailable.

    • Fixed an issue where asynchronous DDL could not be used when adding an In-Memory Column Index (IMCI) by modifying the COMMENT of a table that has a full-text index.

    • Fixes an issue where transactions might not be killed in multi-concurrency scenarios.

    8.0.1.1.45.2 (2024-09-13)

    Bug fixes

    Description

    • Fixes a rare task interruption that could occur during an upgrade from a historical version to 8.0.1.1.45.1.

    • Fixes a rare issue where a query error was reported due to accessing invalid data when accessing string type data during columnstore query execution.

    8.0.1.1.45.1 (2024-09-09)

    Performance optimizations

    Description

    Optimizes the memory overhead of IMCI columnstore wide tables.

    8.0.1.1.45 (2024-09-03)

    New features

    Description

    • Adds a display to show if a session is waiting for thread pool scheduling.

    • Adds a greedy algorithm-based join reorder strategy in IMCI.

    • Added stored procedures and extended SQL commands to add columnstore indexes to an entire database in batches.

    • Added support for major engine version upgrades from PolarDB 5.7 backup sets to improve the efficiency of one-click migration.

    • The Hybrid Plan for columnstore index now supports partitioned tables, virtual columns, and columns of the ENUM, SET, and GIS types.

    Performance optimizations

    Description

    • Optimizes the feature to allow dynamic adjustment of PolarDB IO Threads without a restart.

    • Optimizes the automatic elasticity of IMCI single-machine replay, reducing replay latency and out-of-memory (OOM) issues caused by high replay pressure.

    • Optimizes the read performance of Date type fields in IMCI.

    • Optimizes the IMCI statistics sampling mechanism, increasing the sampling frequency and the proportion of sampled data.

      Optimizes the sampling logic for low-cardinality columns to avoid situations where inaccurate statistics lead to queries not being fully optimized.

    Bug fixes

    Description

    • Fixes a node crash issue with InnoDB full-text indexes in a Multi-master Cluster.

    • Fixes a significant deviation in the selectivity estimation by the optimizer when a JOIN condition in IMCI includes a type conversion.

      Fixes an issue where the Hybrid Plan could not be correctly selected in IMCI due to an overestimation of the output cardinality of a JOIN.

    • Fixes an issue where JSON_LENGTH returned incorrect results when a wildcard character was present.

    • Fixes an issue where modifying the innodb_bulk_load_page_grained_redo_enable parameter within a certain time window during parallel DDL execution caused incorrect Redo writes for some pages.

    • Fixes an issue where the Autoinc value of a partitioned table would roll back after a read-only node was switched to a read/write node.

    • Fixes an issue where removing an RO node could block monitoring connections for a period when innodb_polar_log_rdma_transfer was enabled.

    • Fixes an issue where the index join of IMCI could trigger unstable results when using a constant as a JOIN condition.

    • Fixes an issue where a temporary table using a group by statement could cause temptable to report a table is full error even when the disk was not full.

    • Fixes an issue where user threads on an RO node waited too long for a Free Page when the Buffer Pool was very full.

    • Fixes a potential deadlock in blink for batch data deletion scenarios on tables with lob fields.

    • Fixes an issue where JOIN elimination optimization in IMCI could lead to unstable results.

    • Fixes an issue where the Autoinc value would restart from 1 on the next write operation after all data in a table was deleted.

    • Fixes a failure to drop database when the database contained tens of thousands of tables.

    • Fixes an issue where useless subqueries were not deleted during view merging.

    • Fixes an issue where a query might report insufficient memory when executed in IMCI if it had too many UNION ALL clauses.

    • Fixes an issue where a desc select statement could not correctly call an outline.

    • Fixes an issue where table_comments in information_schema.tables displayed xxx is not base table.

    • Fixes an issue where implicit conversion of date types in IMCI was incompatible with MySQL behavior, leading to unexpected results.

    • Fixes a query result inconsistency issue in IMCI. This occurred when a new partition was added to a partitioned table created in an older version, causing the default pruner type to be inconsistent.

    • Fixes a floating-point precision issue in JSON.

    8.0.1.1.44 (2024-07-06)

    New features

    Description

    • Supports deriving corresponding views from join conditions.

    • Adds a late materialization version of UnionAll for IMCI.

    Performance optimizations

    Description

    • Optimizes the time taken for query optimization on simple queries (single-table queries).

    • Multi-master clusters support fine-grained table-level locks.

    • Optimizes the performance of decimal sum/avg in IMCI.

    • Optimizes performance in hotspot update scenarios.

    • Optimizes the performance of hash match in IMCI.

    • Optimizes the memory for metadata used in IMCI queries.

    • IMCI supports pushing filters down to outer joins.

    • Adjusts the PolarFS transaction processing thread priority to improve PolarDB DDL performance.

    Bug fixes

    Description

    • Fixes an import table failure caused by a blink dangling page.

    • Fixes a DB hang issue during an active checkpoint trigger in various processes.

    • Fixes an issue where frequent dynamic switching of RO No Sync could cause a loss of markers.

    • Fixes an issue where a global Standby node in a Multi-master Cluster could not start due to an abnormal rollback segment.

    • Fixes an issue where an InnoDB table with a function index could not be archived.

    • Fixes an issue where Last_query_cost could become negative in a few optimization scenarios.

    • Fixes an issue where join elimination could not be performed when a function contained an aggregate function.

    • Fixes an issue where the IP address in the audit log was not updated in a timely manner when a connection was reused under a session-level connection pool.

    • Fixes issues related to locking and unlocking global table locks in a Multi-master Cluster.

    8.0.1.1.43 (2024-06-03)

    New features

    Description

    • Adds Binlog support for transaction resumable upload.

    • Adds the parameter thread_pool_reset_waiting_state_before_queuing.

    Performance optimizations

    Description

    • IMCI adds Index Join based on Hybrid Plan, which supports using InnoDB indexes for Join operations.

    • Optimizes the Page read performance of read-only nodes on PFS.

    • Optimizes the memory for metadata used in IMCI queries.

    Bug fixes

    Description

    • Fixes an issue where setting optimizer_switch and parallel_query_switch values would report an Error instead of a Warning for certain incorrect values.

    • Fixes an issue where the optimizer_switch value would not take effect if a comma was added at the end.

    • Fixes an index selection change issue after adding a limit operation to an implicit aggregate query.

    • Fixes an issue where the undo log grew continuously after a follower was rebuilt under 3AZ.

    • Fixes an issue where Persist RO could cause the RO to read old data.

    • Fixes an issue of high replication delay on read-only nodes in a Multi-master Cluster.

    • Fixes an issue where the optimizer could not select the optimal Join Order due to an error in cardinality estimation.

    • Fixes a deadlock issue between threads that could occur during a Btree structure adjustment caused by deleting records.

    • Fixes a failure in archiving an archived table when it had a descending index.

    • Fixes an issue where no data was returned when using Limit Offset pushdown with a composite secondary index equality condition plus a primary key In List condition to get a reverse-order paged output of the primary key.

    • Fixes an issue of excessive permissions during DLM policy execution.

    • Fixes an issue where executing a Create Table Select statement in a Multi-master Cluster affected the availability of other nodes.

    • Fixes an issue where system pages could be corrupted when executing DDL statements on multiple nodes of a Multi-master Cluster simultaneously.

    8.0.1.1.42 (2024-04-30)

    New features

    Description

    • Adds the predicate pushdown feature, including pushing predicates from HAVING to WHERE, and from HAVING to derived tables and subqueries.

    • Adds a hybrid row-column optimizer and cost-based row-column routing capability.

    • Supports viewing the invocation of Statement Outlines in the EXPLAIN result.

    • Supports using a prefix murmur hash bloom filter in IMCI.

    • Supports using the LEFT JOIN elimination feature in UPDATE statements.

    • Supports using the instant column addition feature on tables that have a columnstore index created.

    • Adds the number of returned rows information to the Fast Query Cache. Queries that hit the cache can display the number of returned rows in the audit log.

    Performance optimizations

    Description

    • Introduces an execution feedback mechanism in row-column routing to collect real execution information and feed it back to the optimizer.

    • Disables index merge intersection by default for DML statements to improve performance and prevent deadlocks.

    • Reduces the metadata overhead of memory allocation and memory statistics in IMCI to save memory.

    • IMCI supports using BatchProbe to improve the performance of JOIN operations.

    • Optimizes the memory for metadata, file modules, and small RAM resident objects in IMCI to reduce resident memory usage.

    • Optimizes the error message for importing cold data from OSS back to InnoDB.

    • Ignores the impact of access by O&M engineers on the slow_queries status metric when monitoring database performance.

    Bug fixes

    Description

    • Fixes an issue where the OSS path mapping of tables in the recycle bin was incorrect after restarting the cluster when the RECYCLE BIN feature was enabled to recycle OSS IBD tables.

    • Fixes an issue where a read-only (RO) node with excessive clock drift could preempt the permissions of a read/write (RW) node when starting the NewHA vector voting disk.

    • Fixes an issue where the built-in stored procedure dbms_oss.delete_table_file could not delete cold data in CSV format.

    • Fixes an issue where the internal counter of the Thread Pool could become incorrect if an ACL lock wait was encountered during asynchronous authentication by the Thread Pool.

    • Fixes an issue where the Blob space of the original record could not be reclaimed when performing an UPDATE operation on a column of Blob type.

    • Fixes an issue of data loss when repeatedly archiving an OSS foreign table.

    • Fixes an issue where the sorting operation was not omitted during actual execution even though the optimizer had selected an ordering index.

    • Fixes a node crash when creating an OSS foreign table because the oss_prefix parameter was not configured in the OSS Server.

    • Fixes an issue where abnormal data might be retrieved when accessing some tables in the information_schema database under a Multi-master Cluster.

    • Fixes an issue where an assert message would be returned when performing a multiplication operation on Decimal type data, if at least one multiplier was 0 and the scale of the result exceeded 16.

    • Fixes an issue where statistics could be inaccurate because only some partitions were sampled when updating statistics on a partitioned table with a columnstore index.

    • Fixes an issue where index equality access did not trigger adaptive row-column routing.

    • Fixes an issue of excessive Autoinc init log printing.

    • Fixes a potential error in OSS foreign tables in an Order By Desc scenario.

    • Fixes a rare node crash when executing the TRUNCATE PARTITION command on a partitioned table with an auto-increment column.

    • Fixes an issue of data corruption due to different index orders when performing an EXCHANGE PARTITION operation.

    • Fixes a potential node crash caused by the automatic cancellation of a preceding scale-in operation in the Buffer Pool under high concurrency.

    8.0.1.1.41 (2024-03-19)

    New features

    Description

    Adds a Left Join feature based on TopK pushdown in the columnstore index.

    Performance optimizations

    Description

    • Supports granting users global dynamic permissions to execute the SHOW_ROUTINE, FLUSH_USER_RESOURCES, FLUSH_TABLES, FLUSH_STATUS, and FLUSH_OPTIMIZER_COSTS commands.

    • Optimizes the enabling process of the high-performance global consistency mode. When the innodb_polar_scc parameter is set to ON on an RO node, the cluster automatically enables dependent features of high-performance global consistency, such as RDMA and PolarTrans, which reduces the complexity of the control process.

    • Supports using Variable-Setting Hint syntax in the high-performance global consistency mode feature.

    • Supports setting the polar_oss_ddl_shared parameter to ON to access table data that is being archived as cold data.

    • Disables the partial update feature for Blob fields.

    • Supports using the database and table restoration feature for tables with a columnstore index.

    • Supports using the most common value statistics collection feature in the columnstore index to improve the accuracy of records per key estimation in data skew scenarios.

    • Optimizes the columnstore index memory scheduling feature to improve memory utilization.

    • Optimizes the nonblocking DDL feature to support more DDL statements.

    • Supports using the columnstore index and global consistency (high-performance mode) features simultaneously.

    • Supports using the CHECK TABLE command to check a specific partition.

    Bug fixes

    Description

    • Fixes an issue where the TRUNCATE statement could be executed on any node in a Multi-master Cluster.

    • Fixes a node crash caused by accessing an invalid Blob reference when pre-reading Blob type data.

    • Fixes a potential failure when exporting a local table to the OSS engine in parallel.

    • Fixes an issue where the LSN offset of a checkpoint did not meet expectations during a checkpoint operation, causing the crash recovery logic to fail after an abnormal cluster restart.

    • Fixes an issue where a node restart was required to recover from an Autoinc rollback.

    • Fixes a potential node crash when a temporary table based on the TempTable engine was referenced multiple times in a CTE (Common Table Expression) and an index scan was used on the temporary table.

    • Fixes an out-of-bounds memory issue when the columnstore index processed very long string types.

    • Fixes a rare node crash when using the columnstore index feature with the pre-read feature enabled simultaneously.

    • Fixes an issue where the background compaction task of X-Engine affected foreground operations and slow query performance due to overly strict concurrency control.

    • Fixes an issue where the cardinality estimation result could be inaccurate when a BIGINT type column was used in a Join operation with a very large value, preventing the use of the columnstore index.

    • Fixes a deadlock issue in DDL read-ahead in parallel DDL scenarios.

    • Fixes a memory leak that occurred during a Reload operation for features like Statement Outline and Concurrency Control.

    • Fixes an issue where BIT fields were displayed incorrectly after a Group By operation.

    • Fixes an incompatibility issue between TDE and RDMA memory when forking a child process.

    • Fixes an issue where duplicate groups were present in the result set when parallel query pushed GROUP BY to a Worker for parallel execution with a partitioned table.

    • Fixes an issue of index corruption and inability to access table data due to different index orders when performing an EXCHANGE PARTITION operation.

    • Fixes issues with partitioned tables whose primary key does not include the partitioning key when using the query optimizer for searches, performing DML operations, and recording Binlog.

    8.0.1.1.40.2 (2024-02-07)

    Bug fixes

    Description

    • Fixes an issue where the replication delay of a global read-only node could become high when the load on the primary nodes of a Multi-master Cluster was unbalanced.

    • Fixes an issue where a read-only node might fail to start when it was first created on a Multi-master Cluster.

    • Fixes an issue where a primary node might fail to restart after a DDL was executed on a Multi-master Cluster.

    8.0.1.1.40 (2024-01-19)

    New features

    Description

    • Supports sampling statistics in the X-Engine to estimate the approximate compression ratio.

    • Supports enabling the columnstore index feature on the global read-only node of a Multi-master Cluster (Database/Table).

    • Allows users to ignore the transaction isolation level implicitly set by tools like Metabase when using the columnstore index feature.

    • Stats Manager supports automatically dispatching the task of collecting histograms to a read-only node or a hot replica for execution to achieve automatic histogram updates.

    • Supports using temporary tables when using the Hybrid Plan to accelerate queries on wide tables.

    • Adds a feature to enable adaptive degradation and automatic recovery for semi-sync.

    • Supports modifying the character set of a field using the INPLACE algorithm.

    • SQL Trace supports opening configuration options for a limited number of read-only nodes, which means it supports configuring the sql_trace_type parameter to REPLICA_DEMAND, REPLICA_ALL, or REPLICA_SLOW_QUERY.

    Performance optimizations

    Description

    • Improves the speed of the Thread Pool in processing connection requests in low-concurrency scenarios.

    • Improves database performance in short-lived connection scenarios.

    • Optimizes the transaction mask calculation process in IMCI.

    • When using the adaptive execution plan switching feature, if there is a high volume of cold data read I/O, the maximum execution time for switching is automatically increased.

    • Adjusts the maximum display length of query statements in SQL Trace.

    • The columnstore index feature adds a dynamic filter to improve the join efficiency between tables.

    • When setting the value of the loose_optimizer_switch parameter using a SET_VAR HINT statement, a comma is no longer required at the end.

    Bug fixes

    Description

    • Fixes an incorrect sorting result when using the IMCI feature to query TopK data with reverse sorting, if the tables involved in the query statement contained too many NULL values.

    • Fixes an issue where columnstore data could not be recovered if a read-only columnstore node was started during the execution of a DDL involving a columnstore index table.

    • Fixes a space leak issue caused by an exception during a shrink operation.

    • Fixes an issue where a read-only node became abnormal due to concurrent modification of data structures during the physical replication process of the X-Engine.

    • Fixes an upgrade failure when upgrading an X-Engine from a read replica to a standby.

    • Fixes an issue of excessive optimizer memory usage when using a columnstore index in high-concurrency query scenarios.

    • Fixes an issue where statistics could be inaccurate because only some partitions were sampled when updating statistics on a partitioned table using a columnstore index.

    • Fixes an issue where a query statement containing a subquery that returned an empty result set could not be routed to a columnstore index node for execution.

    • Fixes an issue where CCL rules matched by DIGEST value could become invalid after a cluster upgrade.

    • Fixes an issue where querying the information_schema.tables table was abnormally slow when the database contained CSV or ORC foreign tables.

    • Fixes a Flink CDC parsing failure caused by a duplicate table_id in the global Binlog of a Multi-master Cluster (Database/Table).

    • Fixes an issue where resumable transaction data could not be queried when the transaction resumable upload feature was used with the parallel query feature enabled.

    • Fixes a failure to add a new RO node due to a low registration offset of the read-only (RO) node when executing the new process for database and table restoration.

    • Fixes an issue where a thread could not exit due to a full disk when executing the new process for database and table restoration.

    • Fixes an issue of high memory consumption when using Prepare Statement to handle many concurrent requests or execute complex queries.

    • Fixes an issue where query results were incorrect when using IMCI to query a view containing BIT type data.

    • Fixes an "ERROR 1748 (HY000) Found a row not matching the given partition set" error when inserting into a KEY partitioned table. This was caused by not considering the STORED GENERATED COLUMN when pruning a KEY partitioned table.

    • Fixes an issue where new connections would still access a discarded old file due to frequent DDL and HA operations when archiving cold data as an IBD file.

    2023

    8.0.1.1.39

    Category

    Description

    Release date

    New features and performance optimizations

    • Supports accessing INFORMATION_SCHEMA view information of the column store from any node. By default, it aggregates and displays information from all column store nodes.

    • Simplifies the usage of parameters for automatic request distribution among row store and column store nodes.

    • When a query statement does not support using the column store engine, you can set the use_imci_engine parameter to FORCED and then execute the query statement. In this case, the query result will return the reason why the column store engine cannot be used.

    • Supports using correlated subqueries in the Grouping clause and eliminating complex correlated subqueries.

    • The global Binlog of a Multi-master Cluster supports GTID (global transaction identifier).

    • Optimizes the Buffer Pool scale-out feature, such as automatically canceling preceding scale-in operations and timely scaling out.

    • Optimizes the startup process of IMCI to reduce the startup preparation time for column indexes.

    • Supports adaptive routing for hybrid row-column queries.

    • Improves the read performance of RO nodes in scenarios where a secondary index returns to the primary key.

    2023-12-14

    Bug fixes

    • Fixes a node crash caused by an incorrect format of the user-defined CONNECTION when creating an OSS foreign table.

    • Introduces a patch from official MySQL 8.0.17 to fix an autoinc rollback issue caused by modifying auto_increment_increment on the client side.

    • Introduces a patch from official MySQL 8.0.16 to fix a deadlock issue caused by an oversized Blob.

    • Fixes an RO node crash caused by Runtime Apply.

    • Fixes an issue where the RW node's dirty page flushing was blocked because it did not terminate its replication relationship with a faulty RO node in special cases.

    • Fixes an Autoinc rollback issue caused by table cache eviction due to an excessive number of tables after an HA.

    • Fixes an issue where a read/write node in a Multi-master Cluster might fail to start if the cache center was restarted.

    • Fixes an issue where a table might fail to open when switching the write endpoint in a Multi-master Cluster.

    • Fixes an issue of excessive memory usage during physical replication on an RO node.

    • Fixes an issue where an outline on an AP node did not take effect when the length of the SQL token exceeded the value of the max_digest_length parameter.

    • Fixes an issue where adding or deleting an outline could not be synchronized to an RO node after the RO node was upgraded.

    • Fixes an issue of high response time for low-concurrency writes to tables in X-Engine.

    • Fixes a "table definition has changed" error when Hybrid Plan is applied to an SQL statement with Order By and the output rows contain NULL.

    8.0.1.1.38.1

    Category

    Description

    Release date

    Bug fixes

    For clusters where no Statement Outline has been added, if a Statement Outline is added after a version upgrade, outline matching is no longer affected by the character set.

    2023-11-07

    8.0.1.1.38

    Category

    Description

    Release date

    New features and performance optimizations

    • Supports using the built-in stored procedure dbms_oss.delete_table_flie to delete unused files on OSS.

    • Optimizes the database and table restoration feature. For example, it improves the restoration speed and supports task failure rollback.

    2023-10-31

    Bug fixes

    • Fixes an issue where a table with an IMCI column index could not be restored to a point in time.

    • Fixes an issue where the GroupJoin operator occupied too much memory in some scenarios, causing query failure.

    • Fixes a failure to roll back an advanced RowID when loading a checkpoint.

    • Fixes an issue where a read-only (RO) node accessing the X-Engine could not report version reference information, causing space reclamation to fail.

    • Fixes an issue where the optimizer could not accurately estimate the Join selectivity when joining an unsigned column with a signed column.

    • Fixes an issue where some queries with OR predicates could not be executed because the query plan could not be bound to the correct column.

    • Fixes an issue where a query terminated by the scheduler could cause a database restart.

    • Fixes an I/O performance degradation issue in the late materialization scenario of the columnstore index.

    • Fixes a rare cluster crash in a Multi-master Cluster due to not releasing the metadata lock for a scheduled task in time.

    • Fixes a query slowdown issue when accessing a table in the X-Engine, caused by the inability to use an index covering scan after accessing the primary key index.

    • Fixes a migration link interruption caused by a PolarDB cluster restart in a one-click upgrade scenario from RDS for MySQL to PolarDB for MySQL.

    • Fixes a replica node crash caused by an extreme redo log sequence due to a concurrency relationship between deleting a table or index in X-Engine and a rare background SwitchMemtable operation.

    8.0.1.1.37

    Category

    Description

    Release date

    New features and performance optimizations

    • Optimizes the rate at which a read-only (RO) node reads Redo logs in large Blob scenarios.

    • Supports calling built-in stored procedures using uppercase stored procedure names.

    2023-09-21

    Bug fixes

    • Fixes a node crash caused by adding backticks to the input parameters when calling some built-in stored procedures.

    • Fixes a potential node crash when deleting the last CCL rule of the same SQL statement type that only filled in the keyword but not the schema and table.

    • Fixes a rare crash during the process of a new read-only (RO) node upgrading to a read/write (RW) node, if there was a file extension log after the checkpoint on the RW node when the RO node connected.

    8.0.1.1.36

    Category

    Description

    Release date

    New features and performance optimizations

    • Improves the speed of archiving cold data to OSS in CSV format.

    • Optimizes the cost model for non-covering index access with equality conditions.

    • Adds the parameter opt_non_covering_key_cost to control whether to consider the initial positioning cost of a secondary index.

    • Adds the parameter worst_seek_records_threshold to control whether to limit the maximum I/O cost of non-covering index access with equality conditions during cost estimation.

    • Adds a timeout degradation mechanism to the Redo semi-synchronous feature.

    2023-08-22

    Bug fixes

    • Fixes a crash in the JPPD optimization feature when a CTE contained a nested CTE with multiple references.

    • Fixes an issue where the Slave node did not trigger the reconnection mechanism when the primary node was shut down and restarted.

    • Fixes a potential issue when using the JSON_REMOVE function in the syntax for updating BLOB type data.

    • Fixes an abnormal node restart caused by accessing illegal memory during a transaction deadlock check.

    8.0.1.1.35.1

    Category

    Description

    Release date

    Bug fixes

    Fixes an issue of high CPU usage on low-specification clusters.

    2023-07-13

    8.0.1.1.35

    Category

    Description

    Release date

    New features and performance optimizations

    • Adds the SELECT INTO DEFAULT OSSOUTFILE statement.

    • Adds the parameter innodb_polar_import_tablespace_strict_mode, with a default value of ON. This means that an error will be reported if the table structure contains a full-text index when performing a database and table restoration operation.

    • Supports querying data from a specified partition in a partitioned table using a columnstore index.

    • SQL Trace supports sampling specific SQL statements.

    2023-07-05

    Bug fixes

    • Fixes an issue where a regular user could delete sys.

    • Fixes an abnormal node restart when performing a database and table restoration on a partitioned table after an HA.

    • Fixes a failure of the Standby node to switch to the master node during a point-in-time restore of a Multi-master Cluster.

    • Fixes an issue where stored procedures, user-defined functions, scheduled tasks, views, and triggers in a Multi-master Cluster were not isolated between different nodes.

    • Fixes an issue where stored procedures, user-defined functions, scheduled tasks, views, and triggers in a Multi-master Cluster could not be switched between different nodes.

    • Fixes an issue where data in the Information_schema database could not be synchronized and updated after data was updated when the query cache feature was enabled for a Multi-master Cluster.

    • Fixes a slow cleanup issue in a Multi-master Cluster when the number of data tables was too large.

    8.0.1.1.34

    Category

    Description

    Release date

    New features and performance optimizations

    • Supports creating a columnstore index on a virtual column.

    • Supports using the recycle bin feature for tables with a created columnstore index.

    • You can create hybrid partitions in tables.

    • The federated query engine supports pushing down the Limit Offset syntax to the remote database for execution.

    • The federated query engine supports pushing down all compatible conditions to the remote server for execution and returns only the columns required by the query.

    • Adds the primary key data slicing function call dbms_dts.show_parallel_ranges (<schema_name>, <table_name>, [<suggestion_ranges>]).

    • Supports using the cold data archiving feature for tables with an auto-increment primary key.

    • Optimizes OSS query capability. That is, after enabling the elastic parallel query feature, when the system's loose_csv_max_oss_threads parameter value is greater than 1, a parallel query is directly performed.

    • Optimizes the error message content for incorrect OSS foreign table file formats.

    • Supports adding the without validation option in the ALTER TABLE PARTITION BY RANGE syntax to quickly convert a standard table to a RANGE partitioned table.

    • Supports converting a partitioned table with the 'UNIQUE CHECK IGNORE=1' attribute to a standard table using the ALTER TABLE REMOVE PARTITIONING syntax.

    • Optimizes the issue of skipping digest hash calculation when executing a statement without an Outline during the Statement Outline process.

    • Adds the InnoDB on OSS feature.

    • After updating Statement Outline and Concurrency Control on a Multi-master Cluster, other master nodes are automatically updated.

    • Optimizes the error message content for spelling errors.

    • Optimizes the write performance of the RW node after enabling StandBy semi-synchronous.

    • Added support for the LIST DEFAULT HASH partitioned table type.

    • Supports creating a LIST DEFAULT HASH partitioned table using the CREATE LIKE syntax.

    • The add partition syntax for creating a LIST DEFAULT HASH partitioned table supports using the without validation option to add a LIST partition.

    • SQL Trace supports tracking the execution information of slow queries.

    • Optimizes the lock granularity within PolarFS, significantly improving performance in some high-load scenarios.

    2023-06-12

    Bug fixes

    • Fixes an issue where OSS could not read JSON files.

    • Fixes a Hint Plan generation failure in ps mode.

    • Fixes an issue where the checkpoint LSN advancement did not meet expectations.

    • Fixes an issue where view_definition was empty in the system view.

    • Fixes a potential error when executing a query on an RO node while an ALTER TABLE ... IMPORT TABLESPACE operation was being performed on the RW node.

    • Fixes an issue where data with \n could not be read after being archived by DLM.

    • Fixes an issue where temporary files might remain on OSS after cold data archiving.

    • Fixes an issue where only the first file might be read when reading cold data from OSS in CSV format.

    • Fixes an issue where the internal counter of the thread pool could become abnormal during concurrent recording of slow query logs, causing a backlog of SQL requests.

    • Fixes a potential auto-increment column conflict during concurrent INSERT commands in a Multi-master Cluster.

    • Fixes a replication delay issue when replaying Redo logs of a wide table on an RO node.

    • Fixes an incorrect query result when using the Limit Offset pushdown optimization feature with a query statement containing a window function.

    • Fixes an issue where a lock was held for the entire duration when executing a CHECK TABLE statement in a Multi-master Cluster.

    • Fixes an issue where the source file on OSS could not be deleted when executing the ALTER TABLE engine = csv storage oss, force; command.

    • Fixes a cluster crash caused by dynamically adjusting the cache of a Multi-master Cluster.

    • Fixes an issue where a Multi-master Cluster could not export a tablespace.

    • Fixes an incorrect pushdown of a table with a NULL field when the engine_condition_pushdown parameter was set to true.

    • Fixes a potential incorrect result set when using the Fast Query Cache feature to compare Time and timestamp.

    • Fixes a potential performance regression when dynamically enabling PolarTrans in a high-concurrency update scenario.

    8.0.1.1.33

    Category

    Description

    Release date

    New features and performance optimizations

    • The columnstore index supports instant column addition by rebuilding the columnstore index data.

    • The columnstore index supports the REGEXPR function.

    • The columnstore index supports pruning optimization based on IS NULL and IS NOT NULL related conditions.

    • Multi-master Cluster (Database/Table) supports using the cold data archiving feature.

    • When performing a minor engine version update on a Multi-master Cluster (Database/Table) cluster, it supports parallel upgrading of each node in the cluster.

    • Multi-master Cluster (Database/Table) supports persisting statistics.

    • Optimizes the Optimizer trace when OSS condition pushdown is enabled for OSS foreign tables.

    • Binlog logs are not recorded during manual and automatic archiving of cold data.

    • Global consistency (high-performance mode) adds the Innodb_scc_timeout_count parameter to record the number of timeouts during a query.

    • Global consistency (high-performance mode) adds the Innodb_scc_timeout_degrade_count parameter to record the number of times a query times out and switches to an asynchronous query.

    • Supports querying gtid information on a read-only node.

    • Hint Plan adds the hint types BNL, BKA, and MRR.

    • Fast Query Cache adds the variable qc_weak_read_time to read non-real-time cache.

    • The Statement Outline feature adds the interface dbms_outln.add_optimizer_outline('schema', 'hints', 'query') to add Optimizer Hints.

    • Adds the Auto Plan Cache feature.

    • SQL Sharing uses JSON format to display plan_extra, ref_by, and extra.

    • Displays the execution plan in the extended data of the slow log.

    • When using Statement Outline, if the specified Index Hints do not exist, it reports a warning instead of an error.

    • SQL Sharing adds the variable by_expr_ignore_charset. After setting by_expr_ignore_charset to ON, it eliminates the digest differences generated by statements with Order By or Group By under different character sets. However, after setting it to ON, all digest values generated in this mode will be different from the digest values generated before it was set to ON.

    • Optimizes memory consumption when scanning tables in the recycle bin.

    • Provides multi-version engine capability.

    2023-04-14

    Bug fixes

    • Fixes a database node crash when performing a check operation on an empty OSS foreign table.

    • Fixes an occasional error when executing a query on a global read-only node of a Multi-master Cluster (Database/Table).

    • Fixes an issue where the metadata tablespace size of a Multi-master Cluster (Database/Table) was not synchronized.

    • Fixes an issue where custom table data in the system tablespace of a Multi-master Cluster (Database/Table) would be rolled back.

    • Fixes an issue where undo logs could not be reclaimed after enabling the undo log reclamation feature.

    • Fixes an issue where a read timeout occurred when establishing physical replication on a read-only node, preventing connection to the database.

    • Fixes a node crash caused by executing ADD INDEX or DROP INDEX statements after executing ALTER TABLE DISCARD tablespace in a Multi-master Cluster (Database/Table).

    8.0.1.1.32

    Category

    Description

    Release date

    New features and performance optimizations

    • The columnstore index feature supports the MySQL DECIMAL data type.

    • When creating a columnstore index, it supports sorting data according to a specified column to improve pruning efficiency.

    • The columnstore index feature supports data scanning based on files in ORC or PARQUET format stored in OSS.

    • Cost-based computation supports pushing down the outer join condition of a materialized derived table to the inside of the derived table.

    • Optimizes the optimizer's ability to estimate the number of scanned rows for join columns in an equality derivation scenario.

    • The optimizer's join elimination feature supports eliminating the inner table of a left join (including inner tables with multi-level nested joins and Semi-Joins).

    • Supports the CAST(... AS INT) syntax, with behavior identical to CAST(... AS SIGNED INT) .

    • Multi-master clusters support the Multi-master backup feature.

    2023-02-21

    Bug fixes

    • Fixes an issue where database performance slowed down in long-running transaction scenarios.

    • Fixes compatibility issues between global consistency (high-performance mode) and PQ.

    • Fixes an issue where using the transparent tablespace transport feature in a Multi-master Cluster would block other nodes from executing DDL.

    • Fixes an issue where the free size of a table would, with a certain probability, be displayed as 4 PB.

    • Fixes an issue where some nodes of a Multi-master Cluster could not start when multiple primary nodes were restarted in parallel.

    • Fixes a cluster crash when switching the write point for full-text indexes and columnstore indexes in a Multi-master Cluster.

    • Fixes a database cache access exception when performing a copy DDL on a table with a Foreign Key.

    • Adjusts the timeout parameters related to physical replication connections to avoid stuttering issues in case of a physical machine failure.

    • Fixes an issue where table locks could not be recovered during a Multi-master Cluster crash recovery.

    • Fixes a potential node crash when accessing the information_schema.tables table while adding a new node.

    • Fixes an issue of lost dirty pages during the crash recovery phase of a Multi-master Cluster.

    • Fixes a cluster crash when switching the write point after deleting a database in a Multi-master Cluster.

    • Fixes an issue of illegal memory access when using the TempTable engine with the thread pool enabled.

    2022

    8.0.1.1.31

    Category

    Description

    Release date

    New features and performance optimizations

    • The Standard Edition of PolarDB for MySQL adds the PolarDB high availability automatic switchover feature, which is based on the Reservation feature of NVMe (Non-Volatile Memory Express) cloud disks.

    • The CCL (Concurrency Control) feature adds the built-in stored procedure dbms_ccl.add_ccl_digest_rule, which matches CCL rules through a digest value.

    • Built-in stored procedures support using variables starting with @ as input values.

    • Ignores the semicolon at the end of the SQL statement in the query parameter of the dbms_ccl.add_ccl_digest_rule, dbms_outln.add_index_outline, and dbms_outln.add_optimizer_outline built-in stored procedures.

    • Statement Outline supports all UNION clauses.

    • No longer stores and displays the username and password in the mysql.servers table in plaintext format.

      Note

      The username and password of an existing Server will not be encrypted after an upgrade. You need to manually delete and recreate it.

    • Supports using the Limit Offset pushdown feature when accessing a specific partition in a partitioned table.

    • Clusters of the X-Engine product series support using the parallel DDL feature.

    • The thread pool feature adds kernel autonomy capabilities.

    • The thread pool feature is compatible with CCL. After enabling the Thread Pool feature, if a user's connection is blocked by CCL, the connection will be marked within the Thread Pool, and the Thread Pool will create additional threads to execute SQL statements on other connections.

    • Adds the hint syntax OSS_REPLACE_EXISTED_FILE(). When executing the SELECT INTO OSSOUTFILE statement, if the current file already exists, the original file is directly overwritten.

    • Supports single-machine parallel query on the OSS engine.

    • Adds the table INNODB_GLOBAL_DDL_LOCK_INFO to the information_schema database to view global locks in a Multi-master Cluster.

    • Adds the AWR SQL Detail feature to audit and manage statements such as DDL, LOCK DB, and LOCK TABLE.

    • Supports generating columnstore index statistics through the ANALYZE TABLE command to assist in query decisions.

    • Tables with a columnstore index support using the database (table) restoration feature.

    • The columnstore index feature supports using the cast_as_real function.

    • Supports viewing the build status and progress of a columnstore index through the INFORATION_SCHEMA.IMCI_ASYNC_DDL_STATS table.

    • Optimizes join queries where the join field is of string type in the columnstore index.

    2022-12-07

    Bug fixes

    • Fixes an issue where IF NOT EXISTS could not be used in the syntax for creating a Server.

    • Fixes a potential exception when executing a DDL statement on a master node of a Multi-master Cluster.

    • Fixes a potential deadlock when querying tables in the information_schema database in a Multi-master Cluster.

    • Fixes a performance degradation issue with replace in a Multi-master Cluster.

    • Fixes an issue where a global lock was required when creating an implicit temporary table in a Multi-master Cluster.

    • Fixes a potential hang during crash recovery of a Multi-master Cluster.

    • Fixes an issue where the number of logical reads counted by the SQL Trace feature was inaccurate.

    • Fixes an issue where the output result was incorrect when the columnstore index contained ENUM and SET type data.

    • Fixes an issue where SQL statements with ROLL UP and GROUP BY could not be routed to the column store for execution.

    8.0.1.1.30

    Category

    Description

    Release date

    New features and performance optimizations

    • Optimizes the UNION ALL operation of the columnstore index feature.

    • The columnstore index feature adds a built-in stored procedure to assist in creating a columnstore index.

    • The columnstore index feature adds the global parameter imci_default_pack_shift to control the default pack size for creating a columnstore index.

    • The columnstore index feature supports using partition pruning technology to optimize the query performance of partitioned tables.

    • The columnstore index feature supports using BIT, JSON, and GEOMETRY data types.

    • The columnstore index feature supports the EXCHANGE PARTITION operation.

    • Optimizes the performance of global consistency (high-performance mode) through MTT technology.

    • The Multi-master Cluster Edition supports adaptive eviction of data pages from the cache center.

    • The recursive depth of a JSON document supports 150.

    • The Multi-master Cluster Edition adds the mm_flush_autoinc_when_unlock parameter to control whether to flush the autoinc information in the system table when releasing a global database/table lock. The default value is false.

    • Supports Statement Outline matching for all SQL statements with the same Digest value when Schema_name is empty.

    • Fast Query Cache supports accessing the cache of metadata tables (information_schema.tables/columns) in the database.

    • Adds the SQL Trace feature to track the execution process of SQL statements.

    • Adds the SELECT INTO OSSOUTFILE statement to export a local table (a table on PolarFS) to OSS.

    2022-10-29

    Bug fixes

    • Fixes an issue where data was read incompletely when remotely reading data via RDMA.

    • Fixes an abnormal state of the table clean thread when the master node was shut down.

    • Fixes a deadlock between Offline Master and WAR.

    • Fixes an issue where the master node could not be shut down normally when it lost connection with the cache center.

    • Fixes a potential node crash when writing an implicit primary key through a scheduled task.

    • Fixes an issue where Binlog was recorded when executing an SQL statement during a hot upgrade.

    8.0.1.1.29.1

    Category

    Description

    Release date

    Bug fixes

    Fixes a crash on an RO node caused by a filename hash conflict.

    2022-09-17

    8.0.1.1.29

    Category

    Description

    Release date

    New features and performance optimizations

    • Read-only nodes support the failover with hot replica feature.

    • Concurrency Control (CCL) adds the ccl_mode parameter. When the database access traffic reaches the concurrency control limit, other requests to access the current cluster are rejected.

    • The syntax for creating an OSS server adds the oss_sts_token parameter to configure a temporary access credential for OSS.

    • Supports adaptive digest length, meaning the memory space for statement digest calculation can be adaptively adjusted with the length of the query statement.

    • Supports querying tables related to the columnstore index in INFORMATION_SCHAME through the cluster endpoint.

    • The columnstore index feature adds an ETL mode, which supports creating a table using the query results of a read-only columnstore node, and supports writing the query results of a read-only columnstore node to a table.

    • Optimizes the performance of TopK queries (paging queries in the form of order by a limit n,m) in the columnstore index feature.

    • The columnstore index feature adds the status Last_stmt_use_imci to confirm whether a columnstore index is used in a query statement.

    • The columnstore index feature adds the global variable polar_enable_implicit_imci_with_create_table, which supports automatically creating a columnstore index when executing a CREATE TABLE statement.

    • The columnstore index feature supports using a Cursor.

    • Supports using a columnstore index during an explicit transaction query.

    • Supports creating a columnstore index on a partitioned table.

    2022-09-08

    Bug fixes

    • Fixes an inconsistency between the cache and file caused by a transaction rollback when using the copy algorithm in a DDL statement.

    • Fixes an issue where deleting a database was not recorded in the slow log.

    • Fixes an incorrect result return when Limit offset pushdown and MRR optimization were present in a query at the same time.

    8.0.1.1.28.1

    Category

    Description

    Release date

    New features and performance optimizations

    Thread pool optimization: When a database transaction is waiting for a metadata information lock or a row lock, the thread pool can generate additional threads to handle new requests.

    2022-08-12

    8.0.1.1.28

    Category

    Description

    Release date

    New features and performance optimizations

    • Supports the columnstore index feature. Through the columnstore index feature and the parallel vectorized execution engine for columnar data, the execution efficiency of complex queries can be greatly improved. For more information, see Columnstore index.

    • Supports users creating and using Federated engine tables.

    • Read-only nodes support custom memory temporary tables (currently only supports MEMORY engine and MyISAM engine).

    • Optimizes DDL sorting: two-way merge sort is changed to multi-way merge sort to reduce the number of I/O operations and improve the performance of DDL index addition.

    • Supports the DDL read-ahead feature to improve the efficiency of creating indexes.

    • The syntax for creating an OSS server adds the oss_prefix parameter to configure the OSS file path.

    2022-07-20

    8.0.1.1.27

    Category

    Description

    Release date

    Bug fixes

    Fixes an issue of excessive physical replication delay under low cluster load.

    2022-05-25

    Fixes an issue where the LRU List cleanup was blocked, preventing the release of Pages, in scenarios where the Buffer Pool had too many dirty pages and flushing was slow.

    Optimizes the memory allocation issue during the data insert process.

    Fixes an issue where the show engine innodb status command displayed full deadlock information when the value of innodb_show_verbose_deadlock was ON (the default value).

    Fixes a crash on a new RO node registered to the cluster after the RW node completed a undo truncate operation.

    Fixes an incorrect SKIP_SCAN scan result set after data in the database was marked for deletion.

    8.0.1.1.26

    Category

    Description

    Release date

    Bug fixes

    Fixes an incorrect result for Using index for group by.

    2022-05-05

    Fixes an incorrect SKIP_SCAN scan result set after data in the database was marked for deletion.

    Fixes a potential incorrect SKIP_SCAN scan result set when multiple groups of data existed in the index prefix.

    8.0.1.1.25

    Category

    Description

    Release date

    Bug fixes

    Fixes an incorrect result for Using index for group by.

    2022-04-12

    8.0.1.1.24

    Category

    Description

    Release date

    Bug fixes

    • Fixes an issue where threadpool_high_priority_users was not correctly parsed at database startup.

    • Fixes an issue where dynamically modifying threadpool_high_priority_users could affect other parameters.

    • Fixes a rare crash on a read-only node of X-Engine when replaying Redo logs.

    2022-03-11

    8.0.1.1.23

    Category

    Description

    Release date

    New features and performance optimizations

    • Supports the Strict Consistency Cluster (strong consistency read on RO nodes) feature.

    • Statement Outline supports PrepareStatement.

    • Supports the hot replica feature to further optimize high availability efficiency.

    2022-01-20

    Bug fixes

    • Fixes an issue where Fast Query Cache acquiring an MDL lock on an RO node blocked Redo log synchronization.

    • Supports the SELECT FOR UPDATE/SHARE WAIT N syntax. Here, N represents the timeout in seconds for a single row lock. If a query needs to lock multiple rows, the time is not accumulated; timeout detection is performed only for a single row. If the wait time exceeds N seconds, a lock wait timeout error Lock wait timeout exceeded; try restarting transaction is returned.

    2021

    8.0.1.1.22

    Category

    Description

    Release date

    Bug fixes

    • Optimizes the accuracy of parallelism estimation for partitioned table index equality access in a parallel plan.

    • Fixes an issue where the cost of statistics estimation by the optimizer was time-consuming in specific scenarios.

    • Fixes an issue where the optimizer did not choose a better index range path for some GROUP BY statements.

    • Fixes a failure to create a new Redo log file after a Standby node was switched to a primary node through HA.

    2021-12-22

    8.0.1.1.21

    Category

    Description

    Release date

    Bug fixes

    • Fixes an incorrect GROUP_CONCAT function result caused by an arithmetic overflow when the group_concat_max_len parameter value was large.

    • Fixes a data error that occurred after a Standby node in a secondary zone recovered from a failure.

    • Fixes a data anomaly that occurred when a Standby node in a secondary zone was switched to a primary node (RW node).

    • Fixes an issue where the optimizer could only perform single-column index filtering, not composite index filtering, when a multi-column composite index filter condition was selected.

    2021-11-26

    8.0.1.1.19

    Category

    Description

    Release date

    New features and performance optimizations

    • Adds new concurrency control (CCL) rules for DDL operations.

    • Adds the parameter restrict_on_limit_without_order to control whether to allow parallel query execution for queries with a limit clause but no order by clause.

    2021-09-18

    Bug fixes

    • Fixes an issue in parallel queries where implicit sorting for `GROUP BY` resulted in an unordered result set when an index on the `GROUP BY` column was used.

    • Fixes an error where the transaction ID field in the audit log was always 0 when using the thread pool.

    8.0.1.1.18

    Category

    Description

    Release date

    New features and performance optimizations

    The database kernel now supports resumable transaction uploads and allows read-only nodes to read uncommitted transactions.

    2021-08-14

    Bug fixes

    Optimizes the master_key_id_mutex to allow DDL operations to be executed in parallel.

    8.0.1.1.17

    Category

    Description

    Release date

    New features and performance optimizations

    • Adds the polar_replica_work_on_nonblock_mdl_mode parameter. When this parameter is enabled, uncommitted transactions at the RU/RC isolation level on a read-only node will no longer block DDL operations on the primary node. However, the transactional properties of table definitions on the read-only node will no longer be guaranteed.

    • Optimizes the maintenance mechanism for statistics in scenarios with a massive number of tables (such as those requiring SaaS services). This significantly improves the performance of querying table structures (desc table) and read/write operations under high concurrency.

    2021-07-23

    Bug fixes

    • Fixes a crash at m_recv_bits.is_set(fold) on a read-only node during physical replication under high concurrency pressure.

    • Fixes a crash during log replay on a read-only node under high concurrency pressure.

    8.0.1.1.16

    Category

    Description

    Release date

    Bug fixes

    When an ACL Cache Lock request waits, information about the requesting thread and the earliest lock-holding thread is printed in the master error log to assist with problem diagnosis.

    2021-06-24

    8.0.1.1.15

    Category

    Description

    Release date

    New and optimized features

    • TDE now supports automatic encryption for new tables created in a MySQL cluster.

    • MySQL data tables now support the utf8mb4_0900_bin character set.

    2021-05-25

    Bug fixes

    • Fixes a database crash caused by an overly long record generated when rolling back an Update operation after an instant add column.

    • Fixed an issue where DDL statements forced the mysql.slow_log and mysql.general_log tables to use the InnoDB engine.

    • Fixes an incorrect result set caused by an error in the metadata information of the REGEXP function.

    • Fixes a database crash caused by rolling back an Update operation on a virtual column.

    • Adjusts the strategy for whether an RO node should immediately trigger a checkpoint upon initial registration with the primary node. A checkpoint may not be triggered if the LSN difference is less than the specified threshold.

    8.0.1.1.14

    Category

    Description

    Release date

    New features and performance optimizations

    • Optimizes the maintenance of internal index information in scenarios with a massive number of tables (such as those requiring SaaS services) to improve the startup speed of read-only nodes.

    • Optimizes GDN synchronization connections, reduces CPU consumption by synchronization threads, and improves the speed of synchronizing Redo logs from the cluster for small-specification (i.e., under 8 cores) secondary clusters.

    • Optimizes the AutoDop strategy in the degree of parallelism control parameters to avoid affecting the use of PARALLEL HINT and force_parallel_mode.

    2021-04-23

    Bug fixes

    • Fixes an issue where an incorrect index was used for a wide-range RANGE query due to inaccurate records_in_range statistics.

    • Fixes a Standby node crash caused by a buffer pool that was too small during a full data point-in-time restore.

    • Fixes an issue of excessive memory consumption by internal metadata in the X-Engine.

    • Fixes two ACL DDL issues from official MySQL to prevent cluster unavailability caused by deadlocks from ACL DDL operations.

    • Fixes an issue where an incorrect result set was returned when a parallel query included the SQL_BUFFER_RESULT keyword and used an aggregate function without a GROUP BY.

    8.0.1.1.13.2

    Category

    Description

    Release date

    Bug fixes

    Fixes a potential decryption failure caused by the loss of encryption information in TDE-encrypted tables during a primary-secondary switchover.

    2021-04-19

    8.0.1.1.13.1

    Category

    Description

    Release date

    Bug fixes

    Fixes a query slowdown in parallel queries caused by the failure to push down constant filter conditions from the Block Nested-Loop Join (BNL) algorithm to a single table.

    2021-04-08

    8.0.1.1.13

    Category

    Description

    Release date

    New features and performance optimizations

    • Read-only nodes now support the polar_use_statement_mdl_on_replica parameter to prevent transactions on read-only nodes (at the RC isolation level) from blocking DDL operations on the primary node. Additionally, when a read transaction on a read-only node is concurrent with a DDL on the primary node, the read transaction will see different table definitions (for example, if an ADD COLUMN operation occurs on the primary node between two statements of a read transaction on a read-only node, the second statement on the read-only node will read more columns than the first).

    • Removes unnecessary equality conditions from the index equality lookup path to facilitate Limit offset pushdown execution in ORDER BY LIMIT scenarios.

    • Adds the dbms_stats.gather_stats(timeout, workers) command, which supports updating outdated histograms through event scheduling or manual execution.

    • mysql.slow_log now supports viewing the log_version, log_id, origin_start_time, and rds_ext fields.

    2021-03-30

    Bug fixes

    • Fixes an issue where a query could not be terminated when executing commands such as CHECK TABLE, COUNT(*), or DDL on an X-Engine table.

    • Changes KICKOUT to a non-reserved keyword.

    • Fixes an issue where parallel query was not fully utilized in certain situations because the estimated number of scanned rows during query plan generation was less than the actual number.

    8.0.1.1.12.2

    Category

    Description

    Release date

    Bug fixes

    • Fixes a cluster unavailability issue caused by creating or deleting a temporary table in a stored procedure when the session_track_temporary_tables system variable was enabled.

    • Introduces a patch from official MySQL 8.0.14 to resolve an issue where the CREATE USER statement was blocked due to the inability to acquire a metadata lock (MDL) on MySQL database system tables.

    2021-03-12

    8.0.1.1.12.1

    Category

    Description

    Release date

    New features and performance optimizations

    Optimizes the write performance of the PolarDB X-Engine when continuously importing data in multi-table scenarios.

    2021-03-02

    Bug fixes

    Fixes a potential inconsistency in the metadata lock (MDL) state between the Leader and Worker threads in a parallel query. This was caused by a missing mutex protection for the Leader thread.

    8.0.1.1.12

    Category

    Description

    Release date

    New features and performance optimizations

    • The degree of parallelism control policy adds the auto_dop_low_degree_cost parameter to set the parallelism selection strategy for parallel queries. For more information, see Parallel resource control policy configuration.

    • Adds support for quickly recovering tables in the recycle bin using the restore_table command. For more information, see Table recycle bin.

    • Supports obtaining Binlog from read-only nodes. For more information, see Remotely obtain and parse Binlog logs of PolarDB for MySQL.

    • Supports printing key information such as in_memory in the opt trace to help locate the cause of problems when an execution plan issue occurs.

    2021-02-20

    Bug fixes

    • Introduces a Port Percona patch to resolve slow ACL CACHE metadata lock conflict detection in high-concurrency scenarios.

    • Adds the preferred_ordering_index parameter to the optimizer_switch system variable. This fixes an issue where the optimal plan was not selected in certain scenarios (such as ORDER BY or GROUP BY queries with a LIMIT clause) due to the use of an ordered index.

    • Fixes an incorrect SHOW PROCESSLIST result in some scenarios.

    • Fixes slow system table access after a minor version upgrade from versions earlier than 8.0.1.1.10. This was caused by the definition of the information_schame.KEY_COLUMN_USAGE system table not being updated.

    8.0.1.1.11

    Category

    Description

    Release date

    New features and performance optimizations

    • Adds support for setting the parallelism configuration strategy in parallel queries through the parallel_degree_policy parameter. For more information, see Parallel resource control policy configuration.

    • Adds support for limiting the length of recognizable statements by setting the max_digest_length parameter value with a SET GLOBAL statement.

      Note

      After the max_digest_length parameter value is modified, the client needs to reconnect to the cluster for the new parameter value to take effect.

    • The default value of the innodb_adaptive_hash_index parameter is changed from ON to OFF.

    2021-01-29

    Bug fixes

    • Fixes an issue of inconsistent permissions between the primary and read-only nodes.

    • Fixes an issue where a read-only node could not connect to the primary node after a primary-secondary switchover.

    • Fixes an incorrect processing logic in SPM when a specific execution plan becomes invalid.

    8.0.1.1.10

    Category

    Description

    Release date

    New features and performance optimizations

    • Adds support for implicit sorting of Group By, consistent with its usage in PolarDB for MySQL 5.7.

    • Adds a feature to disable parallel query when a Blob field is present.

    • Adds a feature to automatically update statement-level concurrency control cache information on read-only nodes.

    • Adds the hotspot row optimization feature. For more information, see Hotspot row optimization.

    • Adds support for DDL physical replication optimization. For more information, see DDL physical replication optimization.

    • Async metadata lock replication is now supported. For more information, see async metadata lock replication.

    • Adds a feature for fast reverse traversal when computation is pushed down.

    • Optimizes the file system to speed up table opening in multi-table scenarios.

    • Reduces the primary-secondary switchover time in multi-table scenarios and accelerates the recovery of the new primary node.

    2021-01-12

    Bug fixes

    • Fixes an issue of lost system tables when a read-only node was upgraded to a primary node.

    • Fixes an issue where using a range query after enabling parallel query caused an overestimation of the number of scanned rows.

    • Fixes an issue where the result of an aggregate query was an integer when the field type was BIT.

    • Fixes an incorrect result returned by a SELECT DISTINCT query after using an enumeration field.

    • Fixes an abnormal result in a parallel query using an EXISTS condition.

    • Fixes a read-only node restart failure in some cases.

    • Fixes an abnormal table information issue in the data dictionary. This was caused by a foreign key-related table reopening the DDL-executing table when it was opened during a DDL execution on a read-only node.

    • Fixes a full-text index query failure caused by an incorrectly set node restart flag after a primary-secondary switchover.

    • Fixes an issue where the log application thread on a read-only node was blocked by a metadata lock (MDL).

    • Fixes an issue where a new primary node became unavailable after a primary-secondary switchover due to the reuse of released memory.

    • Fixes an issue where all nodes became unavailable due to a polar.info data problem.

    • Fixes an abnormal auto-increment column issue in a partitioned table.

    • Fixes a data error caused by a Redo log overwrite on the primary node.

    • Fixes an issue where the primary node became unavailable when waiting for a metadata lock (MDL).

    • Fixes related issues when using transparent data encryption (TDE).

    • Fixes a cluster unavailability issue when executing Lock Table with the table recycle bin feature enabled.

    • Fixes a deadlock on the primary node when executing a DDL.

    • Fixes an issue where the thread pool and connection control could not take effect simultaneously.

    2020

    8.0.1.1.9

    Category

    Description

    Release date

    New features and performance optimizations

    Removes SPM and PLAN as keywords to avoid issues where tables could not be operated on if their names contained these words.

    2020-12-18

    8.0.1.1.8

    Category

    Description

    Release date

    New features and performance optimizations

    • The execution plan manager adds a multi-plan mode.

    • Adds the system variable rds_ap_threshold to block requests where the optimizer estimates too many scanned records.

    • Improves the efficiency of dirty page flushing on the primary node.

    • Adds a Redo multi-shard write mechanism.

    2020-12-09

    Bug fixes

    • Fixes a null pointer issue with the metadata lock (MDL) key during parallel query execution.

    • Fixes a query failure when creating a parallel thread cache.

    • Fixes an abnormal result from parallel query Multi-Range Read (MRR).

    8.0.1.1.7

    Category

    Description

    Release date

    New features and performance optimizations

    • Improves the efficiency of parallel scanning for driven tables in JOIN query scenarios.

    • Adds support for cleaning up residual Binlog files even when Binlog is disabled.

    • Adds an automatic check and reconnection mechanism for disconnected Slave node physical replication to avoid prolonged physical replication disconnections.

    • Improves the switchover efficiency between the primary and read-only nodes.

    • Supports fast startup of clusters with many tables for quick scanning of table data files.

    2020-11-16

    Bug fixes

    • Fixes a cluster crash when getting the type of trx->wait_lock.

    • Fixes an issue where the number of AIO threads was limited when multi-queue Simulated AIO was enabled.

    • Fixes an issue where a query could not be terminated directly if the initial query failed when querying an index.

    • Fixes an issue where the Next Page of the current cursor pointed to a non-existent Page during a Split Merge Operation (SMO) on a Slave node.

    • Fixes an issue where a read-only node would read log information that had already been overwritten by the primary node.

    • Fixes a failure to clean up Redo files caused by an excessively large timestamp interval in the Redo log.

    • Fixes an issue where table cache information in the relevant cache was not cleared when releasing a metadata lock (MDL).

    8.0.1.1.6

    Category

    Description

    Release date

    New features and performance optimizations

    • Improves the compatibility of SPM (SQL plan manager) and parallel query.

    • Improves the efficiency of parallel query merge sort.

    • Supports computation pushdown for delete operations.

    • Supports the PolarDB Commit Timestamp (CTS) feature.

    2020-09-21

    Bug fixes

    • Fixes an incorrect description of pq_optimize_switch.

    • Fixes an issue where a subquery could not be executed stably.

    8.0.1.1.5

    Category

    Description

    Release date

    New features and performance optimizations

    • Specifies whether the primary node immediately executes the checkpoint policy upon establishing a replication relationship with a read-only node.

    • Supports simple range queries and computation pushdown.

    • The PFS (Polar file system) adds a pfs_remount feature to avoid the inability to mount a PFS file due to the file not being closed.

    • Resolves a performance bottleneck caused by forced pauses of the Parse thread on read-only nodes, improving the efficiency of data synchronization during physical replication.

    • Optimizes Early Lock Release performance in multi-connection scenarios, improving cluster performance in such scenarios by up to 10 times.

    2020-08-19

    Bug fixes

    • Fixes an unavailability issue on a read-only node after it failed to connect to the primary node.

    • Fixes an unavailability issue on a read-only node after a primary-secondary switchover, which occurred after using a full-text index and executing a DDL query statement.

    • Fixes an issue where a purge binlog could not be performed after executing an UNDO TRUNCATE command.

    • Fixes an issue of inconsistent statistics between the read-only and primary nodes.

    8.0.1.1.4

    Category

    Description

    Release date

    New features and performance optimizations

    • Supports parallel DDL to improve DDL execution efficiency.

    • Supports dynamic adjustment of the length of multiple queues in Simulated AIO.

    • Supports Full Text Search (FTS) cache consistency.

    • The WHERE clause supports subqueries containing aggregate functions. If the subquery supports index-based scanning, it can also support parallel execution.

    • Temporary tables support lock mode checks just like standard tables.

    2020-07-04

    Bug fixes

    • Fixes a cluster unavailability issue caused by some DDLs still being replicated when the primary node was demoted to a secondary node.

    • Fixes a performance degradation issue caused by enabling the thread pool.

    • Fixes a deadlock caused by purge binlog.

    • Fixes several memory leak issues.

    • Fixes several issues that occurred in high-availability scenarios.

    8.0.1.1.3

    Category

    Description

    Release date

    New features and performance optimizations

    • Enhances security (such as password management).

    • Improves the performance of Parallel Query in the following scenarios:

      • Enhances parallel query performance in GROUP BY, UNION, and SELECT COUNT(*) FROM <table> scenarios.

      • Scenarios where the execution plan uses a shared InnoDB temporary table in a parallel subquery.

      • Scenarios where the plan uses a VIEW/DERIVED TEMP TABLE.

      • Parallel query supports scenarios defining temporary tables, but with the following limitations:

        • Does not support SELECT COUNT(*) on a temporary table without a condition.

        • Does not support parallelism on a Memory Engine temporary table.

    • Supports the new version of the audit log format, which adds VIP information.

    • Supports index page free space ratio control to reduce the probability of SMO and latch contention, improving write performance.

    • Supports multi-queue simulated AIO to enhance flushing and write performance.

    • Supports not recording buffer pool content in core files to reduce the size of core files and avoid affecting online services.

    2020-05-29

    Bug fixes

    • Fixes an issue where the TempTable storage engine would incorrectly report an out-of-memory error instead of falling back to disk-based storage when the maximum memory limit for TempTable was reached.

    • Fixes a cluster unavailability issue when using ORDER BY in an InnoDB full-text search with a small sort buffer size parameter.

    • Fixes an issue where the correct Field could not be found when a temporary table had columns with the same name.

    • Fixes an issue where a parallel query using the MAX/MIN function with GROUP BY and a loose scan could not be killed.

    • Fixes several failover issues.

    • Fixes several parallel query issues.

    • Fixes an issue where using the SHOW BINARY LOGS command could block transaction commits.

    8.0.1.1.2

    Category

    Description

    Release date

    New features and performance optimizations

    • Supports a sorting optimization method based on string prefixes (i.e., sorting is first performed using the string prefix, and if the prefixes are the same, the full length of the string is then used for sorting). When sorting columns of long character types, you can accelerate the comparison and reduce sorting time by specifying the maximum different prefix length of the column values.

    • Adds support for parallel query in the following scenarios:

      • Supports parallelism for the Range Cost estimation model.

      • Supports parallelism for Temporary Table tables.

      • Supports parallelism under the Semijoin materialization Lookup and Scan strategies.

    • Adds 3 types of session state trackers that can be used by the PolarDB smart routing to support the persistent connections feature. Additionally, once the tracker is enabled, it can track changes to user variables in a session, the creation and deletion of temporary tables, and prepare and deallocation operations in SQL statements.

    • Optimizes the performance of Drop AHI during a DDL process to reduce the impact of DDL on cluster performance.

    • Adds the table recycle bin feature to avoid data loss due to accidental deletion.

    • Optimizes the performance of truncating a large buffer pool temporary tablespace to reduce the impact of temporary table operations on cluster performance.

    2020-04-09

    Bug fixes

    • Fixes an issue with ROLLUP when an aggregate function was present in an IF function.

    • Fixes an issue with Blob types during the sorting process.

    • Fixes a specific issue with SQL containing an aggregate function in Prepare in a parallel environment.

    • Fixes several parallel query issues.

    • Fixes an issue where too many Redo logs could be cleared.

    • Fixes Redo log-related issues on RO nodes.

    8.0.1.1.1

    Category

    Description

    Release date

    New features and performance optimizations

    • Supports using parallelism in scenarios where a subquery contains ROLLUP.

    • Supports the statement concurrency control feature.

    • Adds the POLARDB_INDEX Hint.

    • Optimizes synchronization latency between the primary and read-only nodes.

    • Supports Thread Pool.

    • Supports the TDE keyring_rds plugin.

    • Supports Global Database Network (GDN).

    • Optimizes the lock-free transaction system to optimize read and write performance.

    2020-03-28

    Bug fixes

    • Fixes several parallel query issues.

    • Fixes an issue where statistics could be 0 during an ONLINE DDL process.

    • Optimizes the user-mode file system to accelerate cluster startup.

    • Fixes a potential cluster unavailability issue when innodb_flush_method was set to all_o_direct.

    • Fixes a potential cluster unavailability issue when releasing locks during a transaction commit.

    • Fixes an issue where slow log truncation could block user requests.

    • Fixes a potential cluster unavailability issue with compressed pages on an RO.

    • Fixes an issue where the thread pool could incorrectly disconnect a kill replication connection.

    8.0.1.1.0

    Category

    Description

    Release date

    New features and performance optimizations

    • Enhances the parallel query capability to support parallel computation of the enterprise-level analysis ROLLUP function.

    • Adds optimizer estimation model capabilities (such as enhancing the selectivity of condition filtering and the cost estimation model for parallel queries). The executed SQL can more accurately choose a parallel or serial plan based on Selectivity.

    • Supports unified management of parallel worker threads allocated in FIFO mode to avoid system resource exhaustion caused by many parallel queries.

    2020-02-05

    Bug fixes

    • Fixes a series of memory-related issues with parallel queries.

    • Fixes several instability issues with parallel queries.

    8.0.1.0.6

    Category

    Description

    Release date

    Bug fixes

    • Fixes an issue where the Binlog Index file was not closed when the primary node was demoted to a secondary node.

    • Fixes a cluster unavailability issue that occurred when an RO node accessed a cleared Undo page.

    • Fixes an issue where a background thread accessed a non-existent tablespace page during a primary-secondary switchover on an RO node.

    • Fixes a cluster unavailability issue caused by writing to the Redo log after the log thread had already exited during cluster shutdown.

    2020-01-01

    2019

    8.0.1.0.5

    Category

    Description

    Release date

    New features and performance optimizations

    • Optimizer trace now supports information related to parallel queries (for example, you can use the Optimizer trace tool to analyze why parallelism was or was not used).

    • Adds Hints related to parallel queries, supporting explicit enabling of parallelism and specifying the degree of parallelism through SQL Hints.

    • Supports parallel scanning for INSERT..SELECT under READ COMMITTED. You can use the INSERT..SELECT statement to add imported data to another table.

    2019-12-03

    Bug fixes

    • Fixes several parallel query issues.

    • Fixes a node unavailability issue that occurred when a secondary node was upgraded to a primary node during a primary-secondary switchover.

    • Fixes a failure caused using some DDL statements during a primary-secondary switchover.

    • Fixes a "too many connection error" caused by lock limitations.