MySQL Forums
Forum List  »  Announcements

MySQL Community Server 8.0.24 has been released [ part 2/2 ]
Posted by: Bjørn Munch
Date: April 20, 2021 03:15AM

[ This is part 2 of the announcement ]

Bugs Fixed


     * Important Note: When a utf8mb3 collation was specified in
       a CREATE TABLE statement, SHOW CREATE TABLE, DEFAULT
       CHARSET, the values of system variables containing
       character set names, and the binary log all subsequently
       displayed the character set as utf8 which is becoming a
       synonym for utf8mb4. Now in such cases, utf8mb3 is shown
       instead, and CREATE TABLE raises the warning
       'collation_name' is a collation of the deprecated
       character set UTF8MB3. Please consider using UTF8MB4 with
       an appropriate collation instead. (Bug #27225287, Bug
       #32085357, Bug #32122844)
       References: See also: Bug #30624990.

     * InnoDB: Stale pages encountered by the buf_page_create()
       function were freed and then read from disk again without
       being reinitialized. (Bug #32622548)

     * InnoDB: C++ enum type values in buffer pool page and
       buffer pool block data structures in the InnoDB source
       code were changed from int to uint8_t in MySQL 8.0.23,
       causing the data to be printed as ascii characters
       instead of integers in different outputs including
       messages and INFORMATION_SCHEMA tables.
       The function that populates the INNODB_BUFFER_PAGE_LRU
       table did not print the IO_PIN state for the IO_FIX
       field. (Bug #32575469)

     * InnoDB: The btr_pcur_t::copy_stored_position function,
       which copies the position of one index tree persistent
       cursor to another, performed unnecessary free and malloc
       calls. (Bug #32574835)

     * InnoDB: A function that checks for locks on a table tried
       to acquire an exclusive lock system (lock_sys) latch,
       causing long semaphore waits. (Bug #32545030)

     * InnoDB: Counting temporary tablespaces as open files
       caused the innodb_open_files limit to be exceeded,
       preventing other files from being opened. Temporary
       tablespaces are now ignored when counting open files.
       (Bug #32541241)

     * InnoDB: The buf_flush_ready_for_flush() function
       identified a stale page as ready to flush without first
       checking if the page was dirty or I/O fixed, causing an
       assertion failure. (Bug #32530147)

     * InnoDB: Rollback of a transaction that modified generated
       columns raised an assertion failure. The failure occurred
       when attempting to free space occupied by externally
       stored columns. The update vector containing the
       externally stored columns did not account for the
       generated columns. (Bug #32529561)

     * InnoDB: When starting the server with
       innodb_validate_tablespace_paths disabled, user-created
       undo tablespaces, which are temporarily set to inactive
       during the initial stages of the startup process, were
       not reactivated. (Bug #32493885)

     * InnoDB: Disabling innodb_extend_and_initialize, which
       causes InnoDB to use fallocate() when allocating space to
       tablespace files, caused a performance regression for
       insert-oriented workloads. (Bug #32437020)

     * InnoDB: An unnecessary full flush list scan was removed,
       improving the speed with which session temporary
       tablespaces are created. Previously, depending on the
       size of the buffer pool and the number of dirty pages,
       creation of session temporary tablespaces could take a
       long time, affecting write transaction performance. (Bug
       #32423860)

     * InnoDB: A function that checks if a given page type is
       valid raised an assertion when testing valid but
       undefined page type for an undo tablespace. (Bug
       #32366301)

     * InnoDB: Sharded read-write lock function instrumentation
       was improved. (Bug #32333168)

     * InnoDB: On Windows, when creating a table with the
       COMPRESSION option, InnoDB failed to check the error
       status of a system call before checking the punch hole
       support flag set by the same system call, which resulted
       in reading an uninitialized flag. (Bug #32322645)

     * InnoDB: Geometry columns created in MySQL 5.6 caused
       failure when restarting the server after upgrading from
       MySQL 5.7 to MySQL 8.0 due to a geometry type change
       introduced in MySQL 5.7. (Bug #32299738)

     * InnoDB: During recovery, log records for multiple record
       group mini transactions were parsed twice. The log record
       from the first parsing operation is now saved to avoid
       the second pass, which improves recovery performance.
       Thanks to Zhai Weixiang for the contribution. (Bug
       #32293797, Bug #102010)

     * InnoDB: In debug builds, an end range condition check for
       a secondary index raised an assertion failure, and
       Valgrind testing uncovered an end range condition check
       for secondary index on a virtual column that read an
       uninitialized value. (Bug #32291506)

     * InnoDB: With the innodb_log_writer_threads variable
       disabled, extensive log writing by one thread could block
       log flushing opportunities for other threads. (Bug
       #32255538)

     * InnoDB: In SHOW ENGINE INNODB STATUS deadlock
       information, in cases where a single rw-lock reader
       thread holds a shared latch, the reader thread id was not
       printed. (Bug #32252477)

     * InnoDB: Running concurrent SHOW CREATE TABLE and ALTER
       TABLE operations on the same table raised an assertion
       failure. The SHOW CREATE TABLE thread referenced a
       tablespace object that had been made stale by the ALTER
       TABLE operation. (Bug #32235621)

     * InnoDB: The introduction of sharded rw_lock_stats
       counters in MySQL 5.7 caused a regression in CPU cache
       efficiency. To address this issue in MySQL 5.7, the
       sharding method was changed. For optimal performance, the
       rw_lock_stats counter is removed in MySQL 8.0. (Bug
       #32225367)

     * InnoDB: On Windows, stalls were caused by concurrent
       SELECT COUNT(*) queries from multiple client threads
       where the number of client threads exceeded the number of
       machine cores. (Bug #32224707, Bug #101789)

     * InnoDB: An IS_STALE column, which indicates whether a
       buffer pool page is stale, was added to the
       INFORMATION_SCHEMA.INNODB_BUFFER_PAGE table. (Bug
       #32194434)

     * InnoDB: In debug builds, the log_free_check() function in
       the redo log code, which ensures that there is available
       space in the logs when holding latches on dirty pages,
       now uses a list of mini-transactions opened by the
       current thread to search for potential constraint
       violations. (Bug #32189367)

     * InnoDB: During a slow shutdown on a system with a 64k
       InnoDB page size and innodb_max_undo_log_size setting
       that was less than the initial undo tablespace size, the
       two undo tablespaces were truncated in an endless loop.
       Undo tablespace truncation is now restricted to undo
       tablespaces that are larger than the initial undo
       tablespace size and the innodb_max_undo_log_size setting.
       The function that retrieves the next redo rollback
       segment for an undo tablespace was modified to ensure
       that undo logs are evenly split between two active undo
       tablespaces when an inactive tablespace is found. (Bug
       #32173457)

     * InnoDB: Starting the server in upgrade mode following an
       unexpected stoppage while the undo_001 undo tablespace
       was being truncated caused failure. When upgrade
       processing was completed and shutdown initiated, the
       function that determines if undo truncation is required
       could not find the undo_001 undo tablespace. To address
       this issue, undo tablespace truncation is no longer
       performed when starting the server in upgrade mode. (Bug
       #32127912)

     * InnoDB: A delete operation on a parent table that
       initiated a cascading update on a child table with an
       indexed virtual column and indexed foreign key constraint
       column caused a virtual column corruption. (Bug
       #32124113)

     * InnoDB: The open and close sequence for table share
       instances (m_share objects) and dictionary table
       instances was modified to prevent accessing old m_share
       objects that could point to stale dictionary indexes.
       Thanks to Yuxiang Jiang for the contribution. (Bug
       #31899685)

     * InnoDB: An debug assertion failure occurred when issuing
       a TRUNCATE TABLE operation after a successful server
       restart following a server initialization failure. (Bug
       #31763837)

     * InnoDB: A fast shutdown (innodb_fast_shutdown=0) raised
       an assertion failure. The assertion code checks for
       transactions in the transaction list (mysql_trx_list)
       before halting purge operations. The check occurred
       before shutting down the GTID persister background
       thread, which was still inserting transactions into the
       transaction list. (Bug #31693627)

     * InnoDB: Undo tablespace truncation error handling was
       improved, and a Windows-specific InnoDB file deletion
       procedure was made more POSIX-compatible. (Bug #31684783)

     * InnoDB: Initializing the server with an with a 4K InnoDB
       page size caused "key too long" errors to be written to
       the error log. (Bug #31496943, Bug #99892)

     * InnoDB: Creating an index on virtual columns raised an
       invalid debug assertion failure. (Bug #31279528, Bug
       #99421)

     * InnoDB: In debug mode, the buf_pool_validate_instance()
       function accessed the buf_page_t::io_fix field without
       properly synchronizing with a thread that was modifying
       the same field in the buf_page_io_complete() function,
       causing an assertion failure. In addition to correcting
       that issue, the buf_page_get_io_fix_unlocked() function
       was replaced by several specific functions that test the
       buf_page_t::io_fix field for particular values. A series
       of other small, related code changes were also
       implemented. (Bug #31027553)

     * InnoDB: The TempTable memory allocator did not track RAM
       consumption when allocating blocks of memory shared by
       different queries for a given session, which could result
       in nonadherence to the temptable_max_ram limit. (Bug
       #29890126)

     * Partitioning: In some cases, invalid PARTITION clauses
       were not handled correctly in ALTER TABLE statements.
       (Bug #32235085)

     * Replication: Binary log transaction compression could not
       continue if a row event included a BLOB column containing
       uncompressable data, and the compressed size of the row
       event was higher than its uncompressed size. The function
       now handles the additional post-compression bytes
       correctly. (Bug #32174715, Bug #101611)

     * Replication: If all previous binary log files were purged
       at startup because their retention period had expired,
       the new binary log file contained an empty Previous_gtids
       event, which could cause errors in replication. The order
       of initialization has now been changed so that previous
       binary log files are only purged after the previous GTID
       set has been written to the new binary log file that is
       created at startup. (Bug #32134875, Bug #101533)

     * Replication: When MySQL Server counted the number of
       GTIDs in a set, it was possible for the return value to
       wrap, returning an incorrect result. This could lead to
       an incorrect decision to use state transfer from the
       binary log for Group Replication's distributed recovery,
       when a remote cloning operation would have been more
       efficient. The logic has now been corrected. (Bug
       #32086209)

     * Replication: An assertion was raised in debug builds
       relating to lost GTIDs if binary log files were removed
       at startup because their retention period had expired.
       (Bug #32008512, Bug #101137)

     * Replication: The sql_slave_skip_counter system variable,
       which is used to make a replica skip a specified number
       of transactions, ignored transaction payloads that had
       been compressed using binary log transaction compression
       (activated using the binlog_transaction_compression
       system variable). Only events in uncompressed transaction
       payloads were counted towards the total skipped. (Bug
       #31973055)

     * Replication: A deadlock could occur if the binary log
       file was rotated while system variables were being
       updated and read by different clients. (Bug #31774422)

     * Replication: The output of a SHOW PROCESSLIST statement
       for a replica's SQL thread sometimes showed the last
       query as currently being applied when the replica was
       actually caught up. (Bug #30521198, Bug #97560)

     * Microsoft Windows: Running MySQL Server (64-bit) on a
       Windows system with more than 32 logical processors and
       setting the VCPU attribute of a resource group to greater
       than 30 produced an incorrect CPU mask value, which is
       used to set the thread affinity. Under these conditions,
       the MSVC compiler reported warnings that the 32-bit shift
       was converted implicitly to 64-bit in the
       thread_attrs_api_win.cc file. The conversion resulted in
       the wrong CPU mask calculation on systems that have more
       than 32 logical processors. This fix ensures that a
       64-bit shift is used when calculating the CPU mask by
       replacing argument 1 of the shift with 1LL. (Bug
       #32079726)

     * JSON: The IF() function sometimes hit an assertion in
       debug builds when an error was raised from its first
       argument; this also could occur under similar
       circumstances with the additional condition that the
       function's return type was JSON. (Bug #32231393, Bug
       #32231620)

     * JSON: A number of JSON functions did not propagate errors
       correctly, which could lead to assert failures in debug
       builds. (Bug #32047630)

     * JSON: JSON_TABLE() inside triggers was sometimes handled
       incorrectly when re-used in different sessions. Fixed by
       ensuring that JSON_TABLE() and its temporary table are
       processed in the context of the current session. (Bug
       #31644193)

     * JSON: A multi-valued index defined on an expression that
       cast a column into a typed array was not used for
       speeding up queries. This was because the server, when
       substituting an expression with an equivalent indexed
       generated column, did not attempt to replace a reference
       to a column with a reference to an equivalent generated
       column; for multi-valued indexes, it makes sense to
       replace the column reference with a reference to a
       generated column backing a multi-valued index on an
       expression that cast that column into a typed array.
       This fix lifts the restriction that the server attempts
       to substitute only function expressions and conditional
       expressions with indexed generated columns, by allowing
       substitution of column references when they appear in a
       context where they can make use of a multi-valued index,
       that is, when they are used as arguments to MEMBER OF(),
       JSON_CONTAINS(), or JSON_OVERLAPS(). The restriction
       remains in force for cases in which the column reference
       is used in a non-array context. (Bug #30838807)

     * JSON: The JSON_SEARCH() function interpreted all search
       string and path values as utf8mb4 strings, regardless of
       their actual encoding, which could lead to wrong results.
       (Bug #102443, Bug #32443143)

     * JSON: In some cases, when used in a left join, some MySQL
       JSON functions caused the optimizer to transform it into
       an inner join, even though the inner join was not
       equivalent to the original left join. This was due to the
       fact that they return a value which is not NULL, even
       though one of their arguments is NULL, and the optimizer
       expected them to return NULL on NULL input.
       Functions affected by this issue included JSON_ARRAY(),
       JSON_OBJECT(), JSON_ARRAY_APPEND(), JSON_ARRAY_INSERT(),
       JSON_INSERT(), JSON_REPLACE(), and JSON_SET(). See JSON
       Functions
       (https://dev.mysql.com/doc/refman/8.0/en/json-functions.html),
       for more information about these functions. (Bug
       #101861, Bug #32248705)

     * Community packages for generic Linux were not built with
       the necessary LDAP/SASL/Kerberos dependencies, and did
       not bundle the associated required libraries. (Bug
       #32619858)

     * The functions BIT_AND(), BIT_OR(), BIT_XOR(), and
       JSON_ARRAYAGG() did not always provide proper error
       handling. (Bug #32594813)

     * The server did not always provide proper error messages
       when IN was incorrectly used with UNION. (Bug #32593846)

     * It was possible for casting from DECIMAL to a signed
       integer type to hit an assertion when the result had more
       digits than the metadata in Item_typecast_signed
       indicated it would have. This happened because the
       decimal value is rounded when converted to an integer,
       and Item_typecast_signed did not take into account that
       the rounding might increase the number of digits in what
       was the integer part of the decimal value, such as when
       rounding 9.9 up to 10.
       This is fixed by removing the logic that tried to compute
       a minimal maximum length for the result of the cast, and
       instead using the default set by the parent class
       Item_int_func. That default is the maximum width of a
       64-bit integer, which should be safe regardless of the
       input value. (Bug #32591589)
       References: This issue is a regression of: Bug #32371039.

     * The name my_row_id was not permitted for invisible
       columns. This restriction has been lifted. (Bug
       #32586231)

     * On a system with many concurrent connections, execution
       of grant statements could take excessively long waiting
       for metadata locks, causing the server to become
       unresponsive. (Bug #32483597)

     * Windows binaries and libraries were not being properly
       signed. (Bug #32458533)

     * Privilege checks for INFORMATION_SCHEMA tables could fail
       to take the lower_case_table_names value into account.
       (Bug #32448364)

     * LIKE ... ESCAPE, where ESCAPE did not reference a
       constant value, was not handled correctly within a
       prepared statement. (Bug #32446728)

     * MySQL has traditionally interpreted an empty value in the
       ESCAPE clause (that is, ESCAPE '') for LIKE as "no escape
       character". Problems could arise when either of the first
       two arguments to LIKE was a string using a multibyte
       character set, because the empty value in such cases was
       interpreted as meaning that the backslash (\) should be
       used as the escape character, breaking the expected
       behavior.
       This fix causes LIKE to interpret ESCAPE '' as meaning
       that there is no escape character regardless of character
       set, restoring the previous, expected behavior.
       In addition, we now raise an error if the specified
       escape character cannot be converted to the target
       character set. This supersedes the original behavior in
       such cases, which was to fall back silently to using the
       backslash as the escape character. (Bug #32446508)

     * Windows packages were subject to an OpenSSL
       vulnerability. (Bug #32431519)

     * User-defined function arguments containing window
       functions or subqueries could produce unexpected results.
       (Bug #32424455)

     * Improper handling of temporary tables used for cursors
       within stored procedures could result in unexpected
       server behavior. (Bug #32416811)

     * Use of the symbol TRUE in the source resulted in a build
       failure on some platforms. This was replaced by true.
       (Bug #32406197, Bug #102308)

     * The privilege check used to determine whether users can
       see view definitions in the INFORMATION_SCHEMA.VIEWS
       table worked incorrectly. (Bug #32405811)

     * For recursive common table expressions, an assertion
       could be raised if it became necessary to convert an
       in-memory temporary table to on-disk. (Bug #32404597)

     * A prepared statement employing a user-created function
       was not handled correctly when the function took no
       arguments. (Bug #32404542)

     * A clone plugin installation failure could cause
       subsequent installation attempts to fail. (Bug #32402158,
       Bug #102240)

     * Some internal functions used with temporal column types
       did not provide proper handling for YEAR values. (Bug
       #32395335)

     * The internal constants MAX_FLOAT_STR_LENGTH = 12 and
       MAX_DOUBLE_STR_LENGTH = 22 represent the maximum lengths
       of strings representing FLOAT and DOUBLE values,
       respectively. The heuristic employed by the conversion
       routine my_gcvt for determining whether to use scientific
       notation sometimes generated strings that were longer
       than these.
       These long strings caused problems for some string
       conversion routines, since their actual lengths could
       exceed the expected maximums. We fix this by explicitly
       telling my_gcvt the desired length whenever we fetch a
       FLOAT or DOUBLE in a string context. (Bug #32385934)

     * Within triggers, use of RAND() with no arguments could
       lead to unexpected server behavior. (Bug #32372805)

     * A missing tablespace error was reported on the recipient
       MySQL server instance after a remote cloning operation.
       The tablespace was not cloned due to the
       innodb_validate_tablespace_paths variable being disabled
       on the donor instance, which resulted in the associated
       tablespace object not being loaded. A check is now
       performed before a cloning operation to ensure that all
       tablespace objects are loaded. (Bug #32354908, Bug
       #102137)

     * Some query blocks containing large numbers of EXISTS
       subqueries were not always handled correctly. (Bug
       #32343143)

     * mysqlpump could exit unexpectedly if a SHOW CREATE TABLE
       statement failed. (Bug #32340208)

     * A long running remote cloning operation failed due to a
       low wait_timeout setting on the donor MySQL Server
       instance. Donor threads use the MySQL Server wait_timeout
       setting when listening for Clone protocol commands. To
       avoid timeout failures on donor instances with a low
       wait_timeout setting, the Clone idle timeout is now set
       to the default wait_timeout setting, which is 28800
       seconds (8 hours). Clone network read and write timeout
       values were also increased. (Bug #32340112, Bug #102097)

     * Replication threads running in the server were visible in
       the Performance Schema threads table, but failed to
       appear in the variables_by_thread or status_by_thread
       tables. Now they appear in all three tables. Thanks to
       Facebook for the contribution. (Bug #32335496, Bug
       #102115)

     * A query string was displayed before it had been
       rewritten. (Bug #32335263, Bug #32628376)

     * For builds compiled using the libedit library, if the
       mysql client was invoked with the
       --default-character-set=utf8 option, libedit rejected
       input of multibyte characters. (Bug #32329078, Bug
       #32583436, Bug #102806)

     * On Windows, large result sets could cause the mysql
       client to exit unexpectedly. (Bug #32316323, Bug #102051)

     * Preparing a query expression for repeated execution could
       raise an assertion if an error occurred during
       preparation. (Bug #32291841)

     * Functional index creation did not handle the column name
       as not case-sensitive. (Bug #32287186, Bug #101994)

     * Temporary tables bound to triggers during statement
       execution could cause an unexpected server exit. (Bug
       #32267749, Bug #32288089, Bug #32299045)

     * Improved NULL and error handling in calculations
       involving decimal values. (Bug #32258228, Bug #32497850)

     * An assertion was raised if there was an open handler to a
       table in a schema when the schema was altered to be read
       only. (Bug #32248313)

     * Selecting from the Performance Schema
       replication_group_members table in some cases raised
       Error 1267 Illegal mix of collations .... This was due to
       a change in MySQL 8.0.22 in the handling of comparisons
       between a column value and a system variable. (Bug
       #32244631)
       References: See also: Bug #32501472, Bug #32579184.

     * MySQL produced invalid metadata for a number of temporal
       functions returning integer values. These functions
       included TO_DAYS(), PERIOD_DIFF(), PERIOD_ADD(),
       TO_SECONDS(), DAYOFMONTH(), DAYOFYEAR(), HOUR(), and
       MINUTE(), among others. (Bug #32239578)

     * Table subqueries of a natural join which retrieved only
       invisible columns were not handled correctly. (Bug
       #32235285)

     * For debug builds, using ALTER TABLE to set a column to
       have a DEFAULT value of TRUE raised an assertion. (Bug
       #32235058)

     * When an error was raised while evaluating a condition
       that was pushed down to the storage engine using index
       condition pushdown, the storage engine sometimes ignored
       the error and returned an error code indicating success,
       which could lead to assertion failures later.
       Now in such cases, we make sure that the executor detects
       that an error has been raised, and stop execution at that
       point. (Bug #32234773)

     * For debug builds with binary logging disabled, ALTER
       TABLE ... MODIFY COLUMN with an invalid DEFAULT value
       raised an assertion. (Bug #32234194)

     * Preparation of an aggregate function sometimes hit an
       assertion in debug builds when the function took a
       constant scalar subquery as argument and the scalar
       subquery raised an error. (Bug #32231698)

     * For debug builds, improper character set handling for
       NULLIF() evaluated in aggregate context raised an
       assertion. (Bug #32231557)

     * A CREATE TABLE statement with an unsupported
       KEY_BLOCK_SIZE value raised an assertion. (Bug #32227101)

     * Upgrading a MySQL instance with a very large number of
       tables consumed an excessive amount of memory. Memory
       allocated to analyze data dictionary entities for
       possible upgrade was not released until all entities were
       processed. (Bug #32226180, Bug #101818)

     * ANALYZE TABLE executed on a table concurrently with a
       long-running query on the same table caused subsequent
       queries on the table to wait for the long-running query
       to finish. This wait induced by ANALYZE TABLE is now
       eliminated, thus allowing the subsequent queries to
       execute with no wait. (Bug #32224917)

     * Statements using a LIKE expression with an ESCAPE clause
       were not always handled correctly. (Bug #32213959)

     * On ARM platforms, an assertion could be raised in
       utilities used during the build process. (Bug #32209415)

     * InnoDB did not always handle some legal names for table
       partitions correctly. (Bug #32208630)

     * With the explicit_defaults_for_timestamp variable
       disabled, Clone plugin installation failed with PFS table
       creation error. The variable setting caused TIMESTAMP
       columns in the Clone Performance Schema tables to be
       created incorrectly as NOT NULL columns. (Bug #32199611)

     * SHOW CREATE VIEW produced invalid syntax for views
       created with a ROLLUP clause. This issue also affected
       mysqldump, which uses SHOW CREATE VIEW. (Bug #32197353,
       Bug #101740)

     * A failed CREATE TABLE or ALTER TABLE with
       SECONDARY_ENGINE_ATTRIBUTE could leak memory. (Bug
       #32187507)

     * Connection establishment failure could cause the server
       to count the number of open connections incorrectly. (Bug
       #32156518)

     * Refactoring work done in MySQL 8.0.19 did not handle left
       joins correctly on columns using functions such as
       IFNULL(). (Bug #32141711)
       References: This issue is a regression of: Bug #30320525.

     * The optimizer could choose to use a Skip Scan even for
       backward index scans for which it is inapplicable,
       resulting in unpredictable server behavior. (Bug
       #32127290)

     * UDF function arguments containing window functions were
       evaluated at prepare time despite the fact that window
       functions are set up quite late in the prepare process.
       Now evaluation of these is delayed until execution time,
       similarly to how this is performed with respect to UDF
       arguments containing subqueries. (Bug #32122078, Bug
       #32393265)

     * Creating a table containing a column with a nonconstant
       default expression caused subsequent ALTER TABLE
       statements to fail. (Bug #32121425, Bug #101486)

     * Updating a BLOB-like column with a value from a larger
       BLOB-like column could cause the updated column to have
       the wrong size, even zero. (Bug #32112403)

     * A race condition could occur if a STOP GROUP_REPLICATION
       statement was used to stop a group member, while the
       Performance Schema statistics for Group Replication were
       being queried by another client. Group Replication now
       prevents STOP GROUP_REPLICATION statements and
       Performance Schema queries from running concurrently.
       (Bug #32100147)

     * Improper locking on an internal queue could cause
       mysqlpump to exit unexpectedly. (Bug #32067013)

     * The server did not always prepare correctly a statement
       using GROUP_CONCAT() on a SELECT with an ORDER BY clause.
       (Bug #32053547, Bug #31947466)

     * The sys schema create_synonym_db() procedure fail to
       create INFORMATION_SCHEMA synonyms. (Bug #32050275, Bug
       #101258)

     * Errors occurring in window functions were not always
       correctly propagated, which could lead to assertion
       failures in debug builds. (Bug #32028154)

     * It is now possible to use START REPLICA SQL_THREAD and
       STOP REPLICA SQL_THREAD statements for the
       group_replication_applier channel when Group Replication
       is stopped. This enables an operator to apply any
       remaining unapplied transactions on a server that left
       the group, without having to rejoin the server to the
       group. (Bug #32027612, Bug #32414767)

     * Calling XA COMMIT on a transaction started by another
       thread could result in Address Sanitizer warnings. (Bug
       #32025408)

     * When the mysql client was used in batch mode, its parser
       could be confused by USE followed by DROP DATABASE when
       the USE database name was quoted. (Bug #32015466, Bug
       #101124)

     * A change in MySQL 8.0.17 caused comp_err to become much
       slower. Normal performance has been restored. (Bug
       #32014733)
       References: This issue is a regression of: Bug #29781631,
       Bug #95377.

     * Using CAST() on a DATE or DATETIME value in an INSERT
       statement raised a warning for "0000-00-00" and
       "2000-02-31", but not for "2000-01-00" or "2000-00-01".
       Now a warning is shown in each of these cases also. (Bug
       #32013612)

     * The maximum length of the MASTER_COMPRESSION_ALGORITHMS
       value for the CHANGE MASTER TO statement was checked
       incorrectly. (Bug #32008597)

     * When casting a dynamic parameter to YEAR (such as in
       PREPARE s FROM "SELECT CAST(? AS YEAR)"), type
       propagation was not preformed, causing execution of the
       prepared statement in which the parameter was used to
       fail. (Bug #32002844)

     * Definitions of some system tables for a MySQL 5.7
       instance upgraded to MySQL 8.0 differed from the
       definitions of the system tables in a new MySQL 8.0
       installation. (Bug #31989290)

     * Some SHOW statements using subqueries could result in
       unexpected server behavior. (Bug #31853180)

     * A query using GROUP BY column HAVING column_expression IS
       [NOT] NULL returned correct results, but when WITH ROLLUP
       was added did not. (Bug #31848191)

     * The SHOW ENGINE PERFORMANCE SCHEMA STATUS statement
       reported incorrect memory usage for the Performance
       Schema. (Bug #31795132, Bug #100624)

     * When trying to generate an entity data model using Visual
       Studio 2019, some tables could not be imported with the
       entity framework wizard. This was due to a change in
       MySQL 8.0.21 made to orthogonal data type aggregation,
       which handles columns from UNION and from functions or
       operators such as CASE and IF(). This makes it possible
       to return a value of type ENUM or SET, which did not need
       to be handled previously in such cases. (Bug #31750645)
       References: See also: Bug #29698617.

     * While optimizing the ORDER BY clause of a subquery there
       was a possibility of cleaning up a subquery tree
       referenced in the outer SELECT, which could lead to a
       premature exit. (Bug #31721430)

     * A malformed name in the mysql.func system table could
       cause unexpected server behavior. (Bug #31674599)

     * Sessions could disable their own auditing. (Bug
       #31630954)

     * Compiler options for using profile guided optimization
       with GCC were improved to include
       -fprofile-partial-training and
       -fprofile-update=prefer-atomic when appropriate. Thanks
       to Dmitriy Philimonov for the suggestion. (Bug #31450064,
       Bug #99781)

     * Starting the server with the
       performance_schema_max_thread_classes and
       performance_schema_max_thread_instances system variables
       set to zero caused MySQL Enterprise Firewall to be unable
       to create new rules. (Bug #31335080, Bug #24947654, Bug
       #83519)

     * A null pointer was incremented during recovery from the
       redo log, causing a runtime error in an Undefined
       Behavior Sanitizer (UBSAN) build. (Bug #31173032, Bug
       #32428131)

     * With the log_slow_extra system variable enabled to add
       the Errno field to slow query log output, the error
       number was 0 even for failed statements. (Bug #30769965,
       Bug #98220)

     * On debug builds, certain conversion operations using the
       utf32 character set could cause unexpected server
       behavior. (Bug #30746908)

     * SELECT ... FOR UPDATE from a nonexistent Performance
       Schema table produced ER_TABLEACCESS_DENIED_ERROR rather
       than ER_NO_SUCH_TABLE. (Bug #30701047, Bug #98068)

     * Mishandling of stored program local variables could lead
       to unexpected server behavior. (Bug #30366310)

     * The Performance Schema metadata_locks table could show
       incorrect DURATION values, such as when a metadata lock
       taken for a TRANSACTION duration was later modified to
       EXPLICIT duration by a RENAME TABLE operation. (Bug
       #30065213, Bug #96237)

     * The audit_log plugin could fail to store its encryption
       password if it generated one at startup. (Bug #29559793)

     * Uninstalling a plugin could affect subsequent execution
       of prepared statements. (Bug #29363867)

     * Conversion of string-valued user-defined variables or
       function results to double (for example, using CAST())
       did not emit a warning when truncation occurred. (Bug
       #27969934, Bug #21943299)

     * When a view definition used LIKE with an ESCAPE clause,
       the contents of the ESCAPE clause were ignored, leading
       to wrong results. (Bug #26086751)

     * It was possible to insert illegal ASCII values (outside
       7-bit range) into character columns that used the ascii
       character set. This is now prohibited. (Bug #24847620)

     * To enable use of spaces and other special characters
       within configuration values, mysql_config_editor now
       surrounds values it writes to the configuration file with
       double quote characters, and also escapes double quote
       characters used within values. (Bug #19953349, Bug
       #74691)

     * When the aggregate iterator finds no rows, it calls on
       each item in its SELECT list to inform them of this (for
       example, so that COUNT(*) can set itself to zero, or
       SUM(foo) can set itself to NULL). After internal work
       done in MySQL 8.0.22, it could also inadvertently call
       hidden items. In some queries with doubly nested
       subqueries, one such hidden item could become its own
       parent subquery (and scalar subqueries in MySQL have
       special legacy handling of this call, for queries which
       are not ONLY_FULL_GROUP_BY), causing the entire subquery
       to return NULL when it should not have done so.
       This is fixed by making the call only on visible items,
       as in MySQL 8.0.21 and earlier. (Bug #102101, Bug
       #32335256)

     * When interpreting the old-style plan to access paths,
       cache invalidators for LATERAL were delayed until all
       outer joins were completed, since outer joins could
       produce null-complemented rows that should also
       invalidate caches. Problems arose when an outer join
       contained a LATERAL, and that LATERAL referred only to
       tables from within the same outer join; in such cases the
       invalidator should be applied immediately and not
       delayed, lest we miss emitted rows, and the cache be
       incorrectly kept. In particular, this could happen when
       certain Information Schema tables were on the right side
       of an outer join, as these are now views defined using
       LATERAL.
       We fix this by delaying emission of the invalidator until
       we are inside the same (outer) join nest as the
       materialization to be invalidated, but no further. This
       also deals correctly with the case where rows from a
       table should invalidate two or more separate
       materializations, where some are within the join and some
       are higher up. (Bug #101460, Bug #32113029, Bug
       #32311147)
       References: This issue is a regression of: Bug #98238,
       Bug #30766181.

     * An optimizer trace printed floating-point numbers with a
       maximum six characters, which meant that the precision
       could be very low for many values, given that sign,
       decimal point, and exponent could use many of these
       characters. This was especially problematic for large
       numbers, whose precision could thus be as small as 1, and
       which could be rounded to values whose absolute value
       exceeded DBL_MAX and so could be rejected by JSON
       parsers.
       Now such numbers are always printed in an optimizer trace
       with a precision of 6. (Bug #101457, Bug #32113020)
       References: See also: Bug #94672, Bug #29493604.

     * Filesort was used for a query having an ORDER BY ... DESC
       clause, even when an index on the descending column was
       available and used. This happened because an ORDER BY
       sub-clause was not removed due to matching a field in an
       equality predicate, even though it should have, so that
       the optimizer did not match the query with the descending
       index, leading to suboptimal performance. (Bug #101220,
       Bug #32038406)

     * The debug server hit an assert when
       optimizer_search_depth was less than the number of
       JOIN_TAB structures used for a join. (Bug #100288, Bug
       #31655483)

     * Following the ALTER TABLE operations EXCHANGE PARTITION,
       IMPORT TABLESPACE, and IMPORT PARTITION TABLESPACE,
       serialized digital information reflecting the previous
       role of the tablespace was left behind. Now in such
       cases, the old SDI is explicitly removed from both
       tablespaces involved in the exchange or import of a
       tablespace. (Bug #98501, Bug #30878065)

     * Type resolution performed by the integer division
       operator (DIV) yielded a precision of one less than
       expected in the result.
       Our thanks to Kaiwang Chen for the contribution. (Bug
       #96459, Bug #30156563)

Options: ReplyQuote


Subject
Views
Written By
Posted
MySQL Community Server 8.0.24 has been released [ part 2/2 ]
585
April 20, 2021 03:15AM


Sorry, you do not have permission to post/reply in this forum.

Content reproduced on this site is the property of the respective copyright holders. It is not reviewed in advance by Oracle and does not necessarily represent the opinion of Oracle or any other party.