Functionality Added or Changed
Triggers from older servers that included no
DEFINER clause in the trigger definition now
execute with the privileges of the invoker (which on the slave
is the slave SQL thread). Previously, replication slaves could
not replicate such triggers.
Builds for Windows, Linux, and Unix (except AIX) platforms now have SSL support enabled, in the server as well as in the client libraries. Because part of the SSL code is written in C++, this does introduce dependencies on the system's C++ runtime libraries in several cases, depending on compiler specifics. (Bug #18195)
Large file support added to build for
engine now provides a descriptive error message if
ibdata file information is omitted from
The syntax for
CREATE FUNCTION statements
now includes a
DEFINER clause. The
DEFINER value specifies the security context
to be used when checking access privileges at routine invocation
time if the routine has the
DEFINER characteristic. See
CREATE PROCEDURE and
CREATE FUNCTION Syntax, for more information.
When mysqldump is invoked with the
--routines option, it now
DEFINER value for stored routines.
Large file support was re-enabled for the MySQL server binary for the AIX 5.2 platform. (Bug #13571)
The server would not compile with
NDB support on AIX 5.2.
A timeout in the handling of an
condition with more that 32 operations could yield a node
MySQL Cluster: When replacing a failed master node, the replacement node could cause the cluster to crash from a buffer overflow if it had an excessively large amount of data to write to the cluster log. (Bug #18118)
MySQL Cluster: The cluster created a crashed replica of a table having an ordered index—or when logging was not enabled, of a table having a table or unique index—leading to a crash of the cluster following 8 successive restarts. (Bug #18298)
Inserting and deleting
column values while a backup was in process could cause data
nodes to shut down.
MySQL Cluster: Some query cache statistics were not always correctly reported for Cluster tables. (Bug #16795)
MySQL Cluster: If a mysql or other client could not parse the result set returned from a mysqld process acting as an SQL node in a cluster, the client would crash instead of returning the appropriate error. For example, this could happen when the client attempted to use a character set was not available to the mysqld. (Bug #17380)
Certain queries using
ORDER BY ... ASC in the
WHERE clause could return incorrect results.
MySQL Cluster: In event of a node failure during a rollback, a “false” lock could be established on the backup for that node, which lock could not be removed without restarting the node. (Bug #18352)
A node restart immediately following a
CREATE TABLE would fail.
This fix supports 2-node Clusters only.
MySQL Cluster: Restarting nodes were permitted to start and join the cluster too early. (Bug #16772)
DEFINER value for stored routines was not
Stored procedures that call UDFs and pass local string variables caused server crashes. (Bug #17261)
ORDER BY with a nonstring column
result's character set was converted to binary.
References: See also Bug #14169.
mysql_close() C API function
leaked handles for shared-memory connections on Windows.
InnoDB encountered a
ER_LOCK_TABLE_FULL error and
rolled back a transaction, the transaction was still written to
the binary log.
InnoDB tables with an adaptive hash blocked
other queries during
statements while the entire hash was checked. This could be a
long time for a large hash.
Views that incorporated tables from the
INFORMATION_SCHEMA database resulted in a
server crash when queried.
Checks for permissions on database operations could be performed
in a case-insensitive manner (a user with permissions on
MYDATABASE could by accident get
permissions on database
myDataBase), if the
privilege data were still cached from a previous check.
Connecting to a server with a UCS2 default character set with a client using a non-UCS2 character set crashed the server. (Bug #18004)
SELECT ... ORDER BY ... from a view defined
using a function could crash the server. An example of such a
CREATE VIEW v1 AS SELECT SQRT(c1) FROM
DELETE using a subquery could
crash the server.
Triggers created in MySQL 5.0.16 and earlier could not be dropped after upgrading the server to 5.0.17 or later. (Bug #15921)
If the server was started with the
--skip-grant-tables option, it
was impossible to create a trigger or a view without explicitly
Stored routine names longer than 64 characters were silently truncated. Now the limit is properly enforced and an error occurs. (Bug #17015)
MyISAM: Performing a bulk insert on a table
referenced by a trigger would crash the table.
If a row was inserted inside a stored procedure using the parameters passed to the procedure in the INSERT statement, the resulting binary log entry was not escaped properly. (Bug #18293)
Use of stored functions with
GROUP BY can produce incorrect results when
ORDER BY is also used.
The server could deadlock under heavy load while writing to the binary log. (Bug #18116)
Updating the value of a Unicode
VARCHAR column with the result
returned by a stored function would cause the insertion of ASCII
characters into the column instead of Unicode, even where the
function's return type was also declared as Unicode.
FEDERATED tables, a
SELECT statement with an
ORDER BY clause did not return rows in the
ORDER BY within a stored procedure (where
intvar is an integer variable or
expression) would crash the server.
The use of an integer
i in an
clause for sorting the result by the
column is deprecated (and nonstandard). It should
not be used in new applications. See
LATEST FOREIGN KEY
ERROR section in the output of
SHOW INNODB STATUS was sometimes
formatted incorrectly, causing problems with scripts that parsed
the output of this statement.
Updating a view that filters certain rows to set a filtered out
row to be included in the table caused infinite loop. For
example, if the view has a WHERE clause of
100 then issuing an UPDATE statement of
salary = 200 WHERE id = 10, caused an infinite loop.
InnoDB tables created in MySQL 4.1 or
earlier, or created in 5.0 or later with compact format,
updating a row so that a long column is updated or the length of
some column changes,
InnoDB later would fail
to reclaim the
BLOB storage space
if the row was deleted.
Complex queries with nested joins could cause a server crash. (Bug #18279)
WHERE condition of a query contained
FALSE term, the
set of tables whose rows cannot serve for null-complements in
outer joins was determined incorrectly. This resulted in
blocking possible conversions of outer joins into joins by the
optimizer for such queries.
LEFT JOIN with a
UNION that selects literal values
could crash the server.
Attempting to access an
InnoDB table after
starting the server with
caused a server crash.
SELECT * query on an
INFORMATION_SCHEMA table by a user with
limited privileges resulted in a server crash.
InnoDB ran out of buffer space for row
locks and adaptive hashes, the server would crash. Now
InnoDB rolls back the transaction.
InnoDB had a memory leak for duplicate-key
errors with tables having 90 columns or more.
The server displayed garbage in the error message warning about
bad assignments to
columns or routine variables.
SELECT ... WHERE , when
column had a key
and used the
caused the wrong number of rows to be returned.
SELECT COUNT(*) for a
MyISAM table could return different results
depending on whether an index was used.
Loading of UDFs in a statically linked MySQL caused a server crash. UDF loading is now blocked if the MySQL server is statically linked. (Bug #11835)
SELECT using a function against
a nested view would crash the server.
mysql_config returned incorrect libraries on
Certain combinations of joins with mixed
USING claused caused unknown
The server would execute stored routines that had a nonexistent definer. (Bug #13198)
Character set conversion of string constants for
UNION of constant and table
column was not done when it was safe to do so.
During conversion from one character set to
ucs2, multi-byte characters with no
ucs2 equivalent were converted to multiple
characters, rather than to