List:Announcements« Previous MessageNext Message »
From:Joerg Bruehe Date:March 10 2008 6:38pm
Subject:MySQL 6.0.4 Alpha has been released ! (part 2 of 2)
View as plain text  
Dear MySQL users,

MySQL 6.0.4-alpha, a new version of the MySQL database system including
the Falcon transactional storage engine (now at beta stage), has been
released. The main page for MySQL 6.0 is at:

If you are new to the Falcon storage engine and need more information,
please read the Falcon Evaluation Guide at:

and the Falcon White Paper at:

MySQL 6.0.4-alpha is available in source and binary form for a number
of platforms from our download pages at

and mirror sites. Note that not all mirror sites may be up to date at
this point in time, so if you can't find this version on some mirror,
please try again later or choose another download site.

We welcome and appreciate your feedback, bug reports, bug fixes,
patches etc.:

Despite all trimming, describing all changes since the last released
version of MySQL 6.0 exceeds the mailing list configuration.
We had to split this message into two parts: part 1 (the other)
lists all changes which are labeled "functionality", "security",
"incompatible", or "important",
while this one lists the changes without such a label.
You can view the full list online at

Changes since the last release:


Bugs fixed (part 2):
* Partitioning: MySQL Cluster: EXPLAIN PARTITIONS reported partition
   usage by queries on NDB tables according to the standard MySQL hash
   function than the hash function used in the NDB storage engine.
* Replication: MySQL Cluster: Row-based replication from or to a
   big-endian machine where the table used the NDB storage engine
   failed, if the same table on the other machine was either
   non-NDB or the other machine was little-endian.
   See also Bug#24231:,
* MySQL Cluster: An insert or update with combined range and equality
   constraints failed when run against an NDB table with the error Got
   unknown error from NDB. An example of such a statement would be UPDATE
   t1 SET b = 5 WHERE a IN (7,8) OR a >= 10;.
* MySQL Cluster: An error with an if statement in sql/
   could potentially lead to an infinite loop in case of failure when
   working with AUTO_INCREMENT columns in NDB tables.
* MySQL Cluster: The NDB storage engine code was not safe for
   strict-alias optimization in gcc 4.2.1.
* MySQL Cluster: Following an upgrade, ndb_mgmd would fail with
   an ArbitrationError. (Bug#31690:
* MySQL Cluster: It was possible in some cases for a node group to be
   "lost" due to missed local checkpoints following a system restart.
* MySQL Cluster: A query against a table with TEXT or BLOB columns that
   would return more than a certain amount of data failed with Got error
   4350 'Transaction already aborted' from NDBCLUSTER.
   This regression was introduced by
* MySQL Cluster: NDB tables having names containing
   non-alphanumeric characters (such as " $ ") were not
   discovered correctly. (Bug#31470:
* MySQL Cluster: A node failure during a local checkpoint could
   lead to a subsequent failure of the cluster during a system
   restart. (Bug#31257:
* MySQL Cluster: In some cases, the cluster managment server
   logged entries multiple times following a restart of mgmd.
* MySQL Cluster: ndb_mgm --help did not display any information
   about the -a option. (Bug#29509:
* MySQL Cluster: An interpreted program of sufficient size and
   complexity could cause all cluster data nodes to shut down due
   to buffer overruns. (Bug#29390:
* MySQL Cluster: Performing DELETE operations after a data node
   had been shut down could lead to inconsistent data following a
   restart of the node. (Bug#26450:
* MySQL Cluster: UPDATE IGNORE could sometimes fail on NDB
   tables due to the use of unitialized data when checking for
   duplicate keys to be ignored.
* MySQL Cluster: The cluster log was formatted inconsistently
   and contained extraneous newline characters.
* MySQL Cluster: (Replication): Inconsistencies could occur
   between the master and the slave when replicating Disk Data
   tables. (Bug#19259:,
* Partitioning: Repeated updates of a table that was partitioned
   by KEY on a TIMESTAMP column eventually crashed the server.
* Partitioning: Selecting from a table partitioned by KEY on a
   VARCHAR column whose size was greater than 65530 caused the
   server to crash. (Bug#31705:
* Partitioning: INSERT DELAYED into a partitioned table crashed
   the server. (Bug#31201:
* Partitioning: Using ALTER TABLE to partition an existing table
   having an AUTO_INCREMENT column could crash the server.
   This regression was introduced by
* Partitioning: Falcon cannot drop a table for which there is a
   pending transaction, but the error message for such attempts
   was misleading. (Bug#22972:
* Replication: When dropping a database containing a stored
   procedure while using row-cased replication, the delete of the
   stored procedure from the mysql.proc table was recorded in the
   binary log following the DROP DATABASE statement. To correct
   this issue, DROP DATABASE now uses statement-based
   replication. (Bug#32435:
* Replication: It was possible for the name of the relay log
   file to exceed the amount of memory reserved for it, possibly
   leading to a crash of the server.
   See also Bug#28597:
* Replication: Corruption of log events caused the server to
   crash on 64-bit Linux systems having 4 GB of memory or more.
* Replication: Trying to replicate an update of a row that was
   missing on the slave led to a failure on the slave.
* Replication: Table names were displayed as binary "garbage"
   characters in slave error messages. The issue was observed on
   64-bit Windows but may have effected other platforms.
* Replication: One thread could read uninitialized memory from
   the stack of another thread. This issue was only known to
   occur in a mysqld process acting as both a master and a slave.
* Replication: It was possible to set SQL_SLAVE_SKIP_COUNTER
   such that the slave would jump into the middle of an event
   group, including possibly a transaction.
   See also Bug#12691:
* Replication: Due a previous change in how the default name and
   location of the binlog file were determined, replication
   failed following some upgrades.
   See also Bug#31836:
   This regression was introduced by
* Replication: Stored procedures having BIT parameters were not
   replicated correctly. (Bug#26199:
* Replication: Issuing SHOW SLAVE STATUS as mysqld was shutting
   down could cause a crash.
* Replication: If a temporary error occured inside an event
   group on an event that was not the first event of the group,
   the slave could get caught in an endless loop because the
   retry counter was reset whenever an event was executed
   successfully. (Bug#24860:
   See also Bug#12691:,
* Replication: An UPDATE statement using a stored function that
   modified a non-transactional table was not logged if it
   failed. This caused the copy of the non-transactional table on
   the master have a row that the copy on the slave did not.
   See also Bug#12713:
* Replication: A replication slave sometimes failed to reconnect
   because it was unable to run SHOW SLAVE HOSTS.
   See also Bug#13963:,
* Replication: A replication slave sometimes stopped for changes
   that were idempotent (that is, such changes should have been
   considered "safe"), even though it should have simply noted
   that the change was already done, and continued operation.
* Cluster Replication: A replication slave could return "garbage" data
   that was not in recognizable row format due to a problem with the
   internal all_set() method. (Bug#33375:
* Cluster Replication: A node failure during replication could
   lead to buckets out of order; now active subscribers are
   checked for, rather than empty buckets.
* Cluster Replication: In some cases, not all tables were
   properly initialized before the binlog thread was started.
* Using Falcon when accessing multiple versions of the same
   record, certain records could fail to be retrieved from the
   record cache, causing an assertion failure.
* Creating an index on a Falcon table with a column using UTF32
   that has been converted to UTF8 would cause a server crash.
* Using ALTER TABLE on a Falcon table it would be possible to
   create two tables with the same name but different case.
* Converting a table from InnoDB to Falcon, where the Falcon
   table with the same name (but different case) would cause a
   server crash. (Bug#32829:
* mysqld_safe looked for error messages in the wrong location.
* An issue with the NO_ENGINE_SUBSTITUTION sql_mode database can
   cause the creation of stored routines to fail. If you are
   having problems with creating stored routines while using this
   sql_mode value, remove this value from your sql_mode setting.
* Repeatedly creating and dropping Falcon tablespaces would fail
   because a dropped tablespace would not be dropped before the
   new tablespace file was created.
* The INTERVAL() function incorrectly handled NULL values in the
   value list. (Bug#32560:
* Use of a NULL-returning GROUP BY expression in conjunction
   with WITH ROLLUP could cause a server crash.
   See also Bug#31095:
* ORDER BY UpdateXML(...) caused the server to crash in queries
   where UpdateXML() returned NULL.
* Falcon used a fixed index key size which would be too small to
   cope with some Falcon page sizes, leading to a crash. Falcon
   now supports variable length index keys according to the
   supported page sizes. See falcon_page_size.
* The rules for valid column names were being applied differently for
   base tables and views. (Bug#32496:
* Falcon options to set the limits of memory usage would not be
   honoured. This could lead to crashes and assertions during
   normal usage, instead of generating a suitable warning.
* Falcon would incorrectly return the supported repeatable-read
   level when queried by the Online Backup system, preventing the
   ability to create a consistent snapshot backup.
* Some uses of user variables in a query could result in a
   server crash. (Bug#32260:
* Under certain conditions, the presence of a GROUP BY clause
   could cause an ORDER BY clause to be ignored.
* Altering a Falcon table to support an auto increment column on
   a column with existing data and null values would incorrectly
   update the table and return an incorrect count of the altered
   rows. (Bug#32194:
* InnoDB does not support SPATIAL indexes, but could crash when
   asked to handle one. Now an error is returned.
* The server crashed on optimizations involving a join of INT
   and MEDIUMINT columns and a system variable in the WHERE
   clause. (Bug#32103:
* used the --user option when starting mysqld,
   which produces warnings if the current user is not root. Now
   --user is added only for root.
* Inserting, updating and deleting a large number of BLOB records in a
   Falcon table would take significant amount of time and may prevent
   shutdown. (Bug#32062:
* On 64-bit platforms, assignments of values to enumeration-valued
   storage engine-specific system variables were not validated and could
   result in unexpected values. (Bug#32034:
* A DELETE statement with a subquery in the WHERE clause would sometimes
   ignore an error during subquery evaluation and proceed with the delete
   operation. (Bug#32030:
* Using dates in the range '0000-00-01' to '0000-00-99' range in the
   WHERE clause could result in an incorrect result set. (These dates are
   not in the supported range for DATE, but different results for a given
   query could occur depending on position of records containing the
   dates within a table.) (Bug#32021:
* User-defined functions are not loaded if the server is started
   with the --skip-grant-tables option, but the server did not
   properly handle this case and issued an Out of memory error
   message instead. (Bug#32020:
* If a user-defined function was used in a SELECT statement, and
   an error occurred during UDF initialization, the error did not
   terminate execution of the SELECT, but rather was converted to
   a warning. (Bug#32007:
* In debug builds, testing the result of an IN subquery against
   NULL caused an assertion failure.
* SHOW CREATE TRIGGER caused a server crash.
* The server crashed after insertion of a negative value into an
   AUTO_INCREMENT column of an InnoDB table.
* For libmysqld applications, handling of mysql_change_user()
   calls left some pointers improperly updated, leading to server
   crashes. (Bug#31850:
* Comparison results for BETWEEN were different from those for
   operators like < and > for DATETIME-like values with trailing
   extra characters such as '2007-10-01 00:00:00 GMT-6'.
* With ONLY_FULL_GROUP_BY SQL mode enabled, queries such as
   SELECT a FROM t1 HAVING COUNT(*)>2 were not being rejected as
   they should have been. (Bug#31794:
* The server could crash during filesort for ORDER BY based on
   expressions with INET_NTOA() or OCT() if those functions
   returned NULL. (Bug#31758:
* For a fatal error during filesort in find_all_keys(), the error was
   returned without the necessary handler uninitialization, causing an
   assertion failure. Fixed by uninitializing  the  handler before
   returning the error. (Bug#31742:
* The examined-rows count was not incremented for const queries.
* Falcon tables would fail during replication if ROW-based
   replication was specified. (Bug#31671:
* The mysql_change_user() C API function was subject to buffer
   overflow. (Bug#31669:
* For SELECT ... INTO OUTFILE, if the ENCLOSED BY string is
   empty and the FIELDS TERMINATED BY string started with a
   special character (one of n, t, r, b, 0, Z, or N), every
   occurrence of the character within field values would be
   duplicated. (Bug#31663:
* SHOW COLUMNS and DESCRIBE displayed null as the column type
   for a view with no valid definer. This caused mysqldump to
   produce a non-reloadable dump file for the view.
* The mysqlbug script did not include the correct values of
   CFLAGS and CXXFLAGS that were used to configure the
   distribution. (Bug#31644:
* For queries for which loose index scan is applicable, the
   optimizer could choose the wrong execution plan for correlated
   subqueries. (Bug#31639:
* Queries that include a comparison of an INFORMATION_SCHEMA
   table column to NULL caused a server crash.
   caused an assertion failure.
* A buffer used when setting variables was not dimensioned to
   accommodate the trailing '\0' byte, so a single-byte buffer
   overrun was possible. (Bug#31588:
* For semi-join processing, pullout of functionally dependent
   tables was not handled transitively.
* HAVING could treat lettercase of table aliases incorrectly if
   lower_case_table_names was enabled.
* Spurious duplicate-key errors could occur for multiple-row
   inserts into an InnoDB table that activate a trigger.
* When inserting dates into a DATETIME column with a Falcon, the
   values would automatically be converted with values between 70
   and 99 converted to 1970-1999, and values from 00 to 69
   converted to 2000 to 2069. These dates are now correctly
   handled. (Bug#31490:
* The length of the result from IFNULL() could be calculated
   incorrectly because the sign of the result was not taken into
   account. (Bug#31471:
* Queries that used the ref access method or index-based subquery
   execution over indexes that have DECIMAL columns could fail with an
   error Column col_name cannot be null.
* InnoDB now tracks locking and use of tables by MySQL only after a
   table has been successfully locked on behalf of a transaction.
   Previously, the locked flag was set and the table in-use counter was
   updated before checking whether the lock on the table succeeded.
   A subsequent failure in obtaining a lock on the table led to an
   inconsistent state as the table was neither locked nor in use.
* SELECT 1 REGEX NULL caused an assertion failure for debug
   servers. (Bug#31440:
* INFORMATION_SCHEMA.TABLES was returning incorrect information.
* DROP USER caused an increase in memory usage.
* TABLESPACE names within Falcon did not support characters
   outside the alpha-numeric ASCII character set.
* For InnoDB tables with READ COMMITTED isolation level, UPDATE
   statements skipped rows locked by another transaction, rather
   than waiting for the locks to be released.
* For an almost-full MyISAM table, an insert that failed could
   leave the table in a corrupt state.
* When dropping Falcon tablespaces the associated tablespace
   file would not be deleted. (Bug#31296:
* myisamchk --unpack could corrupt a table that when unpacked has static
   (fixed-length) row format. (Bug#31277:
* Building a 64-bit binary with support for the Falcon storage
   engine using gcc on Solaris could fail. See Section 2.9,
   "MySQL Installation Using a Source Distribution," for more
   information. (Bug#31268:,
* When a TIMESTAMP with a non-zero time part was converted to a
   DATE value, no warning was generated. This caused index
   lookups to assume that this is a valid conversion and was
   returning rows that match a comparison between a TIMESTAMP
   value and a DATE keypart. Now a warning is generated so that
   TIMESTAMP with a non-zero time part will not match DATE
   values. (Bug#31221:
* If MAKETIME() returned NULL when used in an ORDER BY that was
   evaluated using filesort, a server crash could result.
* LAST_INSERT_ID() execution could be handled improperly in
   subqueries. (Bug#31157:
* An assertion designed to detect a bug in the ROLLUP implementation
   would incorrectly be triggered when used in a subquery context with
   non-cacheable statements. (Bug#31156:
* When creating a TABLESPACE that uses the same name as an existing
   TABLESPACE, Falcon would return Unknown error -103. MySQL will now
   return an error stating that the specified tablespace already exists.
* mysqldump failed to handle databases containing a `-' character
   in the name. (Bug#31113:
* Starting the server using --read-only and with the Event Scheduler
   enabled caused it to crash. (Bug#31111:
* Dropping a tablespace and specifying an engine type that does not
   support tablespaces would report a warning. The response has now been
   updated to report an error. (Bug#31110:
* GROUP BY NULL WITH ROLLUP could cause a server crash.
   See also Bug#32558:
* A rule to prefer filesort over an indexed ORDER BY when
   accessing all rows of a table was being used even if a LIMIT
   clause was present. (Bug#31094:
* REGEXP operations could cause a server crash for character sets such
   as ucs2. Now the arguments are converted to utf8 if possible, to allow
   correct results to be produced if the resulting strings contain only
   8-bit characters. (Bug#31081:
* Expressions of the form WHERE col NOT IN (col, ...), where the
   same column was named both times, could cause a server crash
   in the optimizer. (Bug#31075:
* Falcon would fail to compile on FreeBSD. This limitation has
   now been fixed. (Bug#31045:
* Using ORDER BY with ARCHIVE tables caused a server crash.
* The MOD() function and the % operator crashed the server for a
   divisor less than 1 with a very long fractional part.
* Using falcon_serial_log_dir to set the location of the Falcon
   serial log would have no effect.
* The LooseScan subquery optimization strategy could produce
   duplicate rows in query results.
* A character set introducer followed by a hexadecimal or bit-value
   literal did not check its argument and could return an ill-formed
   result for invalid input. (Bug#30986:
* CHAR(str USING charset) did not check its argument and could
   return an ill-formed result for invalid input.
* The result from CHAR(str USING ucs2) did not add a leading
   0x00 byte for input strings with an odd number of bytes.
* A cluster restart could sometimes fail due to an issue with
   table IDs. (Bug#30975:
* The GeomFromText() function could cause a server crash if the
   first argument was NULL or the empty string.
* When invoked with constant arguments, STR_TO_DATE() could use
   a cached value for the format string and return incorrect
   results. (Bug#30942:
* GROUP_CONCAT() returned ',' rather than an empty string when
   the argument column contained only empty strings.
* A server crash could occur if a stored function that contained
   a DROP TEMPORARY TABLE statement was invoked by a CREATE
   TEMPORARY TABLE statement that created a table of the same
   name. (Bug#30882:
* Calling NAME_CONST() with non-constant arguments triggered an
   assertion failure. Non-constant arguments are now disallowed.
* Running ALTER TABLE ... OPTIMIZE PARTITION on a Falcon table,
   a 'divide by zero' error would be reported during a server
   crash. (Bug#30826:
* For a spatial column with a regular (non-SPATIAL) index,
   queries failed if the optimizer tried to use the index.
* INFORMATION_SCHEMA.SCHEMATA was returning incorrect information.
* On Windows, the pthread_mutex_trylock() implementation was incorrect.
   One symptom was that invalidating the query cache could cause a server
   crash. (Bug#30768:
* A multiple-table UPDATE involving transactional and non-transactional
   tables caused an assertion failure.
* Under some circumstances, CREATE TABLE ... SELECT could crash
   the server or incorrectly report that the table row size was
   too large. (Bug#30736:
* Using the MIN() or MAX() function to select one part of a
   multi-part key could cause a crash when the function result
   was NULL. (Bug#30715:
   were defined to select from other INFORMATION_SCHEMA tables.
* Issuing an ALTER SERVER statement to update the settings for a
   FEDERATED server would cause the mysqld to crash.
* The optimizer could ignore ORDER BY in cases when the result
   set is ordered by filesort, resulting in rows being returned
   in incorrect order. (Bug#30666:
* A different execution plan was displayed for EXPLAIN than
   would actually have been used for the SELECT because the test
   of sort keys for ORDER BY did not consider keys mentioned in
* MyISAM tables could not exceed 4294967295 (2^32 - 1) rows on
   Windows. (Bug#30638:
* could not run mysqld with root privileges.
* Using GROUP BY on an expression of the form timestamp_col DIV
   number caused a server crash due to incorrect calculation of
   number of decimals. (Bug#30587:
* The options available to the CHECK TABLE statement were also
   allowed in OPTIMIZE TABLE and ANALYZE TABLE statements, but
   caused corruption during their execution. An error is now
   raised if you try to apply these options to these statements.
* When expanding a * in a USING or NATURAL join, the check for
   table access for both tables in the join was done using only
   the grant information of the first table.
* Compared to MySQL 5.1, the 6.0 optimizer failed to use join
   buffering for certain queries, resulting in slower performance
   for those queries. (Bug#30363:
* A table-access check was performed improperly by libmysqld,
   causing a crash. (Bug#30329:
* Some valid euc-kr characters having the second byte in the
   ranges [0x41..0x5A] and [0x61..0x7A] were rejected.
* When loading a dynamic plugin on FreeBSD, the plugin would fail to
   load. This was due to a build error where the required symbols would
   be not exported correctly. (Bug#30296:
* Setting certain values on a table using a spatial index could cause
   the server to crash. (Bug#30286:
* Some INFORMATION_SCHEMA tables are intended for internal use, but
   could be accessed by using SHOW statements.
* On some 64-bit systems, inserting the largest negative value into a
   BIGINT column resulted in incorrect data.
* mysqlslap did not properly handle multiple result sets from
   stored procedures. (Bug#29985:
* Running the sqlbench test suite against Falcon would cause a
   crash. (Bug#29870:
* When accessing statistics in INFORMATION_SCHEMA.FALCON_DATABASE_IO,
   the information would relate only to the Falcon database, not user
   tablespaces. (Bug#29823:
* Whitespace characters other than spaces within XML tags, such
   as linefeeds or tabs, caused LOAD XML INFILE to skip rows.
* configure did not find nss on some Linux platforms.
* Compilation failed on systems where a native log2() implementation was
   unavailable. (Bug#29640:
* Use of the latin2_czech_cs collation caused a server crash.
* Using two simultaneous connections it was possible to create a
   deadlock situation between two different active transactions on the
   same Falcon table. There is no way to prevent this, but a new
   parameter, falcon_lock_timeout can set the timeout for deadlocked
   transactions. The default timeout is 0 (timeouts are disabled).
* The mysql client program now ignores Unicode byte order mark
   (BOM) characters at the beginning of input files. Previously,
   it read them and sent them to the server, resulting in a
   syntax error. (Bug#29323:
* Insert information into the same table from multiple threads could
   cause duplicate key errors. This was related to the changes made to
   allow compatibility with the InnoDB repeatable-read isolation level.
   The option, falcon_innodb_compatibility, has been renamed to
   falcon_consistent_read, but with the opposite effect. The default is
   for this option to be on. When set to off, the behaviour of Falcon is
   similar to that in InnoDB. (Bug#29151:
* For transactional tables, an error during a multiple-table DELETE
   statement did not roll back the statement.
* The log and log_slow_queries system variables were displayed by SHOW
   VARIABLES but could not be accessed in expressions as @@log and
   @@log_slow_queries. (Bug#29131:
* When loading large data sets using LOAD DATA INFILE into a Falcon
   table, the server could crash.
* SHOW VARIABLES did not display the relay_log, relay_log_index,
   or relay_log_info_file system variables.
* Index hints specified in view definitions were ignored when using the
   view to select from the base table.
* Views do not have indexes, so index hints do not apply. Use of
   index hints when selecting from a view is now disallowed.
* After changing the SQL mode to a restrictive value that would
   make already-inserted dates in a column be considered invalid,
   searches returned different results depending on whether the
   column was indexed. (Bug#28687:
* The result from CHAR() was incorrectly assumed in some contexts to
   return a single-byte result. (Bug#28550:
* Using a temporary table within Falcon that is created in a
   directory where the path contains a mixture of upper and lower
   letters would fail. (Bug#28541:
* Under heavy load when updating Falcon tables, a race condition
   could occur that would ultimately result in a crash.
* The result of a comparison between VARBINARY and BINARY
   columns differed depending on whether the VARBINARY column was
   indexed. (Bug#28076:
* The metadata in some MYSQL_FIELD members could be incorrect
   when a temporary table was used to evaluate a query.
* It was possible to create a view having a column whose name
   consisted of an empty string or space characters only.
   See also Bug#31202:
* ALTER TABLE tbl_name ROW_FORMAT=format_type did not cause the
   table to be rebuilt. (Bug#27610:
* Searching a Falcon table that uses DATETIME columns with an index
   could return incorrect results.
* Removing a partition on a Falcon table when there are two
   tables with the same name, but different case, would cause a
   crash during normal shutdown. (Bug#27425:
* Mixing differently cased tables between MyISAM and Falcon
   tables would cause a crash. (Bug#27424:
* The ExtractValue() and UpdateXML() functions performed extremely
   slowly for large amounts of XML data (greater than 64 KB). These
   functions now execute approximately 2000 times faster than previously.
* On Windows, writes to the debug log were using freopen() instead of
   fflush(), resulting in slower performance.
* Connections from one mysqld server to another failed on Mac OS X,
   affecting replication and FEDERATED tables.
   See also Bug#29083:
* LOAD DATA INFILE ran very slowly when reading large files into
   partitioned tables. (Bug#26527:
* Threads that were calculating the estimated number of records for a
   range scan did not respond to the KILL statement. That is, if a range
   join type is possible (even if not selected by the optimizer as a join
   type of choice and thus not shown by EXPLAIN), the query in the
   statistics state (shown by the SHOW PROCESSLIST) did not respond to
   the KILL statement. (Bug#25421:
* For mysql --show-warnings, warnings were in some cases not displayed.
* Using CREATE UNIQUE INDEX on a Falcon table where rows contain
   duplicate values could result in pending transactions to the
   table being deleted. (Bug#22842:
* Creating a Falcon table with an auto-increment column that is not
   indexed as the first column in a multi-column index would
   auto0increment. This behavior was different to the behavior in both
   MyISAM and InnoDB. Falcon now rejects such tables during creation in
   the same way InnoDB does. (Bug#22564:
* For storage engines that do not redefine handler::index_next_same()
   and are capable of indexes, statements that include a WHERE clause
   might select incorrect data. (Bug#22351:
* Creating a new table or dropping a database on a newly created
   database or tablespace where the Falcon engine was used would
   raise an error. (Bug#22199:
* Using TRUNCATE on a Falcon table did not reset the auto-increment
   counters and used an inefficient method of deleting existing data.
* Creating a DATE outside the normal range within a Falcon table
   would result in a zero DATE value being returned, even though
   normally invalid values would be stored correctly in other
   storage engines. (Bug#22168:
* Selecting information from a Falcon table using a DOUBLE
   column with an index would produce incorrect results.
* The readline library has been updated to version 5.2. This
   addresses issues in the mysql client where history and editing
   within the client would fail to work as expected.
* mysql stripped comments from statements sent to the server.
   Now the --comments or --skip-comments option can be used to
   control whether to retain or strip comments. The default is
   --skip-comments. (Bug#11230:,
* Executing DISABLE KEYS and ENABLE KEYS on a non-empty table would
   cause the size of the index file for the table to grow considerably.


Daniel Fischer, Team Lead, Build           +46 18174400 ext. 4537
MySQL GmbH, Dachauer Strasse 37, D-80335 Muenchen -
Geschaeftsfuehrer: Kaj Arnoe                  HRB Muenchen 162140
Are you MySQL certified?    49.011, 8.376

MySQL 6.0.4 Alpha has been released ! (part 2 of 2)Joerg Bruehe10 Mar