PolarDB:PolarDB for MySQL 8.0.2 release notes

Description

• Added free in-database inference for built-in models. Models can run inference directly in the database, with no token consumption and no additional charges.

Description

• Fixed an issue where, for INTERVAL partitioned tables, specifying ROW_FORMAT=COMPRESSED without explicitly setting KEY_BLOCK_SIZE caused the ROW_FORMAT attribute to be lost.

Description

• Added support for parallel refresh of materialized views.

• Introduced incremental refresh for materialized view, which enhances refresh performance compared to the full refresh method.

• The new database and table restore workflow enables fast full data queries that complete in minutes, regardless of the amount of data being restored.

• Added support for asynchronously cleaning up expired global secondary index (GSI) data left behind by DROP/TRUNCATE PARTITION operations.

• Introduced the GDN multi-write edition, providing global multi-point write capabilities at the table level.

• Added support for columnar execution plans to the ask_polar expression.

• Vector retrieval for columnar index (IMCI) now has a dedicated concurrency control module that decouples it from the concurrency control of columnar index queries.

• Upgraded vsag to the official 0.16 branch, adding parallel build capabilities for the HNSW algorithm and support for creating hgraph-based indexes.

• Vector retrieval for columnar index (IMCI) now supports IVF and IVF PQ vector index types.

Description

• Improved Hash Join performance for columnar index (IMCI) by storing intermediate join results in row format to reduce the performance overhead of data materialization.

• Optimized the X-Engine storage engine by removing unnecessary implicit primary keys (Implicit PKs) to simplify the data update logic and in-memory data structures in the storage layer.

• Optimized the table cache invalidation strategy for partitioned tables in X-Engine (High-Compression Engine) during add or drop partition operations to reduce the impact on queries.

• Optimized the concurrent computation logic for vector index builds, allowing more threads to be used to accelerate index creation.

• Fixed inaccurate adaptive rate limiting for DDL bulk load and improved the adaptive rate-limiting algorithm.

Description

• Fixed a crash that could occur during an incremental refresh of a materialized view on a hybrid partitioned table when reading partition metadata.

• Fixed an issue where an online DDL operation failed on a table that contained an index on a virtual column.

• Fixed an issue in the community edition of MySQL where purging binary logs at startup could result in an incorrect Previous_gtid for the global transaction identifier (GTID).

• Fixed an issue where INSERT ON DUPLICATE KEY UPDATE could update the wrong row during concurrent inserts from multiple sessions into a table with an auto-increment column.

• Fixed an issue where a columnar query using Hybrid Index Search with a LIMIT clause could fall back to row-store execution if the LIMIT OFFSET value was too large.

• Fixed various incompatibility issues on multi-primary nodes when Parallel Parse is enabled.

• Fixed a potential memory leak in VSAG-based HNSW and DiskANN indexes within the vector index of a columnar index (IMCI).

• Fixed a cluster crash that could occur when a Hybrid Plan for a columnar index (IMCI) reclaimed a Read View.

• Fixed a memory leak of approximately 626 KB that was caused by the buffer pool not being released in the initialization abort path when an InnoDB HA failover failed to start.

• Fixed a memory out-of-bounds access issue caused by concurrent access between rollback segment (Rsegs) lock objects and the Redo log replay thread during InnoDB HA failovers, and a memory leak in the error branch for large records (big_rec) in the clustered index insertion path.

• Fixed a memory leak in the sql_sharing and sql_sharing_proc modules of SQL Plan Management (SPM) where internal buffers of string objects were not properly released.

• Fixed a use-after-free issue in the X-Engine storage engine that could occur if a background space reclamation task ran concurrently with a database instance shutdown.

• Fixed an invalid memory free operation and an indirect memory leak in InnoDB caused by the LatchCounter incorrectly releasing an embedded counter object upon destruction.

• Fixed a minor memory leak that occurred with every request in the ask_polar module because the request header linked list was not properly released after an HTTP request completed.

• Fixed a use-after-free issue where the performance monitoring module (performance_schema) could access a stale pointer to a session thread (THD) during a concurrent scan after the thread had already released its resources.

• Fixed multiple memory leaks in the extended statistics (polar_extend_stats) module. The issues were caused by improperly destroyed sampled cache data, a value-tuple buffer detached from memory management, and missing ownership in a filter-effect clone container.

• Fixed a memory out-of-bounds access issue during instance shutdown. The issue occurred when a redo log synchronization thread accessed a freed resource because a synchronization object was destroyed during binlog cleanup before the thread had completely exited.

• Fixed a stack overflow in the X-Engine storage engine. The issue occurred when a DDL operation on a partitioned table generated a full table name that exceeded the system's maximum length and was written to a fixed-size buffer.

• Fixed an instance crash that occurred during a parallel refresh of a full refresh for materialized view in specific semijoin query scenarios.

• Fixed a memory out-of-bounds access issue that occurred when a Prepared Statement was recompiled, and a table name pointer in a query hint still pointed to a freed memory area.

• Fixed an issue where a LOAD DATA statement failed after attempting to import a NULL value into a NOT NULL column, but the session's field validation state was not reset, causing subsequent valid INSERT statements in the same session to incorrectly fail with a Column cannot be null error. As a temporary workaround, re-establish the connection.

• Fixed an instance crash caused by a buffer overflow. The overflow occurred due to an out-of-bounds write while generating a warning message after an invalid date-time value was passed during the execution of a Prepared Statement.

• Fixed a system crash that could occur in a parallel query when an ORDER BY clause referenced a constant alias expression.

• Fixed a crash caused by incomplete copying of an internal data structure when the query optimizer pulled up a subquery (merged it into the outer query). Also fixed an issue where the table cache pointer was null or invalid.

• Fixed an issue where a columnar index became invalid and unusable after a DDL operation that simultaneously added both a columnar index and a regular secondary index to a partitioned table.

• Fixed a compatibility issue between PolarDB-specific ALTER syntax (such as for quickly converting a single table to a partitioned table) and DMS comments, which resolves DTS transmission issues between PolarDB instances.

• Fixed a dangling pointer access issue caused by the PlanHintsStatement not being reset when a Prepared Statement was recompiled.

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

• Fixed a memory issue that could occur on a read-only node (RO) when flushing the cache if the extended statistics feature was enabled.

• Fixed a data write failure during an instance version upgrade caused by incompatible data types for the scan_cost, purge_cost, and purge_rows fields in the mysql.ttl_job_history system table.

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

• Fixed a memory issue on a standby HA node running as a replica, which could be caused by the log_allocater not being released in a timely manner.

• Fixed an incorrect threshold calculation in columnar index (IMCI) when converting a statement with a multi-column (Row Expr) IN list into a semijoin.

• Fixed a replication latency timeout on a columnar index (IMCI) read-only node that was caused by the Query Cache prematurely triggering an InnoDB strong consistency read wait.

• Fixed a data anomaly caused by a lost Header Page Apply when Transparent Data Encryption (TDE) was used on a read-only node (RO) or a standby node.

• Fixed an issue where the Thread Pool and Connection Control plugins were started simultaneously on new nodes due to incorrect parameter configuration. A conflict check will now be automatically performed at startup.

• Fixed a buffer overflow and instance crash that could occur when querying a partitioned table using a secondary index on an integer field, if the first InnoDB partition of the table was a Partition Partial Index.

• Fixed a crash in the community edition of MySQL caused by an exception when updating a spatial index that is a secondary index.

• Fixed an issue where the results of the Orca DUMP command were not recognized by Redis versions earlier than 7.4.0.

• Fixed an issue where the background dump task for a vector index in a columnar index (IMCI) was not terminated in a timely manner after the corresponding table or index was deleted.

Description

• Added the mm_enable_wait_binlog_flush parameter. This allows a Multi-primary Cluster (Limitless) to wait for the binlog flush to complete, addressing potential data consistency issues caused by asynchronous binlog flushing.

• Fixed a crash that occurred when dropping a CSV table with DROP TABLE in a Multi-primary Cluster (Limitless) that used the cold data archiving feature.

Description

• Fixed an issue where a minor version upgrade to 8.0.2.2.34 would get stuck during the upgrade task flow due to a problem in the upgrade process.

Description

• Added multiple index statistics sampling strategies that can be enabled via parameters.

• Added support for global secondary index (GSI) to perform REBUILD PARTITION operations on partitioned tables.

• The columnar index (IMCI) Hybrid Plan (including Hybrid Index Search and Hybrid Index Join) now supports the MPP execution mode.

• Vector retrieval for columnar index (IMCI) now supports the DiskANN index type.

• Added the parallel Copy DDL feature, which significantly improves the execution efficiency of COPY DDL operations.

• Added the PolarSearch search view feature to enable auto-ETL from PolarDB for MySQL to PolarSearch, simplifying data synchronization.

• Added the WITHOUT VALIDATION option for REORGANIZE PARTITION to support quickly changing RANGE partition boundaries. This is useful for routing new data to a new partition by modifying its boundary when an existing partition is nearly full.

  Note

  Limitation: A single DDL statement can only modify the boundary value of one partition and does not support changing the partition name.

• Added the xengine_default_storage_table_format parameter, which allows you to specify the default table format when creating X-Engine (High-Compression Engine) tables.

• Added support for offloading queries to a specified node for execution during a full refresh for materialized view.

• Traditional InnoDB compressed tables with a BLOCK_SIZE of less than 4 are at risk of data corruption. The new polar_compressed_table_policy system variable has been added to control the compression policy for newly created tables.

  • NATIVE: Executes 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 returns an error.

  Note

  • This policy applies only to newly created compressed tables and does not affect existing compressed tables.

  • For clusters that run a kernel version earlier than 8.0.2.2.34, we recommend that you no longer create InnoDB compressed tables with a BLOCK_SIZE less than 4.

• Added support for hybrid partitioned tables with primary keys, allowing partitions from X-Engine (High-Compression Engine) to be archived as OSS partitions.

• Added a DEMAND mode for SQL Plan Management (SPM) that can be used to inject, capture, and manage execution plans.

• Added support for dynamically enabling and disabling the memory pool for PolarDB Three-Layer Decoupling (CXL). This currently supports toggling the entire CXL memory on or off but does not yet support dynamically resizing the CXL memory pool.

• You can now connect directly to Alibaba Cloud's Model Studio service platform by using the ask_polar expression.

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

• Added support for the LNNVL expression in both row-store and column-store executors.

Description

• Optimized the process of archiving partitions to an OSS partitioned table (cold data archiving). UPDATE and DELETE statements now automatically prune partitions being archived and cold data partitions in OSS, which minimizes the blocking of DML statements.

• Improved the speed at which X-Engine (High-Compression Engine) restores metadata structures during a restart to reduce restart time.

Description

• Fixed an issue where the latest results were not immediately readable after a full refresh for materialized view was complete when the Query Cache was enabled.

• Fixed an issue where the declared order of an ORDER BY clause was ignored in some scenarios. Also optimized predicate handling for Loose Index Scan (LIS) in grouped queries.

• Fixed incorrect memory statistics in performance_schema when the thread_pool_enabled parameter was enabled.

• Fixed an issue where occasional transaction loss for In-Memory Column Index (IMCI) under the transaction persistence feature of Seamless Switch led to data inconsistency between row and column stores.

• Fixed an issue with the timestamp type in ORC format where the min/max values were calculated incorrectly by misaligning units and ignoring the nanosecond part.

• Fixed an issue where the default value became invalid due to a memory exception when an instant add column operation that adds a column with a long string default value was converted to an asynchronous operation.

• Fixed an issue where the incomplete implementation of cloning for Item_ref objects in the JPPD feature caused a subsequent crash.

• Fixed an issue in columnar index (IMCI) where a filter condition was incorrectly pushed down past a LIMIT clause, which could lead to incorrect results.

• Fixed a crash in the mysqlredolog tool that occurred when parsing specific MLOG_METADATA_CHANGE records.

• Fixed an intermittent crash when JSON_TABLE was executed in the execution path of a trigger.

• Fixed an error that could prevent statistics from being updated when collecting statistics for a columnar index (IMCI) with the low-cardinality column sampling enhancement (imci_stats_scan_max_ndv) enabled.

• Fixed an issue where CCL was ineffective for the DELETE xx FROM ... syntax (the DELETE FROM ... syntax was unaffected).

• Fixed an incorrect memory state on a read-only (RO) node when no extensions were initialized.

• Fixed an issue where a Bloom filter did not take effect during queries when using cold data archiving with the filter specified for a date type.

• Fixed a potential crash in Orca (Redis-compatible) that could occur when using a cursor (pcur) to clean expired keys. The mechanism has been replaced with a key-storage approach.

• Fixed an issue where an int integer overflow in the In-Memory Column Index (IMCI) NCI file system after long-running operations caused out-of-bounds memory access and resulted in IMCI transaction replay getting stuck.

Description

• Fixed an issue where online Copy DDL did not work in certain scenarios. Also added restrictions for use in scenarios such as Multi-primary Cluster (Limitless).

• Fixed a rare crash on a read-only (RO) node that could occur when using an X-Engine columnar table. The crash was caused by inconsistent synchronization of the internal purge sequence (purge seq) between the read-write (RW) and RO nodes.

• Fixed a slow query issue that occurred when a columnar index (IMCI) created empty statistics for an OSS partitioned table (cold data archiving) because it calculated the actual row count.

Description

• Added a native BSON data type. This type supports projection, update, query, and aggregation operations.

• Added the ability to call a large language model (LLM) directly by using standard SQL statements.

• Added parallel insert capabilities during the refresh process of a full refresh for materialized view. This parallel processing significantly improves the data refresh speed for materialized views.

• Added the search view and ETL stored procedure feature, which automates data extraction, transformation, and loading (ETL) to improve the efficiency of data synchronization and aggregation.

• Added configurable execution time windows for SQL-layer TTL. You can now specify start and end times for TTL tasks to automatically clean up expired data within a preset time frame.

• X-Engine (High-Compression Engine) now supports the columnar storage format for low-cost storage and high-performance analytics.

• Added support for executing DDL operations in COPY mode on hybrid partitioned tables that contain OSS partitions.

• X-Engine (High-Compression Engine) now supports the utf8_unicode_ci and utf8mb4_unicode_ci character sets and collations for index columns.

• Added a node offloading feature for the full refresh of a full refresh for materialized view. You can now distribute refresh tasks to specific nodes based on cost to isolate resource impact.

• Hybrid partitioned tables now support the columnar index (IMCI) feature. You can now manage columnar indexes on hybrid partitioned tables with combinations like InnoDB+X-Engine, InnoDB+ORC, and InnoDB+CSV by using the ALTER TABLE COMMENT statement. This allows you to use IMCI to accelerate analytical queries on these tables.

• The Overview feature now supports the DATETIME data type. In addition to TIMESTAMP, you can now use columns of the DATETIME type to define automatic data expiration policies to meet a wider range of business scenarios.

• Added support for Lua scripts in Orca (Redis-compatible) mode. Commands such as EVAL, EVALRO, and SCRIPTS are now supported.

• Added an incremental build feature for vector index. This feature allows indexes to be updated in real time as data is written, significantly improving the efficiency of ingesting and updating large volumes of vector data.

• Added a feature to eliminate redundant GROUP BY and ORDER BY clauses. This improves the performance of specific SQL queries by simplifying or removing redundant calculations.

Description

• Optimized physical replication efficiency by enabling parallel Redo log parsing on read-only nodes to reduce primary-replica lag.

• Optimized the restart time for columnar index (IMCI). The Non-Clustered Index (NCI) module was updated to support the Checkpoint mechanism, which eliminates the step of fully rebuilding NCIs during the NCI loading phase.

• Optimized the metadata management mechanism of X-Engine (High-Compression Engine). Periodic release of the manifest log and old versions of the manifest checkpoint prevents extra storage consumption caused by the continuous growth of metadata files.

• Optimized the performance of partitioned vector retrieval for columnar index (IMCI). This optimization reuses distances calculated during the vector index search phase in the multi-way merge to avoid redundant calculations. Also fixed an issue where a condition pushdown for a columnar index (IMCI) could return incorrect results in ORDER BY LIMIT scenarios.

• Optimized the query performance of columnar index (IMCI) for queries where the condition contains an IN-list with very long string values.

• Optimized the query plan search process to accelerate the search for the join order of multiple tables, which reduces the overall optimization time for complex SQL queries.

• Optimized the execution efficiency of grouped aggregation (HashGroupby). A vectorized hash table probing operation was introduced to improve grouped aggregation performance while slightly reducing memory consumption during computation.

• Removed the limit on the number of partitions for a table.

• Optimized the query execution strategy for columnar index (IMCI) by enabling adaptive grouped aggregation by default. This feature automatically selects the most efficient aggregation algorithm based on data distribution and query characteristics, improving the performance of analytical queries that contain a GROUP BY clause.

• Optimized the execution efficiency of the Hash Join operator in columnar index (IMCI). This optimization improves performance for all queries that use Hash Join, with significant improvements for Semi Join scenarios.

• Optimized the performance of the distributed memory pool by adding relevant parameters and monitoring items.

Description

• Fixed a crash that could occur in specific scenarios when a filter condition containing a trigger field was pushed down to a derived table.

• Fixed an issue where condition pushdown optimization was ineffective because a variable assignment function was present in the query.

• Fixed a crash that could occur with a global secondary index (GSI) in specific LIMIT OFFSET pushdown optimization scenarios.

• Fixed a stability issue that could be triggered by improper internal metadata handling during the upgrade process for certain partitioned tables.

• Fixed an issue where executing DML operations on a hybrid partitioned table that contains OSS partitions could block concurrent reads and writes.

• Fixed an issue in columnar index (IMCI) where the high-performance Hash Join operator could cause a loss of rows in the result set when processing a RIGHT JOIN with data spilled to disk.

• Fixed a rare issue where replication could get stuck in a columnar index (IMCI) in scenarios with frequent DDL operations, leading to data latency on the node.

• Fixed an issue where statistics could not be collected as expected for string columns with wide character sets (such as utf8), even if the defined length was short.

• Fixed a crash that could occur in a Multi-primary Cluster (Limitless) when executing DDL operations related to a global secondary index (GSI), due to conflicts with background threads.

• Fixed an issue in the Orca (Redis-compatible) mode where data table metadata might not be updated in a timely manner.

• Fixed a potential SQL parsing error that could occur when using dbms_outln.add_optimizer_outline_sharding to create a Statement Outline for sharded tables.

• Fixed an issue where PCUs for a low-specification, no-load serverless node with columnar index (IMCI) would repeatedly scale up and down.

• Fixed a potential out-of-memory (OOM) issue in the serverless feature for columnar index (IMCI) that could occur when resources were rapidly scaled up and then scaled back down, because the cache quota was not reclaimed in a timely manner.

• Fixed a crash caused by incorrect cost estimation for a large number of constant tables in Elastic Parallel Query.

• Fixed a crash that could occur when defining a partition range for an Interval partitioned table if a time type was specified.

• Fixed an issue where a columnar index (IMCI) could not execute SQL statements that contained a system variable in the query condition.

• Fixed an issue where statistics collection could fail on tables with frequent updates and deletions, and also slightly improved sampling efficiency.

• Fixed an issue where memory usage could continuously increase if a DDL operation was performed during incremental log application.

• Fixed an issue where a table could not be opened for an Index Merge plan when the query did not need to access the OSS partitions of a hybrid partitioned table.

• Fixed a stability issue that could cause a crash when the buffer pool was much smaller than the intermediate result set required by a query.

Description

The Orca (Redis protocol-compatible) restore command now preserves the TTL when restoring an expired hash field.

Description

• Added support for condition pushdown to a derived table that contains a UNION clause.

• Introduced a cost-based OR-expansion query rewrite that intelligently converts OR or IN expressions into UNION ALL, improving performance in specific scenarios through better index utilization.

• Added online DDL support for vector indexes, enabling you to create, drop, modify, and rebuild them without changing the IMCI status.

• Transparent Data Encryption (TDE) supports the SM4 algorithm for enhanced data encryption.

• Global read-only column-store nodes support partitioned tables in a multi-primary cluster.

• Added adaptive execution optimization for vector retrieval, which dynamically selects an execution mode (prefilter, postfilter, or inline filter).

• Added the snapshot update feature, a PostgreSQL-compatible update mechanism that optimizes UPDATE performance in specific scenarios. This feature is controlled by the innodb_polar_use_snapshot_update parameter and can be enabled at the session or global level.

• IMCI supports a full-text index to improve fuzzy text search and analytics performance.

• DLM supports archiving partitioned tables with an IMCI to an OSS external table, ensuring compatibility between the two features.

• Added monitoring metrics for Orca (Redis-compatible) to enhance its observability, including active connections, new connections, memory usage, and the number of pending tasks.

Description

• Optimized the Page Apply efficiency in physical replication. This reduces I/O overhead when read-only nodes access cold data, minimizing sporadic latency jitter and enhancing cluster stability.

• Optimized the predicate deduction (deduce_predicates) logic in the query optimizer to more effectively identify static conditions on partition keys, enabling more aggressive partition pruning and improving query efficiency.

Description

• Fixed an issue where executing a DDL operation such as RENAME TABLE on a table with a view after a High Availability (HA) failover could result in a Duplicate entry error.

• Fixed an issue where database and table recovery failed to restore a table if its backup contained a column dropped by using instant drop column.

• Fixed an issue in a multi-primary cluster where deleting a read-write node was interrupted after an access point switchover.

• Fixed an issue where adding or dropping a partition on an X-Engine partitioned table required a table-level metadata lock (MDL).

• Fixed an issue in Orca where writing immediately after deleting a key could cause inaccurate dbsize statistics.

• Fixed an issue where connections could hang after a DDL operation completed if you dynamically disabled the thread pool by using the loose_thread_pool_enabled parameter.

• Fixed an issue where IMCI did not support JSON TABLE when using the ETL feature, and clarified the error message for insufficient memory during IMCI queries.

• Fixed an issue that could prevent a query from running on an IMCI if the SELECT statement contained both an IN list and an aggregate function with DISTINCT.

• Fixed an issue in IMCI that could cause inaccurate multiplication results when processing DECIMAL data with more than 16 digits after the decimal point.

• Fixed an issue with the IMCI Serverless feature where proactive scale-out was continuously triggered due to an abnormal index status.

• Fixed an issue where a standby node could hang during the recovery phase in Point-in-Time Recovery (PITR) and database and table recovery scenarios.

• Fixed an issue that could cause existing Binlog dump connections to hang and affect Binlog cleanup after a read-only node was promoted to the primary node.

• Fixed an issue where the reported delay in seconds (delay_second) for a standby node was inaccurate when you ran the SHOW POLAR STANDBYS command on a read-write node.

• Fixed an issue where the query optimizer's column pruning feature could cause the process to crash by incorrectly removing a subquery that was referenced by multiple projection columns.

• Fixed an issue where inaccurate statistics for non-BIGINT integer columns prevented the query optimizer from generating an optimal execution plan.

• Fixed an issue where querying JSON data of a specific length returned the The JSON binary value contains invalid data error on a read-only node when the innodb_blob_slave_read_consistent parameter was enabled.

• Fixed an issue that could prevent queries containing a recursive Common Table Expression (CTE) from running on an IMCI.

• Fixed an issue where a newly registered read-only node could report an SDI modification failure when executing DDL operations after being promoted to the primary node.

Description

Added a dynamic toggle to enable cursor position adjustment for read-only nodes at runtime.

Description

Fixed a potential cluster crash during failover under high-concurrency write workloads when no initialization extensions were enabled.

Description

Fixed an issue when using the Hybrid Plan to accelerate wide table queries with an In-Memory Column Index (IMCI), where a query optimization (converting the AVG function to SUM/COUNT) caused an unexpected fallback to row-store execution.

Description

• Added an option to configure whether to display the display width attribute for integer fields (such as BIGINT, INT, MEDIUMINT, SMALLINT, and TINYINT) when the ZEROFILL attribute is not defined.

• Introduced concurrency management and status queries for background vector index creation in IMCI. This enables effective resource control and real-time progress tracking when creating large-scale vector indexes.

• Added the CXL memory extension feature, which uses a Compute Express Link (CXL) memory pool to dynamically increase a cluster's buffer pool capacity, improving large-scale data processing performance and system throughput.

• Added two FAISS-based vector index types to IMCI: HNSW and HNSWPQ. These index types support high-performance, low-memory approximate nearest neighbor (ANN) searches for high-dimensional vectors.

• Introduced an inline filter mode for vector retrieval in IMCI, which fuses scalar filtering and vector retrieval into a single computational operator.

• Added support for Oracle-compatible synonyms (SYNONYM). You can now create synonyms for tables or views and operate on them directly.

• Expanded the subpartitioning feature to support RANGE COLUMNS, LIST COLUMNS, and LIST COLUMNS+DEFAULT partition types, as well as various subpartition key columns such as DATE, DATETIME, and CHAR. A partitioned table now supports any combination of all first-level and second-level partition types, and applies partition pruning optimization to relevant queries.

• Added support for full materialized views with IMCI-accelerated refreshes. This provides pre-computed result sets for complex queries, significantly improving the response time for frequent aggregation or join queries.

• Added the embedding expression to convert input text into vectors in real time. You can also use materialized virtual columns to automatically convert text to vectors and store them when data is inserted.

• Added alias support for the INSERT ... VALUES/SET ... ON DUPLICATE KEY UPDATE syntax. You can now reference the new data from the INSERT part by its alias in the UPDATE clause, which makes the SQL logic clearer and more concise.

• Expanded the automatic cold data archiving feature to support archiving cold data partitions from a partitioned table to the X-Engine storage engine. After archiving, the table becomes a hybrid partitioned table of InnoDB and X-Engine, supporting unified queries across partitions of different storage engines.

• Added a forced forwarding feature for sessions that use an isolation level other than Read Uncommitted (RU) on non-IMCI nodes. Enabling the imci_ignore_unsupported_isolation_level parameter forwards requests from these sessions to column store nodes, allowing them to use IMCI acceleration.

• Added the json_arrayagg expression, which aggregates multi-row results into a JSON array in IMCI queries to enhance the processing capabilities for JSON-formatted data.

• Integrated Resource Control with the Orca feature (Redis-compatible). This allows you to manage the overall CPU resource utilization of the Orca system by using a parameter, which defaults to 100%.

• Added support for PUBSUB commands to the Orca feature (Redis-compatible), including PUBLISH, SUBSCRIBE, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, PUBSUB CHANNELS, PUBSUB NUMPAT, and PUBSUB NUMSUB, to expand its message publishing and subscription capabilities.

• The SQL Trace feature now supports sampling and recording actual SQL statements into shared SQL. This helps database administrators to accurately troubleshoot and optimize ultra-long or high-frequency slow queries.

• Added the rds_max_tmp_disk_space parameter to control the total local disk space used by temporary tables from large queries, preventing the disk from filling up.

• Added support for dbms_oss.delete_table_file to clean up the corresponding OSS files of a partitioned table after the table is deleted.

• The Data Cleanup (TTL) feature now supports COPY-like DDL syntax. Previously, only INPLACE-like DDL was supported.

Description

• Optimized the cost estimation model for the HTAP automatic request distribution solution. The model can now perform calculations based on serial execution overhead instead of relying on the cost after parallel optimization, allowing for better execution plan choices in specific scenarios.

• Added a feature to measure the time consumed by internal operations of row-store and column-store execution operators. This data supports coefficient fitting and automatic optimization of the row-column cost model.

• The Statement Outline feature can now record the original SQL statement. This allows you to regenerate an Outline based on the original SQL in the current environment, which improves the flexibility of execution plan management and pinning.

• Refactored the command processing structure and optimized the lock path of Orca (Redis-compatible), improving its overall read and write performance by approximately 10%.

• Optimized query performance for partitioned tables. Fixed an issue where secondary partition pruning was not triggered by new constant conditions for partition keys generated during the query optimization phase (such as MEP). This update also enables partition pruning for the inner tables of nested outer join operations.

• Optimized the processing logic for union queries with a large number of query blocks, resolving an issue where the find_cloned_select_lex function consumed excessive time and fully loaded a single CPU core.

• Optimized the metadata loading process when a column store node restarts in large-scale data scenarios. This prevents out-of-memory (OOM) issues caused by an overly long metadata list.

• Unified the naming convention for local files related to IMCI. The naming no longer varies by node role, which simplifies file management during a high-availability switchover.

• Optimized the logic for the background elastic thread pool of a read-only column store node when it obtains task status, reducing its CPU resource consumption.

Description

• Fixed an issue where a parallel query could cause a cluster to crash in specific condition pushdown scenarios.

• Fixed an issue where data inconsistency could occur on a read-only node in some scenarios when reading large JSON fields or frequently partially updated JSON fields.

• Fixed an issue where the Non-Clustered Index (NCI) of IMCI failed to automatically trigger an expansion when an insertion into the lru cache failed.

• Fixed abnormal storage space growth caused by vector index data files not being cleaned up promptly.

• Fixed a memory error that occurred during the row-store execution phase of aggregate function queries. The error was caused by an incorrect initialization of the dec_buffs member in the Item_sum_sum::resolve_type function.

• Fixed issues in IMCI where vector retrieval queries could incorrectly fall back to row-store execution and where the query optimizer made poor cost-based choices for scalar filter queries.

• Fixed an issue with listing OSS files using the dbms_oss.list_table_file command.

• Fixed an out-of-memory (OOM) issue on read/write (RW) nodes when performing an ONLINE DDL operation on a table with an IMCI. This was caused by the default batch write behavior.

• Fixed a cluster crash that could occur during a DDL operation on an ORC hybrid partitioned table with an IMCI if the table name contained special characters.

• Fixed an issue where a read-only node might not find some records during B-tree index structure adjustments under high write pressure.

• Fixed an issue where a cluster could become unstable when adding an IMCI to a table that has no primary key but has a UNIQUE KEY.

• Lowered the permission requirements for archiving partitioned table data to an OSS external table by using dbms_dlm.archive_partition2table. Now, only INSERT, CREATE, DROP, and ALTER permissions are required.

• Fixed a cluster crash in Orca (Redis-compatible) that occurred when the LPOS command was used and the value of the MAXLEN option exceeded the length of the list.

• Fixed a memory leak that could occur when reading data from a cold storage table in ORC format.

• Fixed an issue where some queries failed and returned an OOM Error due to inaccurate memory usage calculation.

• Fixed an issue where query performance could degrade in Multi-master Cluster (Limitless) Edition under high pressure.

• Fixed an issue where constant condition propagation failed during query optimization due to inconsistent character set lengths.

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

• Fixed an issue where a cluster could crash during a high-availability switchover between primary and replica nodes in a Multi-master Cluster (Limitless) Edition.

• Fixed an issue where an IMCI query could return incorrect results if it contained both the DISTINCT and AVG aggregate functions.

• Fixed a cluster crash caused by the result_field of Item_func_conv_charset not being cleared after a SQL statement ended, which led to an error on reuse.

• Fixed an issue in a Multi-master Cluster (Limitless) Edition where a read/write (RW) node could crash if a DML operation was performed on an IMCI table after a local read-only node was hot-swapped to an RW node.

• Fixed an issue caused by dangling pointer access when an index was released during an INSTANT DDL operation on an IMCI.

• Fixed an issue where a parallel query could cause a cluster to crash in scenarios with multi-level nested derived tables.

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

• Fixed an issue where the adaptive execution plan switching (adaptive ordering) optimization could not correctly adapt to LIMIT OFFSET statements.

• Fixed a sorting error that could occur when using ORDER BY DISTANCE for vector similarity sorting with distance values close to 0.

• Fixed an issue in Elastic Parallel Query where cross-node MPP execution could cause incorrect results or a cluster crash when multi-level nested shared subqueries were present.

• Fixed an issue where column pruning optimization could cause a cluster to crash when a query contained a recursive Common Table Expression (CTE).

• Fixed an issue where the Query Cache could access invalid memory under multi-threaded concurrent access.

• Fixed an issue in Orca (Redis-compatible) where a cluster could crash when setting an expiration time on a hash (Hash) that contained duplicate fields.

• Fixed an issue in a Multi-master Cluster (Limitless) Edition where the cluster might fail to start or data could not be persisted after a high-availability switchover.

• Fixed an issue where duplicate data could be retrieved when accessing a spatial index on a read-only node.

• Fixed an issue where the execution results of the IMCI json_valid function could be inconsistent between the row store and column store when the first parameter is of the varchar type.

• Fixed an issue where duplicate data appeared in the result set after an EXISTS subquery was converted to a SEMI JOIN (with the duplicate weedout strategy) when parallel query was enabled.

• Fixed an issue in the IMCI shared storage architecture where the column index of a cold storage table on a read-only column store node could be missing.

• Fixed an issue where a cluster could occasionally crash after adaptive aggregation was enabled in queries from older versions.

• Removed unnecessary checks for compressed row status in the code to avoid triggering unexpected errors in special cases.

• Fixed an issue where a read-only column store node could experience replication latency in scenarios with frequent DDL operations.

Description

• Fixed an issue in the In-Memory Column Index (IMCI) feature where a node could crash when the deltastore executes a swap task, due to the pax page length overflowing uint32 or encountering a null pointer.

• Fixed an issue where an improper initialization order of global variables unexpectedly disabled one-write, multiple-read Follower file operations for In-Memory Column Index (IMCI).

• Fixed a rare bug that could cause the background purge process to corrupt a secondary index during a transaction rollback.

Description

• Optimized memory and storage usage of vector indexes in IMCI.

• Optimized window function execution in IMCI by merging window functions that share the same PARTITION BY definition.

Description

• Fixed a potential crash during cost-based query rewrite for SQL statements that contain both an inline view and a scalar subquery.

• Fixed an occasional index join error in Hybrid Plan mode that occurred when IMCI queried partitioned tables.

• Fixed an issue that prevented some statements in prepare statement mode from being correctly routed to column store nodes.

• Fixed a cluster crash caused by a null pointer access, which occurred when the IMCI Delta module missed a check for rolled-back rows during serialization.

• Fixed an issue that prevented some queries from being pushed down to the columnstore index when the imci_implicit_orderby_rollup parameter was enabled.

• Fixed an issue that prevented queries with overly long IN-LISTs from using the columnstore index.

Description

• Added column encryption, which works with TDE to encrypt specified columns for storage. When you access the data, you can use a decryption function to retrieve the raw data.

• Added a feature that deconstructs query expressions with multi-value conditions (IN-LIST) or logical disjunctions (OR) into a UNION ALL operation of multiple independent subqueries to generate index access plans more efficiently.

• The DELETE statement now supports index hints, enabling you to use the USE INDEX and IGNORE INDEX syntax to specify a particular index. You can enable this feature by using the delete_enable_index_hint parameter.

• Lateral derived tables now support parallel execution and can be pushed down to workers in parallel query scenarios.

• IMCI now supports subqueries that use ROLLUP and include aggregate functions in the projection columns.

• IMCI now includes the vector index feature, which supports approximate nearest neighbor (ANN) search.

Description

• Improved the asynchronous operation and flow control for garbage file cleanup after a read-only IMCI node is deleted.

• Removed the restriction that at least one InnoDB partition must be retained when you use ALTER TABLE for cold data archiving. This allows all partitions to be archived. You can now use REORGANIZE PARTITION to restore OSS partitions of a fully archived partitioned table back to InnoDB partitions.

• Optimized the process of building hash tables and their implementation for IMCI HASH JOIN, which significantly improves the performance of IMCI HASH JOIN.

Description

• Fixed a crash that occurred in a parallel query if a constant table was an outer table in a LEFT JOIN with multiple inner tables.

• Fixed an issue where the SCAN command of the Orca feature could fail to return a result, remaining in a searching state.

• Fixed an issue where Sharding Outline did not correctly support table aliases, ORDER BY, and LIMIT BY.

• Fixed a crash caused by the base table and the dependent table not being pushed down to the same shard for execution when a default value references a table.

• Fixed an issue where adding an index to a table with a SET type required a table lock.

• Fixed a cluster crash triggered when you update a NULL value to an empty string in a table that uses the REDUNDANT row format and contains an instant-add column.

• Fixed an issue with the return value of the DISTANCE expression when calculating DOT similarity in IMCI.

• Fixed an error that occurred when a cold-archived ORC-format table contained BIT, ENUM, or SET types.

• Fixed an issue where statistics for adaptive execution were biased in plans that use INDEX MERGE and Index Condition Pushdown (ICP).

• Fixed an issue where reading JSON data on a read-only (RO) node could return an INVALID JSON error in some scenarios.

• Fixed a crash caused by an ORDER BY clause being merged into the outer query in a materialized view.

• Fixed an issue where disabling function pushdown caused incorrect results for Elastic Parallel Query.

• Fixed two issues in Data Lifecycle Management (DLM): an archiving exception that left residual temporary tables, for which error logging is now added; and an ASSERT crash caused by an X lock conflict during the second lock upgrade in the DLM partition metadata lock (MDL) archiving process.

• Fixed an issue where after a partitioned table was renamed by using a RENAME DDL statement, the table_name cache in the INFORMATION_SCHEMA table for IMCI was not updated.

• Fixed an issue in the prepare execute implementation where the collation of string types was incorrectly affected by the character_set_client setting.

• Fixed an assertion error that was triggered by an update task based on old IMCI information after an INSTANT DDL statement was committed.

• Fixed a crash that occurred in high-concurrency scenarios when both Elastic Parallel Query and performance_schema were enabled.

• Fixed an issue where the MySQL Community Edition did not include the LIMIT keyword in query performance cost calculations.

• Fixed an occasional inaccurate timing issue when profiling IMCI queries by using imci_analyze_query.

• Fixed an issue where unsupported user-defined functions were adaptively routed to IMCI, which caused query errors.

• Fixed a crash in the background thread that collects IMCI statistics for the hybrid optimizer. This bug had a higher probability of being triggered when a virtual column was present.

• Fixed an issue that could occur when accessing a partitioned table after it was restored by using the database and table restoration feature, if the table included an INSTANT ADD COLUMN and had 10 or more partitions.

• Fixed an out-of-memory error that could occur in IMCI when a GROUP BY operation was performed on variable-length strings with a large amount of data.

• Fixed an issue where the show binlog events command failed on a read-only node with a "file does not exist" error.

• Fixed an issue in IMCI where queries occasionally could not use a Hybrid Plan after global consistency (high-performance mode) was enabled.

• Fixed a memory leak in the IMCI internal thread pool caused by elastic scale-in, which occurred when the PCU of a serverless cluster was adjusted.

• Fixed an issue in IMCI where a DROP INDEX operation during the loading of a Non-Clustered Index (NCI) could block the loading process.

• Fixed an issue where a crash occurred before the DDL log for a partition swap was written. This issue caused the cluster's crash recovery process to skip the DDL log, resulting in a cluster anomaly.

• Fixed an issue in parallel query scenarios for partitioned tables where the degree of parallelism for a parallel plan involving a PartitionWise Repartition exceeded max_parallel_degree.

Description

• Fixed a crash in IMCI Hybrid Plans that occurred when using an index join with an anti semi join and a post filter.

• Fixed a system crash during online DDL operations. This crash was caused by data inconsistency when updating or deleting data with a dynamic mask.

• Fixed a crash during data cleanup (TTL) that was caused by a deadlock triggering a transaction rollback.

• Fixed a potential crash during shutdown that occurred when a data cleanup (TTL) thread failed to release a transaction object.

• Fixed an Out of Memory (OOM) error that occurred during IMCI sort compaction.

Description

Fixed a memory leak in IMCI caused by the elastic scale-in of the internal thread pool during the dynamic adjustment of the PolarDB Capacity Unit (PCU) for a serverless cluster.

Description

• Added memory reclamation for the parse buffer (parse buf) on serverless read-only (RO) nodes to reduce memory usage.

• Window functions now support the frame clause, including the Rows frame and the default Range frame.

• You can now use online DDL to modify auto-increment column values in X-Engine.

• Added pruner statistics. You can now query the INFORMATION_SCHEMA.IMCI_SQL_PROFILING view to check the data block pruning status for the TableScan operator.

• You can now use hints to influence the execution plan of statements within a view definition.

• You can now query the INFORMATION_SCHEMA.POLAR_INDEX_STATISTICS view to retrieve index hit statistics for each table.

• Added the FORCE STORAGE OSS option to synchronously delete data from OSS during a delete cold data operation.

• Introduced the Range-prefix Skip Scan mechanism to expand the applicability of Skip Scan and improve the performance of complex queries.

• The Hybrid Plan feature in IMCI now supports tables that do not have an explicitly defined primary key.

• Added the adaptive_digest_length_multiplier parameter to dynamically adjust the pre-allocated memory size for the Digest based on the length of the SQL text.

• Added the oss_orc_read_buffer_size parameter to dynamically configure the read buffer size for ORCReader.

• Added the Innodb_ttl_finished_job_expired_days parameter to control the cleanup of expired data in the ttl_job_history table.

• In IMCI, the Index Join in a Hybrid Plan now supports Semi Join and Anti Semi Join modes.

Description

• Improved the performance of IN-list queries on IMCI.

• Resolved performance degradation when using the max_execution_time parameter under high-concurrency workloads.

• Orca (Redis-compatible) now supports setting a TTL for individual fields within a HASH data type.

• Adjusted the scope of high-performance global consistency variables from the system level to the connection level, allowing them to be configured in the database proxy.

• Optimized the Hash Groupby mechanism in IMCI to adaptively select partitioning strategies and algorithms based on data distribution, improving query performance.

Description

• Fixed an issue where the ALTER TABLE command could fail and cause a database restart.

• Fixed an issue with the snapshot feature on column store nodes that could cause monitoring to freeze due to long lock waits.

• Fixed a deadlock caused by concurrent threads while archiving partition data in a partitioned table.

• Fixed an issue where a parallel query with an IS NULL condition could return incorrect results.

• Fixed an issue where the adaptive selection of ordered indexes feature could cause a cluster to crash in certain query scenarios.

• Fixed a rare issue where memory blocks accumulated on an ImciFollower in a multi-node shared architecture of IMCI.

• Fixed an issue where executing a DROP PARTITION statement could cause a crash if an SQL statement held a table-level metadata lock (MDL) but not a partition-level one.

• Fixed an issue in X-Engine (High-Compression Engine) where the Index_merge path failed to correctly obtain Instant_ddl metadata, which caused data query exceptions.

• Fixed an issue where the Mixoutput of hybrid materialization in IMCI failed to perform time zone conversion when reading timestamp data.

• Fixed an issue where a column store node occasionally accessed pre-DDL cached data after a DDL operation.

• Fixed an out-of-bounds memory access issue when performing an instant modify column operation on a table with a large number of columns.

• Fixed a crash that could occur when the thread_pool_size parameter was dynamically modified while the asynchronous execution feature was enabled.

• Fixed an occasional out-of-bounds read/write issue with ROW LOG when performing an ONLINE DDL operation on a table with a virtual column.

• Fixed string-to-vector type conversion issues by allowing the use of multiple whitespace characters.

• Fixed an issue that prevented an IMCI serverless cluster from scaling in when its primary node was large.

• Fixed an issue in IMCI where the imci_implicit_orderby_rollup switch failed to control result sorting for queries using ROLLUP.

• Fixed an issue that could cause the database to crash if a SQL query included a GROUP BY WITH ROLLUP clause, the GROUP BY column referenced a column in a derived table, and the optimizer flattened that derived table.

• Fixed an issue that prevented a new read/write node from starting when added to a multi-master cluster with a global read-only node.

• Fixed a potential crash on a secondary node in a multi-master cluster when switching the database or object endpoint.

• Fixed an issue that prevented dynamic modification of the innodb_log_buffer_size parameter after the innodb_polar_log_rdma_transfer parameter was dynamically disabled.

• Fixed an issue that prevented queries containing a correlated subquery with LIMIT 1 from executing on IMCI.

• Fixed a potential corruption issue with a secondary index created on a virtual column.

Description

• Added an automatic collection feature for column statistics to keep them up to date.

• Added a cost threshold parameter to dynamically control adaptive request distribution between row and column stores. This parameter is distinct from the general cost distribution threshold.

• Added support for range expressions in RANGE partitioned tables. The new cast_for_range() function converts double data to the int type, enabling support for partition key fields of the double type.

• PolarDB for MySQL supports asynchronous execution, including asynchronous handling of lock waits and log flushes.

• Orca provides comprehensive connection monitoring metrics, including total connections, current active connections, and current requests.

• Added support for calling Outline with the explain analyze statement, aligning its functionality with the explain statement and improving query optimization.

• Added support for the following GIS-related functions: ST_HAUSDORFFDISTANCE, ST_FRECHETDISTANCE, ST_LineInterpolatePoints, ST_LineInterpolatePoint, ST_PointAtDistance, ST_Union, ST_Difference, ST_Buffer, ST_Collect, ST_Symdifference, and ST_Intersection.

• Added the In-Memory Column Index (IMCI) query priority scheduling feature, which allows you to assign priorities to IMCI queries to optimize query execution efficiency.

• The Data Cleanup (TTL) feature is compatible with other products such as TiDB and supports the TTL = 'b' + INTERVAL 3 MONTH; syntax.

Description

• Optimized the partition cost model. For equality and IN condition queries on indexes that do not contain a partition key, a partition count factor is included in the cost estimation to improve its accuracy.

• Optimized the algorithm selection logic to allow some correlated subqueries to use an efficient hash join.

• Improved how the IMCI optimizer handles complex IN and EXISTS subqueries, significantly enhancing query efficiency and execution performance.

• Multi-master Cluster (Limitless) Edition supports Partition Redo and asynchronous Redo mechanisms, increasing system throughput in gaming scenarios to better handle high-concurrency demands.

• Optimized the logic in Orca for processing the Redis SCAN command with the COUNT option to ensure the number of returned elements is accurate and consistent.

• Enhanced support in IMCI for SELECT DISTINCT ... statements to allow for non-full-groupby cases, improving compatibility and query flexibility.

• Optimized the logic for multi-level nested IN subqueries, so that they can now be accelerated by the columnstore index.

Description

• Fixed an illegal memory access issue that could occur when executing an INSERT ON DUPLICATE KEY UPDATE statement on an interval range partition.

• Fixed an incompatibility with the database and table restoration feature that occurred because the loose_innodb_initialize_in_space_extend parameter for file space extension could not be set to 0.

• Fixed a limitation where the Hybrid Plan in IMCI did not support Semi Join and Anti Semi Join modes in its Index Join mechanism.

• Fixed a system crash that could occur when using the TempTable engine with a common table expression (CTE) that is referenced multiple times.

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

• Fixed an issue where a read-only node did not sync the gtid_purged variable, which caused queries to return empty values.

• Fixed an issue where a database and table restoration task could be interrupted if the source table had a columnstore index.

• Fixed a crash that could occur when disabling Hybrid Plan in IMCI while it was running.

• Fixed a potential socket leak in the Orca network framework when a connection timed out or was actively closed.

• Fixed a rare issue where, with the non-blocking DDL feature enabled, a statement failed to exit normally if its corresponding DDL connection was terminated.

• Fixed an inefficiency in the data lifecycle management (DLM) partition archiving process by using a partition-level metadata lock (MDL) instead of a table-level one, which reduces lock granularity and improves system concurrency and archiving efficiency.

• Fixed inaccurate memory preemption under mixed workloads.

• Fixed an issue where an X-Engine partition required a table rebuild during an optimize operation.

• Fixed a parallel query cluster crash that was caused by a sort operation after a materialized table merge.

• Fixed a potential crash that occurred when the materialized table pruning feature was used with the WITH ROLLUP feature.

• Fixed a cluster crash that occurred when creating a temporary table with a CREATE TABLE AS SELECT statement.

• Fixed a potential cluster crash that could be triggered when accessing statistics tables in a Multi-master Cluster (Limitless) Edition.

• Fixed an issue where an incorrect index was selected for constant range filtering (const between field1 and field2) in IMCI queries.

• Fixed an issue in Multi-master Cluster (Limitless) Edition scenarios where the online DDL process for the columnstore index was incompatible with the Logical Log Sequence Number (LLSN) logic, causing some columnstore redo log replays to be missed.

• Fixed a tablespace leak in X-Engine that occurred when recycling old tablespaces after a DDL change.

• Fixed a crash that was caused by executing an explain for connection statement during a query on an IMCI partitioned table.

• Fixed an issue where IMCI data could not be recovered due to a metadata lock (MDL) acquisition failure during the metadata recovery phase.

• Fixed an issue where queries on IMCI I_S (IMCI-related views in the Information_Schema database) with a name filter condition returned incomplete results because the query did not use a case-sensitive string comparison function.

• Fixed an issue where a X-Engine read-only node unexpectedly cleared data block metadata on restart.

• Fixed a potential anomaly in the metadata lock (MDL) system when the number of connections exceeded 65,536.

Description

• Fixed a potential data redundancy issue in the column index that could occur during crash recovery if a column store node cluster restarted during a large transaction.

• Fixed a TTL syntax issue by changing TTL to a non-reserved keyword to ensure compatibility with the community version.

Description

Description

Fixed an issue where reading large JSON or GIS objects through IMCI would occasionally fail.