Anhang D. MySQL-Änderungsverlauf (Change History)
Zurück |  | Weiter

## Anhang D. MySQL-Änderungsverlauf (Change History)

This appendix lists the changes from version to version in the MySQL source code through the latest version of MySQL 5.1, which is currently MySQL 5.1.5-alpha. Starting with MySQL 5.0, we began offering a new version of the Manual for each new series of MySQL releases (5.0, 5.1, and so on). For information about changes in previous release series of the MySQL database software, see the corresponding version of this Manual. For information about legacy versions of the MySQL software through the 4.1 series, see MySQL-Referenzhandbuch für die Versionen 3.23, 4.0 und 4.1.

We update this section as we add new features in the 5.1 series, so that everybody can follow the development process.

Note that we tend to update the manual at the same time we make changes to MySQL. If you find a recent version of MySQL listed here that you can't find on our download page (http://dev.mysql.com/downloads/), it means that the version has not yet been released.

The date mentioned with a release version is the date of the last BitKeeper ChangeSet on which the release was based, not the date when the packages were made available. The binaries are usually made available a few days after the date of the tagged ChangeSet, because building and testing all packages takes some time.

The manual included in the source and binary distributions may not be fully accurate when it comes to the release changelog entries, because the integration of the manual happens at build time. For the most up-to-date release changelog, please refer to the online version instead.

## D.1. Änderungen in Release 5.1.x (Entwicklung)

The following changelog shows what has been done in the 5.1 tree:

- MySQL 5.1 enables table partitioning with a selection of partitioning algorithms and options available, independently of the storage engine used by the table. Syntactically, this implements a number of new extensions to the `CREATE TABLE`, `ALTER TABLE`, and `EXPLAIN ... SELECT` statements. See Kapitel 17, Partitionierung.

- MySQL 5.1 implements support for a plugin API that allows the loading and unloading of components at runtime, without restarting the server. See Abschnitt 26.2, „Die MySQL-Plug-In-Schnittstelle“.

For a full list of changes, please refer to the changelog sections for each individual 5.1.x release.

### D.1.1. Änderungen in Release 5.1.6 (Noch nicht veröffentlicht)

Functionality added or changed:

- Incompatible change: This release introduced the `TRIGGER` privilege. Previously, the `SUPER` privilege was needed to create or drop triggers. Now those operations require the `TRIGGER` privilege. This is a security improvement because you no longer need to grant users the `SUPER` privilege to enable them to create triggers. However, the requirement that the account named in a trigger's `DEFINER` clause must have the `SUPER` privilege has changed to a requirement for the `TRIGGER` privilege. You should check which accounts are named in the `DEFINER` clause of existing triggers and make sure that those accounts have the `TRIGGER` privilege. Otherwise, they will fail when activated. (Bug#9142)

- Incompatible change: Due to a change in the naming scheme for partitioning and subpartitioning files, it is not possible for the server to read partitioned tables created in previous MySQL versions. A suggested workaround is (1) to create a non-partitioned table with the same table schema using a standard `CREATE TABLE` statement (that is, with no partitioning clauses) and then (2) to issue a`SELECT INTO` to copy the data into the non-partitioned table before the upgrade; following the upgrade, you can partition the new table using `ALTER TABLE ... PARTITION BY ...`. Alternatively, you can dump the table using mysqldump prior to upgrading and reload it afterwards with `LOAD DATA`. In either case, you should drop the pre-5.1.6 partitioned tables before upgrading to 5.1.6 or later. (Bug#13437)

  Important: If any partitioned tables that were created prior to MySQL 5.1.6 are present following an upgrade to MySQL 5.1.6 or later, it is also not possible to read from the `INFORMATION_SCHEMA.PARTITIONS` table, nor will you be able to drop those tables or the database or databases in which they are located. In this event, you must: (1) shut down mysqld; (2) manually delete the table, partition, and (if any) subpartition files; and then (3) restart the MySQL Server. (Bug#16695)

- Incompatible change: Words with apostrophes are now matched in a FULLTEXT search against non-apostrophe words (for example, a search for `Jerry` will match against the term `Jerry's`). Users upgrading to this version must issue `REPAIR TABLE` statements for tables containing `FULLTEXT` indexes. (Bug#14194)

- The mysqldump utility now supports an option for dumping tablespaces. Use `-Y` or `--all-tablespaces` to enable this functionality. (Bug#16753)

- Partition support is not an „engine“, but it was included in the output of `SHOW ENGINES`. Now it is not. (Bug#14355) The `have_partition_engine` was renamed to `have_partitioning`. (Bug#16718)

- `ANALYZE TABLE` is now supported for partitioned tables. (Bug#13441)

- Added the `--both-log-formats` and `--old-log-format` options for controlling whether log files or log tables are used. variable.

- Added the `character_set_filesystem` system variable.

- Added the `event_scheduler` system variable.

- Added the `ndb_extra_logging` system variable.

- Added the `EVENTS` table to `INFORMATION_SCHEMA`.

- Added the `PARTITIONS` table to `INFORMATION_SCHEMA`.

- The `ARCHIVE` storage engine supports the `AUTO_INCREMENT` column attribute and the `AUTO_INCREMENT` table option. Abschnitt 14.8, „Die `ARCHIVE`-Speicher-Engine“.

- Fixed a crash when fulltext search parser plugin returned more words than half of the length (in bytes) of the query string. (Bug#16722)

Bugs fixed:

- `MYSQL_OPT_RECONNECT` option was modified by calls to the `mysql_real_connect()` function. (Bug#15719)

- Specifying a value for `--tmptable` without a trailing slash had unpredictable results. (Bug#15904)

- Attempting to insert data into a partitioned table that used the `BLACKHOLE` storage engine caused mysqld to crash. (Bug#14524)

- Using `RANGE` partitioning with a `CASE` statement as the partitioning function would cause records to be placed in the wrong partition. (Bug#15393)

- `ALTER TABLE ... ADD PARTITIONS` on a table with one partition crashed the server. (Bug#15820)

- NDB Cluster returned incorrect `Can't find file` error for OS error 24, changed to `Too many open files`. (Bug#15020)

- Multi-byte path names for `LOAD DATA` and `SELECT ... INTO OUTFILE` caused errors. (Bug#12448)

- Certain subqueries where the inner query is the result of a aggregate function would return different results on MySQL 5.0 than on MySQL 4.1. (Bug#15347)

- Error message for specifying value for which no partition exists returned wrong values on certain platforms. (Bug#15910)

- Certain Japanese table names were not properly saved during a `CREATE TABLE` statement. (Bug#3906)

- NDB Cluster leaked disk space when performing INSERTS/DELETES in a loop. (Bug#16771)

- NDB Cluster returned wrong error when tablespace on disk was full. (Bug#16738)

- The `DATA DIRECTORY` and `INDEX DIRECTORY` clauses of a `CREATE TABLE` statement involving partitions did not work. (Bug#14354)

- Subselect could return wrong results when records cache and grouping was involved. (Bug#15347)

- In some cases the query optimizer did not properly perform multiple joins where inner joins followed left joins, resulting in corrupted result sets. (Bug#15633)

- The absence of a table in the left part of a left or right join was not checked prior to name resolution, which resulted in a server crash. (Bug#15538)

- `NDB Cluster`: Trying to import too many dumped tables requiring resources beyond those allocated in the cluster configuration would cause the server to crash instead of reporting an insufficient resources error. (Bug#16455)

- `NDB Cluster` (Disk Data): Tablespaces created using parameters with relatively low values (< 10 MB) produced filesizes much smaller than expected. (Bug#16742)

- `NDB Cluster`: `CREATE TABLESPACE` statements were incorrectly parsed on 64-bit platforms. (`INITIAL SIZE `size`` worked, but `INITIAL SIZE = `size`` failed.) (Bug#13556)

- Trying to add more than one partition in a single `ALTER TABLE ... ADD PARTITION` statement caused the server to crash. (Bug#16534)

- Creating a partitioned table using a storage engine other than the session default storage engine caused the server to crash. (Bug#15966)

- An `ALTER TABLE ... PARTITION BY ...` statement did not have any effect. (Bug#15523)

- `NDBCluster` (Disk Data): The error message generated by a failed `ADD UNDOFILE` did not provide any reasons for the failure. (Bug#16267)

- `NDBCluster` (Disk Data): `DROP LOGFILE GROUP` corrupted the cluster file system and caused ndbd to fail when running more than one node on the same system. (Bug#16193)

- `NDBCluster`: A bitfield whose offset and length totaled 32 would crash the cluster. (Bug#16125)

- `NDBCluster`: Upon the completion of a scan where a key request remained outstanding on the primary replica and a starting node died, the scan did not terminate. This caused incompleted error handling of the failed node. (Bug#15908)

- `NDBCluster`: The `ndb_autodiscover` test failed sporadically due to a node not being permitted to connect to the cluster. (Bug#15619)

- Using mysqldump to obtain a dump of a partitioned table employing the `NDB` storage engine produced a non-functional table creation statement. (Bug#13155)

- `SHOW CREATE TABLE` did not display the `PARTITIONS` clause for tables partitioned by `HASH` or `KEY`. (Bug#14327)

- Inserting a negative value into an integer column used as the partitioning key for a table partitioned by `HASH` could cause the server to crash. (Bug#15968)

- With a table partitioned by `LIST`, inserting a value which was smaller than any value shown in the partitioning value-lists could cause the server to crash. (Bug#14365)

- `ALTER TABLE ... DROP PARTITION` would truncate all `DATE` column values in the table's remaining partitions to `NULL`. (Bug#13644)

- `ALTER TABLE ... ADD PARTITION` could crash the server or cause an Out of memory error in some circumstances. (Bug#13447)

- The server would allow foreign keys to be declared in the definition of a partitioned table despite the fact that partitioned tables do not support foreign keys (see Abschnitt 17.4, „Beschränkungen und Grenzen der Partitionierung“). (Bug#13446)

- A `SELECT` from a key-partitioned table with a multi-column key could cause the server to crash. (Bug#13445)

- Issuing a `TRUNCATE` statement twice in succession on the same partitioned table would cause the server to crash. (Bug#13442)

- Using a `REPLACE` statement on a partitioned table caused the server to crash. (Bug#13440)

- Using an identifier rather than a literal integer value in the `LESS THAN` clause of a range-partitioned table could cause the server to crash and corruption of tables. (Bug#13439)

- Using `ENGINE=...` within a `PARTITION` clause could cause the server to crash. (Bug#13438)

- `CREATE TABLE ... LIKE` did not work if the table whose schema was to be copied was a partitoned table. (Bug#13435)

- `SHOW CREATE TABLE` did not display the `PARTITIONS` clause for tables partitioned by `HASH` or `KEY`. (Bug#14327)

- Certain permission management statements could create a `NULL` hostname for a user, resulting in a server crash. (Bug#15598)

- Temporary table aliasing did not work inside stored functions. (Bug#12198)

- Parallel builds occasionally failed on Solaris. (Bug#16282)

### D.1.2. Änderungen in Release 5.1.5 (10. Januar 2006)

Functionality added or changed:

- Added the `INFORMATION_SCHEMA ENGINES` table.

- Added the `INFORMATION_SCHEMA PLUGINS` table and the `SHOW PLUGIN` statement.

- Added the `binlog_format` system variable that controls whether to use row-based or statement-based binary logging. Added the `--binlog-format` and `--binlog-row-event-max-size` server options for binary logging control. See Abschnitt 6.3, „Zeilenbasierte Replikation“.

- Plugins now can have status variables that are displayed in the output from `SHOW STATUS`.

- Added the XML functions `ExtractValue()` and `UpdateXML()`. `ExtractValue()` returns the content of a fragment of XML matching a given XPath expression. `UpdateXML()` replaces the element selected from a fragment of XML by an XPath expression supplied by the user with a second XML fragment (also user-supplied), and returns the modified XML. See Abschnitt 12.9, „XML-Funktionen“.

- Added the `--base64-output` option to mysqlbinlog to print all binary log entries using base64 encoding. This is for debugging only. Logs produced using this option should not be applied on production systems.

- Added the `--port-open-timeout` option to mysqld to control how many seconds the server should wait for the TCP/IP port to become free if it cannot be opened. (Bug#15591)

- Two new Hungarian collations are included: `utf8_hungarian_ci` and `ucs2_hungarian_ci`. These support the correct sort order for Hungarian vowels. However, they do not support the correct order for sorting Hungarian consonant contractions; this issue will be fixed in a future release.

Bugs fixed:

- `InnoDB`: An `UPDATE` statement with no index column in the `WHERE` condition locked all the rows in the table. (Bug#3300)

- `INSERT DELAYED` caused mysqld to crash. (Bug#16095)

- The output of mysqldump --triggers did not contain the `DEFINER` clause in dumped trigger definitions. (Bug#15110)

- The output of `SHOW TRIGGERS` contained extraneous whitespace. (Bug#15103)

- An `INSERT ... SELECT` statement between tables in a `MERGE` set can return errors when statement involves insert into child table from merge table or vice-versa. (Bug#5390)

- A `COMMIT` statement followed by a `ALTER TABLE` statement on a BDB table caused server crash. (Bug#14212)

- `InnoDB`: Comparison of indexed `VARCHAR CHARACTER SET ucs2 COLLATE ucs2_bin` columns using `LIKE` could fail. (Bug#14583)

- Creating a trigger caused a server crash if the table or trigger database was not known because no default database had been selected. (Bug#14863)

- Issuing a `DROP USER` command could cause some users to encounter a ``hostname` is not allowed to connect to this MySQL server` error. (Bug#15775)

- The `--plugin_dir` option was not working. Also fix error with specifying parser name for fulltext. (Bug#16068)

- Attempting to insert into a table partitioned by `LIST` a value less than any specified in one of the table's partition definitions resulted in a server crash. In such cases, mysqld now returns ERROR 1500 (HY000): Table has no partition for value `v` , where `v` is the out-of-range value. (Bug#15819)

### D.1.3. Änderungen in Release 5.1.4 (21. Dezember 2005)

Functionality added or changed:

- Added the mysqlslap program, which is designed to emulate client load for a MySQL server and report the timing of each stage. It works as if multiple clients are accessing the server.

- Added the `--server-id` option to mysqlbinlog to enable only those events created by the server having the given server ID to be extracted. (Bug#15485)

- It is now possible to build the server such that `MyISAM` tables can support up to 128 keys rather than the standard 64. This can be done by configuring the build using the option `--with-max-indexes=`N``, where `N`≤128 is the maximum number of indexes to permit per table. (Bug#10932)

- The bundled `BDB` library was upgraded to version 4.4.16.

- Added the `cp1250_polish_ci` collation for the `cp1250` character set.

- Added the `myisam_use_mmap` system variable.

- Added the `--bdb-data-direct` and `--bdb-log-direct` server options.

Bugs fixed:

- Server could not be built on default Debian systems with BDB enabled. (Bug#15734)

- `BDB`: A `DELETE`, `INSERT`, or `UPDATE` of a `BDB` table could cause the server to crash where the query contained a subquery using an index read. (Bug#15536)

- A left join on a column that having a `NULL` value could cause the server to crash. (Bug#15268)

- It was not possible to reorganize a partition reusing a discarded partition name.

  Now, for example, you can create a table such as this one:

      CREATE TABLE t1 (a INT)
          PARTITION BY RANGE (a) (
            PARTITION p0 VALUES LESS THAN (10),
            PARTITION p1 VALUES LESS THAN (20),
            PARTITION p2 VALUES LESS THAN MAXVALUE
          );

  and then repartition it as shown here:

      ALTER TABLE t1 REORGANIZE PARTITION p2 INTO (
          PARTITION p2 VALUES LESS THAN (30)
      );

  Previously, attempting to do so would produce the error All partitions must have unique names in the table . (Bug#15521)

- `NDB Cluster`: The `--ndb` option for perror did not function. (Bug#15486)

- The `BLACKHOLE` storage engine did not handle transactions properly: Rolled-back transactions were written to the binary log. Now they ae not. (Bug#15406)

- `NDB Cluster`: Using `ORDER BY `primary_key_column`` when selecting from a table having the primary key on a `VARCHAR` column caused a forced shutdown of the cluster. (Bug#14828, Bug#15240, Bug#15682, Bug#15517)

- `ANALYZE TABLE` did not properly update table statistics for a `MyISAM` table with a `FULLTEXT` index containing stopwords, so a subsequent `ANALYZE TABLE` would not recognize the table as having already been analyzed. (Bug#14902)

- The maximum value of `MAX_ROWS` was handled incorrectly on 64-bit systems. (Bug#14155)

- Multiple-table update operations were counting updates and not updated rows. As a result, if a row had several updates it was counted several times for the „rows matched“ value but updated only once. (Bug#15028)

- `SELECT` queries that began with an opening parenthesis were not being placed in the query cache. (Bug#14652)

- Space truncation was being ignored when inserting into `BINARY` or `VARBINARY` columns. Now space truncation results in a warning, or an error in strict mode. (Bug#14299)

- Selecting from a view processed with the temptable algorithm caused a server crash if the query cache was enabled. (Bug#15119)

- Creating a view that referenced a stored function that selected from a view caused a crash upon selection from the view. (Bug#15096)

- Creating a view within a stored procedure could result in an out of memory error or a server crash. (Bug#14885)

- `SHOW CREATE DATABASE` was sometimes refused when the client had privileges for the database. (Bug#9785)

- mysql ignored the `MYSQL_TCP_PORT` environment variable. (Bug#5792)

- `ROW_COUNT()` returned an incorrect result after `EXECUTE` of a prepared statement. (Bug#14956)

- Invalid casts to `DATE` values now result in a message of `Incorrect datetime value`, rather than `Truncated incorrect datetime value`. (Bug#8294)

- Attempts to assign `NULL` to a `NOT NULL` column in strict mode now result in a message of `Column '`col_name`' cannot be null`, rather than `Column set to default value; NULL supplied to NOT NULL column '`col_name`' at row `n``. (Bug#11491)

- For binary string data types, mysqldump --hex-blob produced an illegal output value of `0x` rather than `''`. (Bug#13318)

- Some comparisons for the `IN()` operator were inconsistent with equivalent comparisons for the `=` operator. (Bug#12612)

### D.1.4. Änderungen in Release 5.1.3 (29. November 2005)

Functionality added or changed:

This is the first public alpha release of the current MySQL 5.1 development branch, providing an insight to upcoming features. Although some of these are still under heavy development, this release includes the following new features and changes (in comparison to the current MySQL 5.0 production release):

- Partitioning: allows distributing portions of individual tables across a filesystem, according to rules which can be set when the table is created. In effect, different portions of a table are stored as separate tables in different locations, but from the user point of view, the partitioned table is still a single table. See Kapitel 17, Partitionierung, for further information on this functionality. (Author: Mikael Ronström)

- Plugin API: MySQL 5.1 adds support for a very flexible plugin API that enables loading and unloading of various components at runtime, without restarting the server. Although the work on this is not finished yet, plugin full-text parsers are a first step in this direction. This allows users to implement their own input filter on the indexed text, enabling full-text search capability on arbitrary data such as PDF files or other document formats. A pre-parser full-text plugin performs the actual parsing and extraction of the text and hands it over to the built-in MySQL full-text search. (Author: Sergey Vojtovich)

  The plugin API requires the `mysql.plugin` table. When upgrading from an older version of MySQL, you should run the mysql_fix_privilege_tables command to create this table. See Abschnitt 5.6, „mysql_fix_privilege_tables — Upgrade von MySQL-Systemtabellen“.

  Incompatible change: Plugins are installed in the directory named by the `plugin_dir` system variable. This variable also controls the location from which the server loads user-defined functions (UDFs), which is a change from earlier versions of MySQL. That is, all UDF library files now must be installed in the plugin directory. When upgrading from an older version of MySQL, you must migrate your UDF files to the plugin directory.

- The Instance Manager (IM) now has some additional functionality:

  - `SHOW `instance_name` LOG FILES` provides a listing of all log files used by the instance. (Author: Petr Chardin)

  - `SHOW `instance_name` LOG {ERROR | SLOW | GENERAL} `size`` retrieves a part of the specified log file. (Author: Petr Chardin)

  - `SET `instance_name`. `option_name`=`option_value`` sets an option to the specified value and writes it to the config file See Abschnitt 5.5, „mysqlmanager — Der MySQL Instance Manager“, for more details on these new commands. (Author: Petr Chardin)

- The performance of boolean full-text searches (using the „+“ Operator) has been improved. See Abschnitt 12.7, „MySQL-Volltextsuche“, for more details about full-text searching. (Author: Sergey Vojtovich)

- `VARCHAR` fields used in MySQL Cluster tables are now variable-sized; that is, they now only allocate as much space as required to store the data. Previously, a `VARCHAR(`n`)` column allocated n+2 bytes (aligned to 4 bytes), regardless if the actual inserted value required that much space. (In other words, a `VARCHAR` column always required the same, fixed, amount of storage as a `CHAR` column of the same size.)

- Renamed the `table_cache` system variable to `table_open_cache`. Any scripts that refer to `table_cache` should be updated to use the new name.

- Added the `table_definition_cache` system variable. If you use a large number of tables, you can create a large table definition cache to speed up opening of tables. The table definition cache takes less space and does not use file descriptors, unlike the normal table cache.

Bugs fixed:

- Set functions could not be aggregated in outer subqueries. (Bug#12762)

### D.1.5. Änderungen in Release 5.1.2 (Nicht veröffentlicht)

Functionality added or changed:

- Added `MAXLOCKS`, `MINLOCKS`, `MAXWRITE`, and `MINWRITE` as allowable values of the `--bdb-lock-detect` option. (Bug#14876)

- Added the `bdb_cache_parts` and `bdb_region_size` system variables, and allowed `bdb_cache_size` to be larger than 4GB on systems that support it. (Bug#14895)

- Added `Transactions`, `XA`, and `Savepoints` columns to `SHOW ENGINES` output.

- Added `--replace` to mysqldump. This option uses `REPLACE INTO`, rather than `INSERT INTO`, when writing the dumpfile.

Bugs fixed:

- Foreign keys were not properly enforced in `TEMPORARY` tables. Foreign keys now are disallowed in `TEMPORARY` tables. (Bug#12084)

### D.1.6. Änderungen in Release 5.1.1 (Nicht veröffentlicht)

Functionality added or changed:

Bugs fixed:

- Performing a `CREATE TABLE` statement with a `PARTITION BY` clause in a prepared statement could crash a server running in debug mode. (Bug#12097)

- `NDB`: Specifying the wrong nodegroup in a `CREATE TABLE` using partitioning would lead to the table name being locked after the `CREATE TABLE` statement failed (that is, the table name could not be re-used). (Bug#12114)

- Using `ORDER BY` in a query with a partitioned table on a 64-bit operating system could crash the server. (Bug#12116)

- When two threads compete for the same table, a deadlock could occur if one thread has also a lock on another table through `LOCK TABLES` and the thread is attempting to remove the table in some manner and the other thread want locks on both tables. (Bug#10600)

## D.2. Änderungen in MyODBC

### D.2.1. Änderungen in MyODBC 3.51.13

Functionality added or changed:

- N/A

Bugs fixed:

- The `SQLDriverConnect()` ODBC method did not work with recent MyODBC releases. (Bug#12393)

### D.2.2. Änderungen in MyODBC 3.51.12

Functionality added or changed:

- N/A

Bugs fixed:

- `SQLColumns()` returned no information for tables that had a column named using a reserved word. (Bug#9539)

### D.2.3. Änderungen in MyODBC 3.51.11

Functionality added or changed: No changes.

Bugs fixed:

- `mysql_list_dbcolumns()` and `insert_fields()` were retrieving all rows from a table. Fixed the queries generated by these functions to return no rows. (Bug#8198)

- `SQLGetTypoInfo()` returned `tinyblob` for `SQL_VARBINARY` and nothing for `SQL_BINARY`. Fixed to return `varbinary` for `SQL_VARBINARY`, `binary` for `SQL_BINARY`, and `longblob` for `SQL_LONGVARBINARY`. (Bug#8138)

## D.3. MySQL Connector/J Change History

### D.3.1. Changes in MySQL Connector/J 5.0.3 (26 July 2006)

- Fixed `Statement.cancel()` causes `NullPointerException` if underlying connection has been closed due to server failure. (Bug#20650)

- Added configuration option "noAccessToProcedureBodies" which will cause the driver to create basic parameter metadata for CallableStatements when the user does not have access to procedure bodies via "SHOW CREATE PROCEDURE" or selecting from mysql.proc instead of throwing an exception. The default value for this option is "false"

### D.3.2. Changes in MySQL Connector/J 5.0.2-beta (11 July 2006)

- Fixed can't use `XAConnection` for local transactions when no global transaction is in progress. (Bug#17401)

- Fixed driver fails on non-ASCII platforms. The driver was assuming that the platform character set would be a superset of MySQL's `latin1` when doing the handshake for authentication, and when reading error messages. We now use Cp1252 for all strings sent to the server during the handshake phase, and a hard-coded mapping of the `language` systtem variable to the character set that is used for error messages. (Bug#18086)

- Fixed `ConnectionProperties` (and thus some subclasses) are not serializable, even though some J2EE containers expect them to be. (Bug#19169)

- Fixed `MysqlValidConnectionChecker` for JBoss doesn't work with `MySQLXADataSources`. (Bug#20242)

- Better caching of character set converters (per-connection) to remove a bottleneck for multibyte character sets.

- Added connection/datasource property `pinGlobalTxToPhysicalConnection` (defaults to `false`). When set to `true`, when using `XAConnections`, the driver ensures that operations on a given XID are always routed to the same physical connection. This allows the `XAConnection` to support `XA START ... JOIN` after `XA END` has been called, and is also a workaround for transaction managers that don't maintain thread affinity for a global transaction (most either always maintain thread affinity, or have it as a configuration option).

- `MysqlXaConnection.recover(int flags)` now allows combinations of `XAResource.TMSTARTRSCAN` and `TMENDRSCAN`. To simulate the „scanning“ nature of the interface, we return all prepared XIDs for `TMSTARTRSCAN`, and no new XIDs for calls with `TMNOFLAGS`, or `TMENDRSCAN` when not in combination with `TMSTARTRSCAN`. This change was made for API compliance, as well as integration with IBM WebSphere's transaction manager.

### D.3.3. Changes in MySQL Connector/J 5.0.1-beta (Not Released)

Not released due to a packaging error

### D.3.4. Changes in MySQL Connector/J 5.0.0-beta (22 December 2005)

- `XADataSource` implemented (ported from 3.2 branch which won't be released as a product). Use `com.mysql.jdbc.jdbc2.optional.MysqlXADataSource` as your datasource class name in your application server to utilize XA transactions in MySQL-5.0.10 and newer.

- `PreparedStatement.setString()` didn't work correctly when `sql_mode` on server contained `NO_BACKSLASH_ESCAPES` and no characters that needed escaping were present in the string.

- Attempt detection of the MySQL type `BINARY` (it's an alias, so this isn't always reliable), and use the `java.sql.Types.BINARY` type mapping for it.

- Moved `-bin-g.jar` file into separate `debug` subdirectory to avoid confusion.

- Don't allow `.setAutoCommit(true)`, or `.commit()` or `.rollback()` on an XA-managed connection as per the JDBC specification.

- If the connection `useTimezone` is set to `true`, then also respect time zone conversions in escape-processed string literals (for example, `"{ts ...}"` and `"{t ...}"`).

- Return original column name for `RSMD.getColumnName()` if the column was aliased, alias name for `.getColumnLabel()` (if aliased), and original table name for `.getTableName()`. Note this only works for MySQL-4.1 and newer, as older servers don't make this information available to clients.

- Setting `useJDBCCompliantTimezoneShift=true` (it's not the default) causes the driver to use GMT for all `TIMESTAMP`/`DATETIME` time zones, and the current VM time zone for any other type that refers to time zones. This feature can not be used when `useTimezone=true` to convert between server and client time zones.

- Add one level of indirection of internal representation of `CallableStatement` parameter metadata to avoid class not found issues on JDK-1.3 for `ParameterMetadata` interface (which doesn't exist prior to JDBC-3.0).

- Added unit tests for `XADatasource`, as well as friendlier exceptions for XA failures compared to the "stock" `XAException` (which has no messages).

- Idle timeouts cause `XAConnections` to whine about rolling themselves back. (Bug#14729)

- Added support for Connector/MXJ integration via url subprotocol `jdbc:mysql:mxj://...`.

- Moved all `SQLException` constructor usage to a factory in `SQLError` (ground-work for JDBC-4.0 `SQLState`-based exception classes).

- Removed Java5-specific calls to `BigDecimal` constructor (when result set value is `''`, `(int)0` was being used as an argument indirectly via method return value. This signature doesn't exist prior to Java5.)

- Added service-provider entry to `META-INF/services/java.sql.Driver` for JDBC-4.0 support.

- Return "[VAR]BINARY" for `RSMD.getColumnTypeName()` when that is actually the type, and it can be distinguished (MySQL-4.1 and newer).

- When fix for Bug#14562 was merged from 3.1.12, added functionality for `CallableStatement`'s parameter metadata to return correct information for `.getParameterClassName()`.

- Fuller synchronization of `Connection` to avoid deadlocks when using multithreaded frameworks that multithread a single connection (usually not recommended, but the JDBC spec allows it anyways), part of fix to Bug#14972).

- Implementation of `Statement.cancel()` and `Statement.setQueryTimeout()`. Both require MySQL-5.0.0 or newer server, require a separate connection to issue the `KILL QUERY` statement, and in the case of `setQueryTimeout()` creates an additional thread to handle the timeout functionality.

  Note: Failures to cancel the statement for `setQueryTimeout()` may manifest themselves as `RuntimeExceptions` rather than failing silently, as there is currently no way to unblock the thread that is executing the query being cancelled due to timeout expiration and have it throw the exception instead.

### D.3.5. Changes in MySQL Connector/J 3.1.14 (not yet released)

- Fixed updatable result set throws ClassCastException when there is row data and moveToInsertRow() is called. (Fixes Bug#20479)

- Fixed Updatable result set that contains a BIT column fails when server-side prepared statements are used. (Fixes Bug#20485)

- Fixed memory leak with profileSQL=true. (Fixes Bug#16987)

- Connection fails to localhost when using timeout and IPv6 is configured. (Fixes Bug#19726)

- Fixed NullPointerException in MysqlDataSourceFactory due to Reference containing RefAddrs with null content. (Fixes Bug#16791)

- Fixed ResultSet.getShort() for UNSIGNED TINYINT returns incorrect values when using server-side prepared statements. (Fixes Bug#20306)

- Fixed can't pool server-side prepared statements, exception raised when re-using them. (Fixes Bug#20687)

- Fixed Bug#21062 - ResultSet.getSomeInteger() doesn't work for BIT(>1).

- Fixed Bug#18880 - ResultSet.getFloatFromString() can't retrieve values near Float.MIN/MAX_VALUE.

- Fixed Bug#20888 - escape of quotes in client-side prepared statements parsing not respected. Patch covers more than bug report, including NO_BACKSLASH_ESCAPES being set, and stacked quote characters forms of escaping (i.e. '' or "").

- Fixed Bug#19993 - ReplicationDriver does not always round-robin load balance depending on URL used for slaves list.

### D.3.6. Changes in MySQL Connector/J 3.1.13 (26 May 2006)

- `INOUT` parameter does not store `IN` value. (Bug#15464)

- Exception thrown for new decimal type when using updatable result sets. (Bug#14609)

- No "dos" character set in MySQL > 4.1.0. (Bug#15544)

- `PreparedStatement.setObject()` serializes `BigInteger` as object, rather than sending as numeric value (and is thus not complementary to `.getObject()` on an `UNSIGNED LONG` type). (Bug#15383)

- `ResultSet.getShort()` for `UNSIGNED TINYINT` returned wrong values. (Bug#11874)

- `lib-nodist` directory missing from package breaks out-of-box build. (Bug#15676)

- `DBMD.getColumns()` returns wrong type for `BIT`. (Bug#15854)

- Fixed issue where driver was unable to initialize character set mapping tables. Removed reliance on `.properties` files to hold this information, as it turns out to be too problematic to code around class loader hierarchies that change depending on how an application is deployed. Moved information back into the `CharsetMapping` class. (Bug#14938)

- Fixed updatable result set doesn't return `AUTO_INCREMENT` values for `insertRow()` when multiple column primary keys are used. (the driver was checking for the existence of single-column primary keys and an autoincrement value > 0 instead of a straightforward `isAutoIncrement()` check). (Bug#16841)

- Fixed `Statement.getGeneratedKeys()` throws `NullPointerException` when no query has been processed. (Bug#17099)

- Fixed driver trying to call methods that don't exist on older and newer versions of Log4j. The fix is not trying to auto-detect presense of log4j, too many different incompatible versions out there in the wild to do this reliably. (Bug#13469)

  If you relied on autodetection before, you will need to add "logger=com.mysql.jdbc.log.Log4JLogger" to your JDBC URL to enable Log4J usage, or alternatively use the new "CommonsLogger" class to take care of this.

- Added support for Apache Commons logging, use "com.mysql.jdbc.log.CommonsLogger" as the value for the "logger" configuration property.

- LogFactory now prepends "com.mysql.jdbc.log" to log class name if it can't be found as-specified. This allows you to use "short names" for the built-in log factories, for example "logger=CommonsLogger" instead of "logger=com.mysql.jdbc.log.CommonsLogger".

- Fixed issue with `ReplicationConnection` incorrectly copying state, doesn't transfer connection context correctly when transitioning between the same read-only states. (Bug#15570)

- Fixed issue where server-side prepared statements don't cause truncation exceptions to be thrown when truncation happens. (Bug#18041)

- Added performance feature, re-writing of batched executes for `Statement.executeBatch()` (for all DML statements) and `PreparedStatement.executeBatch()` (for INSERTs with VALUE clauses only). Enable by using "rewriteBatchedStatements=true" in your JDBC URL.

- Fixed `CallableStatement.registerOutParameter()` not working when some parameters pre-populated. Still waiting for feedback from JDBC experts group to determine what correct parameter count from `getMetaData()` should be, however. (Bug#17898)

- Fixed calling `clearParameters()` on a closed prepared statement causes NPE. (Bug#17587)

- Map "latin1" on MySQL server to CP1252 for MySQL > 4.1.0.

- Added additional accessor and mutator methods on ConnectionProperties so that DataSource users can use same naming as regular URL properties.

- Fixed data truncation and `getWarnings()` only returns last warning in set. (Bug#18740)

- Improved performance of retrieving `BigDecimal`, `Time`, `Timestamp` and `Date` values from server-side prepared statements by creating fewer short-lived instances of `Strings` when the native type is not an exact match for the requested type. Fixes Bug#18496 for `BigDecimals`.

- Fixed aliased column names where length of name > 251 are corrupted. (Bug#18554)

- Fixed `ResultSet.wasNull()` not always reset correctly for booleans when done via conversion for server-side prepared statements. (Bug#17450)

- Fixed invalid classname returned for `ResultSetMetaData.getColumnClassName()` for `BIGINT type`. (Bug#19282)

- Fixed case where driver wasn't reading server status correctly when fetching server-side prepared statement rows, which in some cases could cause warning counts to be off, or multiple result sets to not be read off the wire.

- Driver now aware of fix for `BIT` type metadata that went into MySQL-5.0.21 for server not reporting length consistently (Bug#13601).

- `Fixed PreparedStatement.setObject(int, Object, int)` doesn't respect scale of BigDecimals. (Bug#19615)

- Fixed `ResultSet.wasNull()` returns incorrect value when extracting native string from server-side prepared statement generated result set. (Bug#19282)

### D.3.7. Changes in MySQL Connector/J 3.1.12 (30 November 2005)

- Fixed client-side prepared statement bug with embedded `?` characters inside quoted identifiers (it was recognized as a placeholder, when it was not).

- Don't allow `executeBatch()` for `CallableStatements` with registered `OUT`/`INOUT` parameters (JDBC compliance).

- Fall back to platform-encoding for `URLDecoder.decode()` when parsing driver URL properties if the platform doesn't have a two-argument version of this method.

- Java type conversion may be incorrect for `MEDIUMINT`. (Bug#14562)

- Added configuration property `useGmtMillisForDatetimes` which when set to `true` causes `ResultSet.getDate()`, `.getTimestamp()` to return correct millis-since GMT when `.getTime()` is called on the return value (currently default is `false` for legacy behavior).

- Fixed `DatabaseMetaData.stores*Identifiers()`:

  - If `lower_case_table_names=0` (on server):

    - `storesLowerCaseIdentifiers()` returns `false`

    - `storesLowerCaseQuotedIdentifiers()` returns `false`

    - `storesMixedCaseIdentifiers()` returns `true`

    - `storesMixedCaseQuotedIdentifiers()` returns `true`

    - `storesUpperCaseIdentifiers()` returns `false`

    - `storesUpperCaseQuotedIdentifiers()` returns `true`

  - If `lower_case_table_names=1` (on server):

    - `storesLowerCaseIdentifiers()` returns `true`

    - `storesLowerCaseQuotedIdentifiers()` returns `true`

    - `storesMixedCaseIdentifiers()` returns `false`

    - `storesMixedCaseQuotedIdentifiers()` `returns false`

    - `storesUpperCaseIdentifiers()` returns `false`

    - `storesUpperCaseQuotedIdentifiers()` returns `true`

- `DatabaseMetaData.getColumns()` doesn't return `TABLE_NAME` correctly. (Bug#14815)

- Escape processor replaces quote character in quoted string with string delimiter. (Bug#14909)

- OpenOffice expects `DBMD.supportsIntegrityEnhancementFacility()` to return `true` if foreign keys are supported by the datasource, even though this method also covers support for check constraints, which MySQL doesn't have. Setting the configuration property `overrideSupportsIntegrityEnhancementFacility` to `true` causes the driver to return `true` for this method. (Bug#12975)

- Added `com.mysql.jdbc.testsuite.url.default` system property to set default JDBC url for testsuite (to speed up bug resolution when I'm working in Eclipse).

- Unable to initialize character set mapping tables (due to J2EE classloader differences). (Bug#14938)

- Deadlock while closing server-side prepared statements from multiple threads sharing one connection. (Bug#14972)

- `logSlowQueries` should give better info. (Bug#12230)

- Extraneous sleep on `autoReconnect`. (Bug#13775)

- Driver incorrectly closes streams passed as arguments to `PreparedStatements`. Reverts to legacy behavior by setting the JDBC configuration property `autoClosePStmtStreams` to `true` (also included in the 3-0-Compat configuration „bundle“). (Bug#15024)

- `maxQuerySizeToLog` is not respected. Added logging of bound values for `execute()` phase of server-side prepared statements when `profileSQL=true` as well. (Bug#13048)

- Usage advisor complains about unreferenced columns, even though they've been referenced. (Bug#15065)

- Don't increase timeout for failover/reconnect. (Bug#6577)

- Process escape tokens in `Connection.prepareStatement(...)`. (Bug#15141) You can disable this behavior by setting the JDBC URL configuration property `processEscapeCodesForPrepStmts` to `false`.

- Reconnect during middle of `executeBatch()` should not occur if `autoReconnect` is enabled. (Bug#13255)

### D.3.8. Changes in MySQL Connector/J 3.1.11-stable (07 October 2005)

- Spurious `!` on console when character encoding is `utf8`. (Bug#11629)

- Fixed statements generated for testcases missing `;` for „plain“ statements.

- Incorrect generation of testcase scripts for server-side prepared statements. (Bug#11663)

- Fixed regression caused by fix for Bug#11552 that caused driver to return incorrect values for unsigned integers when those integers where within the range of the positive signed type.

- Moved source code to Subversion repository.

- Escape tokenizer doesn't respect stacked single quotes for escapes. (Bug#11797)

- `GEOMETRY` type not recognized when using server-side prepared statements.

- `ReplicationConnection` won't switch to slave, throws „Catalog can't be null“ exception. (Bug#11879)

- Properties shared between master and slave with replication connection. (Bug#12218)

- `Statement.getWarnings()` fails with NPE if statement has been closed. (Bug#10630)

- Only get `char[]` from SQL in `PreparedStatement.ParseInfo()` when needed.

- Geometry types not handled with server-side prepared statements. (Bug#12104)

- `StringUtils.getBytes()` doesn't work when using multi-byte character encodings and a length in characters is specified. (Bug#11614)

- `Pstmt.setObject(...., Types.BOOLEAN)` throws exception. (Bug#11798)

- `maxPerformance.properties` mis-spells „elideSetAutoCommits“. (Bug#11976)

- `DBMD.storesLower/Mixed/UpperIdentifiers()` reports incorrect values for servers deployed on Windows. (Bug#11575)

- `ResultSet.moveToCurrentRow()` fails to work when preceded by a call to `ResultSet.moveToInsertRow()`. (Bug#11190)

- `VARBINARY` data corrupted when using server-side prepared statements and `.setBytes()`. (Bug#11115)

- `explainSlowQueries` hangs with server-side prepared statements. (Bug#12229)

- Escape processor didn't honor strings demarcated with double quotes. (Bug#11498)

- Lifted restriction of changing streaming parameters with server-side prepared statements. As long as `all` streaming parameters were set before execution, `.clearParameters()` does not have to be called. (due to limitation of client/server protocol, prepared statements can not reset individual stream data on the server side).

- Reworked `Field` class, `*Buffer`, and `MysqlIO` to be aware of field lengths > `Integer.MAX_VALUE`.

- Updated `DBMD.supportsCorrelatedQueries()` to return `true` for versions > 4.1, `supportsGroupByUnrelated()` to return `true` and `getResultSetHoldability()` to return `HOLD_CURSORS_OVER_COMMIT`.

- Handling of catalog argument in `DatabaseMetaData.getIndexInfo()`, which also means changes to the following methods in `DatabaseMetaData`: (Bug#12541)

  - `getBestRowIdentifier()`

  - `getColumns()`

  - `getCrossReference()`

  - `getExportedKeys()`

  - `getImportedKeys()`

  - `getIndexInfo()`

  - `getPrimaryKeys()`

  - `getProcedures()` (and thus indirectly `getProcedureColumns()`)

  - `getTables()`

  The `catalog` argument in all of these methods now behaves in the following way:

  - Specifying `NULL` means that catalog will not be used to filter the results (thus all databases will be searched), unless you've set `nullCatalogMeansCurrent=true` in your JDBC URL properties.

  - Specifying `""` means „current“ catalog, even though this isn't quite JDBC spec compliant, it's there for legacy users.

  - Specifying a catalog works as stated in the API docs.

  - Made `Connection.clientPrepare()` available from „wrapped“ connections in the `jdbc2.optional` package (connections built by `ConnectionPoolDataSource` instances).

- Added `Connection.isMasterConnection()` for clients to be able to determine if a multi-host master/slave connection is connected to the first host in the list.

- Tokenizer for `=` in URL properties was causing `sessionVariables=....` to be parameterized incorrectly. (Bug#12753)

- Foreign key information that is quoted is parsed incorrectly when `DatabaseMetaData` methods use that information. (Bug#11781)

- The `sendBlobChunkSize` property is now clamped to `max_allowed_packet` with consideration of stream buffer size and packet headers to avoid `PacketTooBigExceptions` when `max_allowed_packet` is similar in size to the default `sendBlobChunkSize` which is 1M.

- `CallableStatement.clearParameters()` now clears resources associated with `INOUT`/`OUTPUT` parameters as well as `INPUT` parameters.

- `Connection.prepareCall()` is database name case-sensitive (on Windows systems). (Bug#12417)

- `cp1251` incorrectly mapped to `win1251` for servers newer than 4.0.x. (Bug#12752)

- `java.sql.Types.OTHER` returned for `BINARY` and `VARBINARY` columns when using `DatabaseMetaData.getColumns()`. (Bug#12970)

- `ServerPreparedStatement.getBinding()` now checks if the statement is closed before attempting to reference the list of parameter bindings, to avoid throwing a `NullPointerException`.

- `ResultSetMetaData` from `Statement.getGeneratedKeys()` caused a `NullPointerException` to be thrown whenever a method that required a connection reference was called. (Bug#13277)

- Backport of `Field` class, `ResultSetMetaData.getColumnClassName()`, and `ResultSet.getObject(int)` changes from 5.0 branch to fix behavior surrounding `VARCHAR BINARY`/`VARBINARY` and related types.

- Fixed `NullPointerException` when converting `catalog` parameter in many `DatabaseMetaDataMethods` to `byte[]`s (for the result set) when the parameter is `null`. (`null` isn't technically allowed by the JDBC specification, but we've historically allowed it).

- Backport of `VAR[BINARY|CHAR] [BINARY]` types detection from 5.0 branch.

- Read response in `MysqlIO.sendFileToServer()`, even if the local file can't be opened, otherwise next query issued will fail, because it's reading the response to the empty `LOAD DATA INFILE` packet sent to the server.

- Workaround for Bug#13374: `ResultSet.getStatement()` on closed result set returns `NULL` (as per JDBC 4.0 spec, but not backward-compatible). Set the connection property `retainStatementAfterResultSetClose` to `true` to be able to retrieve a `ResultSet`'s statement after the `ResultSet` has been closed via `.getStatement()` (the default is `false`, to be JDBC-compliant and to reduce the chance that code using JDBC leaks `Statement` instances).

- URL configuration parameters don't allow ‘`&`’ or ‘`=`’ in their values. The JDBC driver now parses configuration parameters as if they are encoded using the application/x-www-form-urlencoded format as specified by `java.net.URLDecoder` (http://java.sun.com/j2se/1.5.0/docs/api/java/net/URLDecoder.html). (Bug#13453)

  If the ‘`%`’ character is present in a configuration property, it must now be represented as `%25`, which is the encoded form of ‘`%`’ when using application/x-www-form-urlencoded encoding.

- The configuration property `sessionVariables` now allows you to specify variables that start with the ‘`@`’ sign.

- When `gatherPerfMetrics` is enabled for servers older than 4.1.0, a `NullPointerException` is thrown from the constructor of `ResultSet` if the query doesn't use any tables. (Bug#13043)

### D.3.9. Changes in MySQL Connector/J 3.1.10-stable (23 June 2005)

- Fixed connecting without a database specified raised an exception in `MysqlIO.changeDatabaseTo()`.

- Initial implemention of `ParameterMetadata` for `PreparedStatement.getParameterMetadata()`. Only works fully for `CallableStatements`, as current server-side prepared statements return every parameter as a `VARCHAR` type.

### D.3.10. Changes in MySQL Connector/J 3.1.9-stable (22 June 2005)

- Overhaul of character set configuration, everything now lives in a properties file.

- Driver now correctly uses CP932 if available on the server for Windows-31J, CP932 and MS932 java encoding names, otherwise it resorts to SJIS, which is only a close approximation. Currently only MySQL-5.0.3 and newer (and MySQL-4.1.12 or .13, depending on when the character set gets backported) can reliably support any variant of CP932.

- `com.mysql.jdbc.PreparedStatement.ParseInfo` does unnecessary call to `toCharArray()`. (Bug#9064)

- Memory leak in `ServerPreparedStatement` if `serverPrepare()` fails. (Bug#10144)

- Actually write manifest file to correct place so it ends up in the binary jar file.

- Added `createDatabaseIfNotExist` property (default is `false`), which will cause the driver to ask the server to create the database specified in the URL if it doesn't exist. You must have the appropriate privileges for database creation for this to work.

- Unsigned `SMALLINT` treated as signed for `ResultSet.getInt()`, fixed all cases for `UNSIGNED` integer values and server-side prepared statements, as well as `ResultSet.getObject()` for `UNSIGNED TINYINT`. (Bug#10156)

- Double quotes not recognized when parsing client-side prepared statements. (Bug#10155)

- Made `enableStreamingResults()` visible on `com.mysql.jdbc.jdbc2.optional.StatementWrapper`.

- Made `ServerPreparedStatement.asSql()` work correctly so auto-explain functionality would work with server-side prepared statements.

- Made JDBC2-compliant wrappers public in order to allow access to vendor extensions.

- Cleaned up logging of profiler events, moved code to dump a profiler event as a string to `com.mysql.jdbc.log.LogUtils` so that third parties can use it.

- `DatabaseMetaData.supportsMultipleOpenResults()` now returns `true`. The driver has supported this for some time, DBMD just missed that fact.

- Driver doesn't support `{?=CALL(...)}` for calling stored functions. This involved adding support for function retrieval to `DatabaseMetaData.getProcedures()` and `getProcedureColumns()` as well. (Bug#10310)

- `SQLException` thrown when retrieving `YEAR(2)` with `ResultSet.getString()`. The driver will now always treat `YEAR` types as `java.sql.Dates` and return the correct values for `getString()`. Alternatively, the `yearIsDateType` connection property can be set to `false` and the values will be treated as `SHORT`s. (Bug#10485)

- The datatype returned for `TINYINT(1)` columns when `tinyInt1isBit=true` (the default) can be switched between `Types.BOOLEAN` and `Types.BIT` using the new configuration property `transformedBitIsBoolean`, which defaults to `false`. If set to `false` (the default), `DatabaseMetaData.getColumns()` and `ResultSetMetaData.getColumnType()` will return `Types.BOOLEAN` for `TINYINT(1)` columns. If `true`, `Types.BOOLEAN` will be returned instead. Regardless of this configuration property, if `tinyInt1isBit` is enabled, columns with the type `TINYINT(1)` will be returned as `java.lang.Boolean` instances from `ResultSet.getObject(...)`, and `ResultSetMetaData.getColumnClassName()` will return `java.lang.Boolean`.

- `SQLException` is thrown when using property `characterSetResults` with `cp932` or `eucjpms`. (Bug#10496)

- Reorganized directory layout. Sources now are in `src` folder. Don't pollute parent directory when building, now output goes to `./build`, distribution goes to `./dist`.

- Added support/bug hunting feature that generates `.sql` test scripts to `STDERR` when `autoGenerateTestcaseScript` is set to `true`.

- 0-length streams not sent to server when using server-side prepared statements. (Bug#10850)

- Setting `cachePrepStmts=true` now causes the `Connection` to also cache the check the driver performs to determine if a prepared statement can be server-side or not, as well as caches server-side prepared statements for the lifetime of a connection. As before, the `prepStmtCacheSize` parameter controls the size of these caches.

- Try to handle `OutOfMemoryErrors` more gracefully. Although not much can be done, they will in most cases close the connection they happened on so that further operations don't run into a connection in some unknown state. When an OOM has happened, any further operations on the connection will fail with a „Connection closed“ exception that will also list the OOM exception as the reason for the implicit connection close event.

- Don't send `COM_RESET_STMT` for each execution of a server-side prepared statement if it isn't required.

- Driver detects if you're running MySQL-5.0.7 or later, and does not scan for `LIMIT ?[,?]` in statements being prepared, as the server supports those types of queries now.

- `VARBINARY` data corrupted when using server-side prepared statements and `ResultSet.getBytes()`. (Bug#11115)

- `Connection.setCatalog()` is now aware of the `useLocalSessionState` configuration property, which when set to `true` will prevent the driver from sending `USE ...` to the server if the requested catalog is the same as the current catalog.

- Added the following configuration bundles, use one or many via the `useConfigs` configuration property:

  - `maxPerformance` — maximum performance without being reckless

  - `solarisMaxPerformance` — maximum performance for Solaris, avoids syscalls where it can

  - `3-0-Compat` — Compatibility with Connector/J 3.0.x functionality

- Added `maintainTimeStats` configuration property (defaults to `true`), which tells the driver whether or not to keep track of the last query time and the last successful packet sent to the server's time. If set to `false`, removes two syscalls per query.

- `autoReconnect` ping causes exception on connection startup. (Bug#11259)

- Connector/J dumping query into `SQLException` twice. (Bug#11360)

- Fixed `PreparedStatement.setClob()` not accepting `null` as a parameter.

- Production package doesn't include JBoss integration classes. (Bug#11411)

- Removed nonsensical „costly type conversion“ warnings when using usage advisor.

### D.3.11. Changes in MySQL Connector/J 3.1.8-stable (14 April 2005)

- Fixed `DatabaseMetaData.getTables()` returning views when they were not asked for as one of the requested table types.

- Added support for new precision-math `DECIMAL` type in MySQL 5.0.3 and up.

- Fixed `ResultSet.getTime()` on a `NULL` value for server-side prepared statements throws NPE.

- Made `Connection.ping()` a public method.

- `DATE_FORMAT()` queries returned as `BLOB`s from `getObject()`. (Bug#8868)

- `ServerPreparedStatements` now correctly „stream“ `BLOB`/`CLOB` data to the server. You can configure the threshold chunk size using the JDBC URL property `blobSendChunkSize` (the default is 1MB).

- `BlobFromLocator` now uses correct identifier quoting when generating prepared statements.

- Server-side session variables can be preset at connection time by passing them as a comma-delimited list for the connection property `sessionVariables`.

- Fixed regression in `ping()` for users using `autoReconnect=true`.

- `PreparedStatement.addBatch()` doesn't work with server-side prepared statements and streaming `BINARY` data. (Bug#9040)

- `DBMD.supportsMixedCase*Identifiers()` returns wrong value on servers running on case-sensitive filesystems. (Bug#8800)

- Cannot use `UTF-8` for characterSetResults configuration property. (Bug#9206)

- A continuation of Bug#8868, where functions used in queries that should return non-string types when resolved by temporary tables suddenly become opaque binary strings (work-around for server limitation). Also fixed fields with type of `CHAR(n) CHARACTER SET BINARY` to return correct/matching classes for `RSMD.getColumnClassName()` and `ResultSet.getObject()`. (Bug#9236)

- `DBMD.supportsResultSetConcurrency()` not returning `true` for forward-only/read-only result sets (we obviously support this). (Bug#8792)

- `DATA_TYPE` column from `DBMD.getBestRowIdentifier()` causes `ArrayIndexOutOfBoundsException` when accessed (and in fact, didn't return any value). (Bug#8803)

- Check for empty strings (`''`) when converting `CHAR`/`VARCHAR` column data to numbers, throw exception if `emptyStringsConvertToZero` configuration property is set to `false` (for backward-compatibility with 3.0, it is now set to `true` by default, but will most likely default to `false` in 3.2).

- `PreparedStatement.getMetaData()` inserts blank row in database under certain conditions when not using server-side prepared statements. (Bug#9320)

- `Connection.canHandleAsPreparedStatement()` now makes „best effort“ to distinguish `LIMIT` clauses with placeholders in them from ones without in order to have fewer false positives when generating work-arounds for statements the server cannot currently handle as server-side prepared statements.

- Fixed `build.xml` to not compile `log4j` logging if `log4j` not available.

- Added support for the c3p0 connection pool's (http://c3p0.sf.net/) validation/connection checker interface which uses the lightweight `COM_PING` call to the server if available. To use it, configure your c3p0 connection pool's `connectionTesterClassName` property to use `com.mysql.jdbc.integration.c3p0.MysqlConnectionTester`.

- Better detection of `LIMIT` inside/outside of quoted strings so that the driver can more correctly determine whether a prepared statement can be prepared on the server or not.

- Stored procedures with same name in different databases confuse the driver when it tries to determine parameter counts/types. (Bug#9319)

- Added finalizers to `ResultSet` and `Statement` implementations to be JDBC spec-compliant, which requires that if not explicitly closed, these resources should be closed upon garbage collection.

- Stored procedures with `DECIMAL` parameters with storage specifications that contained ‘`,`’ in them would fail. (Bug#9682)

- `PreparedStatement.setObject(int, Object, int type, int scale)` now uses scale value for `BigDecimal` instances.

- `Statement.getMoreResults()` could throw NPE when existing result set was `.close()`d. (Bug#9704)

- The performance metrics feature now gathers information about number of tables referenced in a SELECT.

- The logging system is now automatically configured. If the value has been set by the user, via the URL property `logger` or the system property `com.mysql.jdbc.logger`, then use that, otherwise, autodetect it using the following steps:

  1. Log4j, if it's available,

  2. Then JDK1.4 logging,

  3. Then fallback to our `STDERR` logging.

- `DBMD.getTables()` shouldn't return tables if views are asked for, even if the database version doesn't support views. (Bug#9778)

- Fixed driver not returning `true` for `-1` when `ResultSet.getBoolean()` was called on result sets returned from server-side prepared statements.

- Added a `Manifest.MF` file with implementation information to the `.jar` file.

- More tests in `Field.isOpaqueBinary()` to distinguish opaque binary (that is, fields with type `CHAR(n)` and `CHARACTER SET BINARY`) from output of various scalar and aggregate functions that return strings.

- Should accept `null` for catalog (meaning use current) in DBMD methods, even though it's not JDBC-compliant for legacy's sake. Disable by setting connection property `nullCatalogMeansCurrent` to `false` (which will be the default value in C/J 3.2.x). (Bug#9917)

- Should accept `null` for name patterns in DBMD (meaning ‘`%`’), even though it isn't JDBC compliant, for legacy's sake. Disable by setting connection property `nullNamePatternMatchesAll` to `false` (which will be the default value in C/J 3.2.x). (Bug#9769)

### D.3.12. Changes in MySQL Connector/J 3.1.7-stable (18 February 2005)

- Timestamp key column data needed `_binary` stripped for `UpdatableResultSet.refreshRow()`. (Bug#7686)

- Timestamps converted incorrectly to strings with server-side prepared statements and updatable result sets. (Bug#7715)

- Detect new `sql_mode` variable in string form (it used to be integer) and adjust quoting method for strings appropriately.

- Added `holdResultsOpenOverStatementClose` property (default is `false`), that keeps result sets open over statement.close() or new execution on same statement (suggested by Kevin Burton).

- Infinite recursion when „falling back“ to master in failover configuration. (Bug#7952)

- Disable multi-statements (if enabled) for MySQL-4.1 versions prior to version 4.1.10 if the query cache is enabled, as the server returns wrong results in this configuration.

- Fixed duplicated code in `configureClientCharset()` that prevented `useOldUTF8Behavior=true` from working properly.

- Removed `dontUnpackBinaryResults` functionality, the driver now always stores results from server-side prepared statements as is from the server and unpacks them on demand.

- Emulated locators corrupt binary data when using server-side prepared statements. (Bug#8096)

- Fixed synchronization issue with `ServerPreparedStatement.serverPrepare()` that could cause deadlocks/crashes if connection was shared between threads.

- By default, the driver now scans SQL you are preparing via all variants of `Connection.prepareStatement()` to determine if it is a supported type of statement to prepare on the server side, and if it is not supported by the server, it instead prepares it as a client-side emulated prepared statement. You can disable this by passing `emulateUnsupportedPstmts=false` in your JDBC URL. (Bug#4718)

- Remove `_binary` introducer from parameters used as in/out parameters in `CallableStatement`.

- Always return `byte[]`s for output parameters registered as `*BINARY`.

- Send correct value for „boolean“ `true` to server for `PreparedStatement.setObject(n, "true", Types.BIT)`.

- Fixed bug with Connection not caching statements from `prepareStatement()` when the statement wasn't a server-side prepared statement.

- Choose correct „direction“ to apply time adjustments when both client and server are in GMT time zone when using `ResultSet.get(..., cal)` and `PreparedStatement.set(...., cal)`.

- Added `dontTrackOpenResources` option (default is `false`, to be JDBC compliant), which helps with memory use for non-well-behaved apps (that is, applications that don't close `Statement` objects when they should).

- `ResultSet.getString()` doesn't maintain format stored on server, bug fix only enabled when `noDatetimeStringSync` property is set to `true` (the default is `false`). (Bug#8428)

- Fixed NPE in `ResultSet.realClose()` when using usage advisor and result set was already closed.

- `PreparedStatements` not creating streaming result sets. (Bug#8487)

- Don't pass `NULL` to `String.valueOf()` in `ResultSet.getNativeConvertToString()`, as it stringifies it (that is, returns `null`), which is not correct for the method in question.

- `ResultSet.getBigDecimal()` throws exception when rounding would need to occur to set scale. The driver now chooses a rounding mode of „half up“ if non-rounding `BigDecimal.setScale()` fails. (Bug#8424)

- Added `useLocalSessionState` configuration property, when set to `true` the JDBC driver trusts that the application is well-behaved and only sets autocommit and transaction isolation levels using the methods provided on `java.sql.Connection`, and therefore can manipulate these values in many cases without incurring round-trips to the database server.

- Added `enableStreamingResults()` to `Statement` for connection pool implementations that check `Statement.setFetchSize()` for specification-compliant values. Call `Statement.setFetchSize(>=0)` to disable the streaming results for that statement.

- Added support for `BIT` type in MySQL-5.0.3. The driver will treat `BIT(1-8)` as the JDBC standard `BIT` type (which maps to `java.lang.Boolean`), as the server does not currently send enough information to determine the size of a bitfield when < 9 bits are declared. `BIT(>9)` will be treated as `VARBINARY`, and will return `byte[]` when `getObject()` is called.

### D.3.13. Changes in MySQL Connector/J 3.1.6-stable (23 December 2004)

- Fixed hang on `SocketInputStream.read()` with `Statement.setMaxRows()` and multiple result sets when driver has to truncate result set directly, rather than tacking a `LIMIT `n`` on the end of it.

- `DBMD.getProcedures()` doesn't respect catalog parameter. (Bug#7026)

### D.3.14. Changes in MySQL Connector/J 3.1.5-gamma (02 December 2004)

- Fix comparisons made between string constants and dynamic strings that are converted with either `toUpperCase()` or `toLowerCase()` to use `Locale.ENGLISH`, as some locales „override“ case rules for English. Also use `StringUtils.indexOfIgnoreCase()` instead of `.toUpperCase().indexOf()`, avoids creating a very short-lived transient `String` instance.

- Server-side prepared statements did not honor `zeroDateTimeBehavior` property, and would cause class-cast exceptions when using `ResultSet.getObject()`, as the all-zero string was always returned. (Bug#5235)

- Fixed batched updates with server prepared statements weren't looking if the types had changed for a given batched set of parameters compared to the previous set, causing the server to return the error „Wrong arguments to mysql_stmt_execute()“.

- Handle case when string representation of timestamp contains trailing ‘`.`’ with no numbers following it.

- Inefficient detection of pre-existing string instances in `ResultSet.getNativeString()`. (Bug#5706)

- Don't throw exceptions for `Connection.releaseSavepoint()`.

- Use a per-session `Calendar` instance by default when decoding dates from `ServerPreparedStatements` (set to old, less performant behavior by setting property `dynamicCalendars=true`).

- Added experimental configuration property `dontUnpackBinaryResults`, which delays unpacking binary result set values until they're asked for, and only creates object instances for non-numerical values (it is set to `false` by default). For some usecase/jvm combinations, this is friendlier on the garbage collector.

- `UNSIGNED BIGINT` unpacked incorrectly from server-side prepared statement result sets. (Bug#5729)

- `ServerSidePreparedStatement` allocating short-lived objects unnecessarily. (Bug#6225)

- Removed unwanted new `Throwable()` in `ResultSet` constructor due to bad merge (caused a new object instance that was never used for every result set created). Found while profiling for Bug#6359.

- Fixed too-early creation of `StringBuffer` in `EscapeProcessor.escapeSQL()`, also return `String` when escaping not needed (to avoid unnecessary object allocations). Found while profiling for Bug#6359.

- Use null-safe-equals for key comparisons in updatable result sets.

- `SUM()` on `DECIMAL` with server-side prepared statement ignores scale if zero-padding is needed (this ends up being due to conversion to `DOUBLE` by server, which when converted to a string to parse into `BigDecimal`, loses all „padding“ zeros). (Bug#6537)

- Use `DatabaseMetaData.getIdentifierQuoteString()` when building DBMD queries.

- Use 1MB packet for sending file for `LOAD DATA LOCAL INFILE` if that is < `max_allowed_packet` on server.

- `ResultSetMetaData.getColumnDisplaySize()` returns incorrect values for multi-byte charsets. (Bug#6399)

- Make auto-deserialization of `java.lang.Objects` stored in `BLOB` columns configurable via `autoDeserialize` property (defaults to `false`).

- Re-work `Field.isOpaqueBinary()` to detect `CHAR(`n`) CHARACTER SET BINARY` to support fixed-length binary fields for `ResultSet.getObject()`.

- Use our own implementation of buffered input streams to get around blocking behavior of `java.io.BufferedInputStream`. Disable this with `useReadAheadInput=false`.

- Failing to connect to the server when one of the addresses for the given host name is IPV6 (which the server does not yet bind on). The driver now loops through all IP addresses for a given host, and stops on the first one that `accepts()` a `socket.connect()`. (Bug#6348)

### D.3.15. Changes in MySQL Connector/J 3.1.4-beta (04 September 2004)

- Connector/J 3.1.3 beta does not handle integers correctly (caused by changes to support unsigned reads in `Buffer.readInt()` -> `Buffer.readShort()`). (Bug#4510)

- Added support in `DatabaseMetaData.getTables()` and `getTableTypes()` for views, which are now available in MySQL server 5.0.x.

- `ServerPreparedStatement.execute*()` sometimes threw `ArrayIndexOutOfBoundsException` when unpacking field metadata. (Bug#4642)

- Optimized integer number parsing, enable „old“ slower integer parsing using JDK classes via `useFastIntParsing=false` property.

- Added `useOnlyServerErrorMessages` property, which causes message text in exceptions generated by the server to only contain the text sent by the server (as opposed to the SQLState's „standard“ description, followed by the server's error message). This property is set to `true` by default.

- `ResultSet.wasNull()` does not work for primatives if a previous `null` was returned. (Bug#4689)

- Track packet sequence numbers if `enablePacketDebug=true`, and throw an exception if packets received out-of-order.

- `ResultSet.getObject()` returns wrong type for strings when using prepared statements. (Bug#4482)

- Calling `MysqlPooledConnection.close()` twice (even though an application error), caused NPE. Fixed.

- `ServerPreparedStatements` dealing with return of `DECIMAL` type don't work. (Bug#5012)

- `ResultSet.getObject()` doesn't return type `Boolean` for pseudo-bit types from prepared statements on 4.1.x (shortcut for avoiding extra type conversion when using binary-encoded result sets obscured test in `getObject()` for „pseudo“ bit type). (Bug#5032)

- You can now use URLs in `LOAD DATA LOCAL INFILE` statements, and the driver will use Java's built-in handlers for retreiving the data and sending it to the server. This feature is not enabled by default, you must set the `allowUrlInLocalInfile` connection property to `true`.

- The driver is more strict about truncation of numerics on `ResultSet.get*()`, and will throw an `SQLException` when truncation is detected. You can disable this by setting `jdbcCompliantTruncation` to `false` (it is enabled by default, as this functionality is required for JDBC compliance).

- Added three ways to deal with all-zero datetimes when reading them from a `ResultSet`: `exception` (the default), which throws an `SQLException` with an SQLState of `S1009`; `convertToNull`, which returns `NULL` instead of the date; and `round`, which rounds the date to the nearest closest value which is `'0001-01-01'`.

- Fixed `ServerPreparedStatement` to read prepared statement metadata off the wire, even though it's currently a placeholder instead of using `MysqlIO.clearInputStream()` which didn't work at various times because data wasn't available to read from the server yet. This fixes sporadic errors users were having with `ServerPreparedStatements` throwing `ArrayIndexOutOfBoundExceptions`.

- Use `com.mysql.jdbc.Message`'s classloader when loading resource bundle, should fix sporadic issues when the caller's classloader can't locate the resource bundle.

### D.3.16. Changes in MySQL Connector/J 3.1.3-beta (07 July 2004)

- Mangle output parameter names for `CallableStatements` so they will not clash with user variable names.

- Added support for `INOUT` parameters in `CallableStatements`.

- Null bitmask sent for server-side prepared statements was incorrect. (Bug#4119)

- Use SQL Standard SQL states by default, unless `useSqlStateCodes` property is set to `false`.

- Added packet debuging code (see the `enablePacketDebug` property documentation).

- Added constants for MySQL error numbers (publicly accessible, see `com.mysql.jdbc.MysqlErrorNumbers`), and the ability to generate the mappings of vendor error codes to SQLStates that the driver uses (for documentation purposes).

- Externalized more messages (on-going effort).

- Error in retrieval of `mediumint` column with prepared statements and binary protocol. (Bug#4311)

- Support new time zone variables in MySQL-4.1.3 when `useTimezone=true`.

- Support for unsigned numerics as return types from prepared statements. This also causes a change in `ResultSet.getObject()` for the `bigint unsigned` type, which used to return `BigDecimal` instances, it now returns instances of `java.lang.BigInteger`.

### D.3.17. Changes in MySQL Connector/J 3.1.2-alpha (09 June 2004)

- Fixed stored procedure parameter parsing info when size was specified for a parameter (for example, `char()`, `varchar()`).

- Enabled callable statement caching via `cacheCallableStmts` property.

- Fixed case when no output parameters specified for a stored procedure caused a bogus query to be issued to retrieve out parameters, leading to a syntax error from the server.

- Fixed case when no parameters could cause a `NullPointerException` in `CallableStatement.setOutputParameters()`.

- Removed wrapping of exceptions in `MysqlIO.changeUser()`.

- Fixed sending of split packets for large queries, enabled nio ability to send large packets as well.

- Added `.toString()` functionality to `ServerPreparedStatement`, which should help if you're trying to debug a query that is a prepared statement (it shows SQL as the server would process).

- Added `gatherPerformanceMetrics` property, along with properties to control when/where this info gets logged (see docs for more info).

- `ServerPreparedStatements` weren't actually de-allocating server-side resources when `.close()` was called.

- Added `logSlowQueries` property, along with `slowQueriesThresholdMillis` property to control when a query should be considered „slow.“

- Correctly map output parameters to position given in `prepareCall()` versus. order implied during `registerOutParameter()`. (Bug#3146)

- Correctly detect initial character set for servers >= 4.1.0.

- Cleaned up detection of server properties.

- Support placeholder for parameter metadata for server >= 4.1.2.

- `getProcedures()` does not return any procedures in result set. (Bug#3539)

- `getProcedureColumns()` doesn't work with wildcards for procedure name. (Bug#3540)

- `DBMD.getSQLStateType()` returns incorrect value. (Bug#3520)

- Added `connectionCollation` property to cause driver to issue `set collation_connection=...` query on connection init if default collation for given charset is not appropriate.

- Fixed `DatabaseMetaData.getProcedures()` when run on MySQL-5.0.0 (output of `SHOW PROCEDURE STATUS` changed between 5.0.0 and 5.0.1.

- `getWarnings()` returns `SQLWarning` instead of `DataTruncation`. (Bug#3804)

- Don't enable server-side prepared statements for server version 5.0.0 or 5.0.1, as they aren't compatible with the '4.1.2+' style that the driver uses (the driver expects information to come back that isn't there, so it hangs).

### D.3.18. Changes in MySQL Connector/J 3.1.1-alpha (14 February 2004)

- Fixed bug with `UpdatableResultSets` not using client-side prepared statements.

- Fixed character encoding issues when converting bytes to ASCII when MySQL doesn't provide the character set, and the JVM is set to a multi-byte encoding (usually affecting retrieval of numeric values).

- Unpack „unknown“ data types from server prepared statements as `Strings`.

- Implemented long data (Blobs, Clobs, InputStreams, Readers) for server prepared statements.

- Implemented `Statement.getWarnings()` for MySQL-4.1 and newer (using `SHOW WARNINGS`).

- Default result set type changed to `TYPE_FORWARD_ONLY` (JDBC compliance).

- Centralized setting of result set type and concurrency.

- Refactored how connection properties are set and exposed as `DriverPropertyInfo` as well as `Connection` and `DataSource` properties.

- Support for NIO. Use `useNIO=true` on platforms that support NIO.

- Support for transaction savepoints (MySQL >= 4.0.14 or 4.1.1).

- Support for `mysql_change_user()`. See the `changeUser()` method in `com.mysql.jdbc.Connection`.

- Reduced number of methods called in average query to be more efficient.

- Prepared `Statements` will be re-prepared on auto-reconnect. Any errors encountered are postponed until first attempt to re-execute the re-prepared statement.

- Ensure that warnings are cleared before executing queries on prepared statements, as-per JDBC spec (now that we support warnings).

- Support „old“ `profileSql` capitalization in `ConnectionProperties`. This property is deprecated, you should use `profileSQL` if possible.

- Optimized `Buffer.readLenByteArray()` to return shared empty byte array when length is 0.

- Allow contents of `PreparedStatement.setBlob()` to be retained between calls to `.execute*()`.

- Deal with 0-length tokens in `EscapeProcessor` (caused by callable statement escape syntax).

- Check for closed connection on delete/update/insert row operations in `UpdatableResultSet`.

- Fix support for table aliases when checking for all primary keys in `UpdatableResultSet`.

- Removed `useFastDates` connection property.

- Correctly initialize datasource properties from JNDI Refs, including explicitly specified URLs.

- `DatabaseMetaData` now reports `supportsStoredProcedures()` for MySQL versions >= 5.0.0

- Fixed stack overflow in `Connection.prepareCall()` (bad merge).

- Fixed `IllegalAccessError` to `Calendar.getTimeInMillis()` in `DateTimeValue` (for JDK < 1.4).

- `DatabaseMetaData.getColumns()` is not returning correct column ordinal info for non-`'%'` column name patterns. (Bug#1673)

- Merged fix of datatype mapping from MySQL type `FLOAT` to `java.sql.Types.REAL` from 3.0 branch.

- Detect collation of column for `RSMD.isCaseSensitive()`.

- Fixed sending of queries larger than 16M.

- Added named and indexed input/output parameter support to `CallableStatement`. MySQL-5.0.x or newer.

- Fixed `NullPointerException` in `ServerPreparedStatement.setTimestamp()`, as well as year and month descrepencies in `ServerPreparedStatement.setTimestamp()`, `setDate()`.

- Added ability to have multiple database/JVM targets for compliance and regression/unit tests in `build.xml`.

- Fixed NPE and year/month bad conversions when accessing some datetime functionality in `ServerPreparedStatements` and their resultant result sets.

- Display where/why a connection was implicitly closed (to aid debugging).

- `CommunicationsException` implemented, that tries to determine why communications was lost with a server, and displays possible reasons when `.getMessage()` is called.

- `NULL` values for numeric types in binary encoded result sets causing `NullPointerExceptions`. (Bug#2359)

- Implemented `Connection.prepareCall()`, and `DatabaseMetaData`. `getProcedures()` and `getProcedureColumns()`.

- Reset `long binary` parameters in `ServerPreparedStatement` when `clearParameters()` is called, by sending `COM_RESET_STMT` to the server.

- Merged prepared statement caching, and `.getMetaData()` support from 3.0 branch.

- Fixed off-by-1900 error in some cases for years in `TimeUtil.fastDate`/`TimeCreate()` when unpacking results from server-side prepared statements.

- Fixed charset conversion issue in `getTables()`. (Bug#2502)

- Implemented multiple result sets returned from a statement or stored procedure.

- Server-side prepared statements were not returning datatype `YEAR` correctly. (Bug#2606)

- Enabled streaming of result sets from server-side prepared statements.

- Class-cast exception when using scrolling result sets and server-side prepared statements. (Bug#2623)

- Merged unbuffered input code from 3.0.

- Fixed `ConnectionProperties` that weren't properly exposed via accessors, cleaned up `ConnectionProperties` code.

- `NULL` fields were not being encoded correctly in all cases in server-side prepared statements. (Bug#2671)

- Fixed rare buffer underflow when writing numbers into buffers for sending prepared statement execution requests.

- Use DocBook version of docs for shipped versions of drivers.

### D.3.19. Changes in MySQL Connector/J 3.1.0-alpha (18 February 2003)

- Added `requireSSL` property.

- Added `useServerPrepStmts` property (default `false`). The driver will use server-side prepared statements when the server version supports them (4.1 and newer) when this property is set to `true`. It is currently set to `false` by default until all bind/fetch functionality has been implemented. Currently only DML prepared statements are implemented for 4.1 server-side prepared statements.

- Track open `Statements`, close all when `Connection.close()` is called (JDBC compliance).

### D.3.20. Changes in MySQL Connector/J 3.0.17-ga (23 June 2005)

- `Timestamp`/`Time` conversion goes in the wrong „direction“ when `useTimeZone=true` and server time zone differs from client time zone. (Bug#5874)

- `DatabaseMetaData.getIndexInfo()` ignored `unique` parameter. (Bug#7081)

- Support new protocol type `MYSQL_TYPE_VARCHAR`.

- Added `useOldUTF8Behavior`' configuration property, which causes JDBC driver to act like it did with MySQL-4.0.x and earlier when the character encoding is `utf-8` when connected to MySQL-4.1 or newer.

- Statements created from a pooled connection were returning physical connection instead of logical connection when `getConnection()` was called. (Bug#7316)

- `PreparedStatements` don't encode Big5 (and other multi-byte) character sets correctly in static SQL strings. (Bug#7033)

- Connections starting up failed-over (due to down master) never retry master. (Bug#6966)

- `PreparedStatement.fixDecimalExponent()` adding extra `+`, making number unparseable by MySQL server. (Bug#7061)

- Timestamp key column data needed `_binary` stripped for `UpdatableResultSet.refreshRow()`. (Bug#7686)

- Backported SQLState codes mapping from Connector/J 3.1, enable with `useSqlStateCodes=true` as a connection property, it defaults to `false` in this release, so that we don't break legacy applications (it defaults to `true` starting with Connector/J 3.1).

- `PreparedStatement.fixDecimalExponent()` adding extra `+`, making number unparseable by MySQL server. (Bug#7601)

- Escape sequence {fn convert(..., type)} now supports ODBC-style types that are prepended by `SQL_`.

- Fixed duplicated code in `configureClientCharset()` that prevented `useOldUTF8Behavior=true` from working properly.

- Handle streaming result sets with more than 2 billion rows properly by fixing wraparound of row number counter.

- `MS932`, `SHIFT_JIS`, and `Windows_31J` not recognized as aliases for `sjis`. (Bug#7607)

- Adding `CP943` to aliases for `sjis`. (Bug#6549, fixed while fixing Bug#7607)

- Which requires hex escaping of binary data when using multi-byte charsets with prepared statements. (Bug#8064)

- `NON_UNIQUE` column from `DBMD.getIndexInfo()` returned inverted value. (Bug#8812)

- Workaround for server Bug#9098: Default values of `CURRENT_*` for `DATE`, `TIME`, `DATETIME`, and `TIMESTAMP` columns can't be distinguished from `string` values, so `UpdatableResultSet.moveToInsertRow()` generates bad SQL for inserting default values.

- `EUCKR` charset is sent as `SET NAMES euc_kr` which MySQL-4.1 and newer doesn't understand. (Bug#8629)

- `DatabaseMetaData.supportsSelectForUpdate()` returns correct value based on server version.

- Use hex escapes for `PreparedStatement.setBytes()` for double-byte charsets including „aliases“ `Windows-31J`, `CP934`, `MS932`.

- Added support for the `EUC_JP_Solaris` character encoding, which maps to a MySQL encoding of `eucjpms` (backported from 3.1 branch). This only works on servers that support `eucjpms`, namely 5.0.3 or later.

### D.3.21. Changes in MySQL Connector/J 3.0.16-ga (15 November 2004)

- Re-issue character set configuration commands when re-using pooled connections and/or `Connection.changeUser()` when connected to MySQL-4.1 or newer.

- Fixed `ResultSetMetaData.isReadOnly()` to detect non-writable columns when connected to MySQL-4.1 or newer, based on existence of „original“ table and column names.

- `ResultSet.updateByte()` when on insert row throws `ArrayOutOfBoundsException`. (Bug#5664)

- Fixed `DatabaseMetaData.getTypes()` returning incorrect (this is, non-negative) scale for the `NUMERIC` type.

- Off-by-one bug in `Buffer.readString(`string`)`. (Bug#5664)

- Made `TINYINT(1)` -> `BIT`/`Boolean` conversion configurable via `tinyInt1isBit` property (default `true` to be JDBC compliant out of the box).

- Only set `character_set_results` during connection establishment if server version >= 4.1.1.

- Fixed regression where `useUnbufferedInput` was defaulting to `false`.

- `ResultSet.getTimestamp()` on a column with `TIME` in it fails. (Bug#5664)

### D.3.22. Changes in MySQL Connector/J 3.0.15-production (04 September 2004)

- `StringUtils.escapeEasternUnicodeByteStream` was still broken for GBK. (Bug#4010)

- Failover for `autoReconnect` not using port numbers for any hosts, and not retrying all hosts. (Warning: This required a change to the `SocketFactory` `connect()` method signature, which is now `public Socket connect(String host, int portNumber, Properties props)`; therefore, any third-party socket factories will have to be changed to support this signature. (Bug#4334)

- Logical connections created by `MysqlConnectionPoolDataSource` will now issue a `rollback()` when they are closed and sent back to the pool. If your application server/connection pool already does this for you, you can set the `rollbackOnPooledClose` property to `false` to avoid the overhead of an extra `rollback()`.

- Removed redundant calls to `checkRowPos()` in `ResultSet`.

- `DOUBLE` mapped twice in `DBMD.getTypeInfo()`. (Bug#4742)

- Added FLOSS license exemption.

- Calling `.close()` twice on a `PooledConnection` causes NPE. (Bug#4808)

- `DBMD.getColumns()` returns incorrect JDBC type for unsigned columns. This affects type mappings for all numeric types in the `RSMD.getColumnType()` and `RSMD.getColumnTypeNames()` methods as well, to ensure that „like“ types from `DBMD.getColumns()` match up with what `RSMD.getColumnType()` and `getColumnTypeNames()` return. (Bug#4138, Bug#4860)

- „Production“ is now „GA“ (General Availability) in naming scheme of distributions.

- `RSMD.getPrecision()` returning 0 for non-numeric types (should return max length in chars for non-binary types, max length in bytes for binary types). This fix also fixes mapping of `RSMD.getColumnType()` and `RSMD.getColumnTypeName()` for the `BLOB` types based on the length sent from the server (the server doesn't distinguish between `TINYBLOB`, `BLOB`, `MEDIUMBLOB` or `LONGBLOB` at the network protocol level). (Bug#4880)

- `ResultSet` should release `Field[]` instance in `.close()`. (Bug#5022)

- `ResultSet.getMetaData()` should not return incorrectly initialized metadata if the result set has been closed, but should instead throw an `SQLException`. Also fixed for `getRow()` and `getWarnings()` and traversal methods by calling `checkClosed()` before operating on instance-level fields that are nullified during `.close()`. (Bug#5069)

- Parse new time zone variables from 4.1.x servers.

- Use `_binary` introducer for `PreparedStatement.setBytes()` and `set*Stream()` when connected to MySQL-4.1.x or newer to avoid misinterpretation during character conversion.

### D.3.23. Changes in MySQL Connector/J 3.0.14-production (28 May 2004)

- Fixed URL parsing error.

### D.3.24. Changes in MySQL Connector/J 3.0.13-production (27 May 2004)

- Using a `MySQLDatasource` without server name fails. (Bug#3848)

- `No Database Selected` when using `MysqlConnectionPoolDataSource`. (Bug#3920)

- `PreparedStatement.getGeneratedKeys()` method returns only 1 result for batched insertions. (Bug#3873)

### D.3.25. Changes in MySQL Connector/J 3.0.12-production (18 May 2004)

- Add unsigned attribute to `DatabaseMetaData.getColumns()` output in the `TYPE_NAME` column.

- Added `failOverReadOnly` property, to allow end-user to configure state of connection (read-only/writable) when failed over.

- Backported „change user“ and „reset server state“ functionality from 3.1 branch, to allow clients of `MysqlConnectionPoolDataSource` to reset server state on `getConnection()` on a pooled connection.

- Don't escape SJIS/GBK/BIG5 when using MySQL-4.1 or newer.

- Allow `url` parameter for `MysqlDataSource` and `MysqlConnectionPool` `DataSource` so that passing of other properties is possible from inside appservers.

- Map duplicate key and foreign key errors to SQLState of `23000`.

- Backport documentation tooling from 3.1 branch.

- Return creating statement for `ResultSets` created by `getGeneratedKeys()`. (Bug#2957)

- Allow `java.util.Date` to be sent in as parameter to `PreparedStatement.setObject()`, converting it to a `Timestamp` to maintain full precision. (Bug#103).

- Don't truncate `BLOB` or `CLOB` values when using `setBytes()` and/or `setBinary/CharacterStream()`. (Bug#2670).

- Dynamically configure character set mappings for field-level character sets on MySQL-4.1.0 and newer using `SHOW COLLATION` when connecting.

- Map `binary` character set to `US-ASCII` to support `DATETIME` charset recognition for servers >= 4.1.2.

- Use `SET character_set_results` during initialization to allow any charset to be returned to the driver for result sets.

- Use `charsetnr` returned during connect to encode queries before issuing `SET NAMES` on MySQL >= 4.1.0.

- Add helper methods to `ResultSetMetaData` (`getColumnCharacterEncoding()` and `getColumnCharacterSet()`) to allow end-users to see what charset the driver thinks it should be using for the column.

- Only set `character_set_results` for MySQL >= 4.1.0.

- `StringUtils.escapeSJISByteStream()` not covering all eastern double-byte charsets correctly. (Bug#3511)

- Renamed `StringUtils.escapeSJISByteStream()` to more appropriate `escapeEasternUnicodeByteStream()`.

- Not specifying database in URL caused `MalformedURL` exception. (Bug#3554)

- Auto-convert MySQL encoding names to Java encoding names if used for `characterEncoding` property.

- Added encoding names that are recognized on some JVMs to fix case where they were reverse-mapped to MySQL encoding names incorrectly.

- Use `junit.textui.TestRunner` for all unit tests (to allow them to be run from the command line outside of Ant or Eclipse).

- `UpdatableResultSet` not picking up default values for `moveToInsertRow()`. (Bug#3557)

- Inconsistent reporting of data type. The server still doesn't return all types for *BLOBs *TEXT correctly, so the driver won't return those correctly. (Bug#3570)

- `DBMD.getSQLStateType()` returns incorrect value. (Bug#3520)

- Fixed regression in `PreparedStatement.setString()` and eastern character encodings.

- Made `StringRegressionTest` 4.1-unicode aware.

### D.3.26. Changes in MySQL Connector/J 3.0.11-stable (19 February 2004)

- Trigger a `SET NAMES utf8` when encoding is forced to `utf8` or `utf-8` via the `characterEncoding` property. Previously, only the Java-style encoding name of `utf-8` would trigger this.

- `AutoReconnect` time was growing faster than exponentially. (Bug#2447)

- Fixed failover always going to last host in list. (Bug#2578)

- Added `useUnbufferedInput` parameter, and now use it by default (due to JVM issue http://developer.java.sun.com/developer/bugParade/bugs/4401235.html)

- Detect `on`/`off` or `1`, `2`, `3` form of `lower_case_table_names` value on server.

- Return `java.lang.Integer` for `TINYINT` and `SMALLINT` types from `ResultSetMetaData.getColumnClassName()`. (Bug#2852)

- Return `java.lang.Double` for `FLOAT` type from `ResultSetMetaData.getColumnClassName()`. (Bug#2855)

- Return `[B` instead of `java.lang.Object` for `BINARY`, `VARBINARY` and `LONGVARBINARY` types from `ResultSetMetaData.getColumnClassName()` (JDBC compliance).

- Issue connection events on all instances created from a `ConnectionPoolDataSource`.

### D.3.27. Changes in MySQL Connector/J 3.0.10-stable (13 January 2004)

- Don't count quoted IDs when inside a 'string' in `PreparedStatement` parsing. (Bug#1511)

- „Friendlier“ exception message for `PacketTooLargeException`. (Bug#1534)

- Backported fix for aliased tables and `UpdatableResultSets` in `checkUpdatability()` method from 3.1 branch.

- Fix for `ArrayIndexOutOfBounds` exception when using `Statement.setMaxRows()`. (Bug#1695)

- Barge blobs and split packets not being read correctly. (Bug#1576)

- Fixed regression of `Statement.getGeneratedKeys()` and `REPLACE` statements.

- Subsequent call to `ResultSet.updateFoo()` causes NPE if result set is not updatable. (Bug#1630)

- Fix for 4.1.1-style authentication with no password.

- Foreign Keys column sequence is not consistent in `DatabaseMetaData.getImported/Exported/CrossReference()`. (Bug#1731)

- `DatabaseMetaData.getSystemFunction()` returning bad function `VResultsSion`. (Bug#1775)

- Cross-database updatable result sets are not checked for updatability correctly. (Bug#1592)

- `DatabaseMetaData.getColumns()` should return `Types.LONGVARCHAR` for MySQL `LONGTEXT` type.

- `ResultSet.getObject()` on `TINYINT` and `SMALLINT` columns should return Java type `Integer`. (Bug#1913)

- Added `alwaysClearStream` connection property, which causes the driver to always empty any remaining data on the input stream before each query.

- Added more descriptive error message `Server Configuration Denies Access to DataSource`, as well as retrieval of message from server.

- Autoreconnect code didn't set catalog upon reconnect if it had been changed.

- Implement `ResultSet.updateClob()`.

- `ResultSetMetaData.isCaseSensitive()` returned wrong value for `CHAR`/`VARCHAR` columns.

- Connection property `maxRows` not honored. (Bug#1933)

- Statements being created too many times in `DBMD.extractForeignKeyFromCreateTable()`. (Bug#1925)

- Support escape sequence {fn convert ... }. (Bug#1914)

- `ArrayIndexOutOfBounds` when parameter number == number of parameters + 1. (Bug#1958)

- `ResultSet.findColumn()` should use first matching column name when there are duplicate column names in `SELECT` query (JDBC-compliance). (Bug#2006)

- Removed static synchronization bottleneck from `PreparedStatement.setTimestamp()`.

- Removed static synchronization bottleneck from instance factory method of `SingleByteCharsetConverter`.

- Enable caching of the parsing stage of prepared statements via the `cachePrepStmts`, `prepStmtCacheSize`, and `prepStmtCacheSqlLimit` properties (disabled by default).

- Speed up parsing of `PreparedStatements`, try to use one-pass whenever possible.

- Fixed security exception when used in Applets (applets can't read the system property `file.encoding` which is needed for `LOAD DATA LOCAL INFILE`).

- Use constants for SQLStates.

- Map charset `ko18_ru` to `ko18r` when connected to MySQL-4.1.0 or newer.

- Ensure that `Buffer.writeString()` saves room for the `\0`.

- Fixed exception `Unknown character set 'danish'` on connect with JDK-1.4.0

- Fixed mappings in SQLError to report deadlocks with SQLStates of `41000`.

- `maxRows` property would affect internal statements, so check it for all statement creation internal to the driver, and set to 0 when it is not.

### D.3.28. Changes in MySQL Connector/J 3.0.9-stable (07 October 2003)

- Faster date handling code in `ResultSet` and `PreparedStatement` (no longer uses `Date` methods that synchronize on static calendars).

- Fixed test for end of buffer in `Buffer.readString()`.

- Fixed `ResultSet.previous()` behavior to move current position to before result set when on first row of result set. (Bug#496)

- Fixed `Statement` and `PreparedStatement` issuing bogus queries when `setMaxRows()` had been used and a `LIMIT` clause was present in the query.

- `refreshRow` didn't work when primary key values contained values that needed to be escaped (they ended up being doubly escaped). (Bug#661)

- Support `InnoDB` contraint names when extracting foreign key information in `DatabaseMetaData` (implementing ideas from Parwinder Sekhon). (Bug#517, Bug#664)

- Backported 4.1 protocol changes from 3.1 branch (server-side SQL states, new field information, larger client capability flags, connect-with-database, and so forth).

- Fix `UpdatableResultSet` to return values for `get`XXX`()` when on insert row. (Bug#675)

- The `insertRow` in an `UpdatableResultSet` is now loaded with the default column values when `moveToInsertRow()` is called. (Bug#688)

- `DatabaseMetaData.getColumns()` wasn't returning `NULL` for default values that are specified as `NULL`.

- Change default statement type/concurrency to `TYPE_FORWARD_ONLY` and `CONCUR_READ_ONLY` (spec compliance).

- Don't try and reset isolation level on reconnect if MySQL doesn't support them.

- Don't wrap `SQLExceptions` in `RowDataDynamic`.

- Don't change timestamp TZ twice if `useTimezone==true`. (Bug#774)

- Fixed regression in large split-packet handling. (Bug#848)

- Better diagnostic error messages in exceptions for „streaming“ result sets.

- Issue exception on `ResultSet.get`XXX`()` on empty result set (wasn't caught in some cases).

- Don't hide messages from exceptions thrown in I/O layers.

- Don't fire connection closed events when closing pooled connections, or on `PooledConnection.getConnection()` with already open connections. (Bug#884)

- Clip +/- INF (to smallest and largest representative values for the type in MySQL) and NaN (to 0) for `setDouble`/`setFloat()`, and issue a warning on the statement when the server does not support +/- INF or NaN.

- Double-escaping of `'\'` when charset is SJIS or GBK and `'\'` appears in non-escaped input. (Bug#879)

- When emptying input stream of unused rows for „streaming“ result sets, have the current thread `yield()` every 100 rows in order to not monopolize CPU time.

- `DatabaseMetaData.getColumns()` getting confused about the keyword „set“ in character columns. (Bug#1099)

- Fixed deadlock issue with `Statement.setMaxRows()`.

- Fixed `CLOB.truncate()`. (Bug#1130)

- Optimized `CLOB.setChracterStream()`. (Bug#1131)

- Made `databaseName`, `portNumber`, and `serverName` optional parameters for `MysqlDataSourceFactory`. (Bug#1246)

- `ResultSet.get/setString` mashing char 127. (Bug#1247)

- Backported authentication changes for 4.1.1 and newer from 3.1 branch.

- Added `com.mysql.jdbc.util.BaseBugReport` to help creation of testcases for bug reports.

- Added property to „clobber“ streaming results, by setting the `clobberStreamingResults` property to `true` (the default is `false`). This will cause a „streaming“ `ResultSet` to be automatically closed, and any oustanding data still streaming from the server to be discarded if another query is executed before all the data has been read from the server.

### D.3.29. Changes in MySQL Connector/J 3.0.8-stable (23 May 2003)

- Allow bogus URLs in `Driver.getPropertyInfo()`.

- Return list of generated keys when using multi-value `INSERTS` with `Statement.getGeneratedKeys()`.

- Use JVM charset with filenames and `LOAD DATA [LOCAL] INFILE`.

- Fix infinite loop with `Connection.cleanup()`.

- Changed Ant target `compile-core` to `compile-driver`, and made testsuite compilation a separate target.

- Fixed result set not getting set for `Statement.executeUpdate()`, which affected `getGeneratedKeys()` and `getUpdateCount()` in some cases.

- Unicode character 0xFFFF in a string would cause the driver to throw an `ArrayOutOfBoundsException`. (Bug#378).

- Return correct number of generated keys when using `REPLACE` statements.

- Fix problem detecting server character set in some cases.

- Fix row data decoding error when using very large packets.

- Optimized row data decoding.

- Issue exception when operating on an already closed prepared statement.

- Fixed SJIS encoding bug, thanks to Naoto Sato.

- Optimized usage of `EscapeProcessor`.

- Allow multiple calls to `Statement.close()`.

### D.3.30. Changes in MySQL Connector/J 3.0.7-stable (08 April 2003)

- Fixed `MysqlPooledConnection.close()` calling wrong event type.

- Fixed `StringIndexOutOfBoundsException` in `PreparedStatement.setClob()`.

- 4.1 Column Metadata fixes.

- Remove synchronization from `Driver.connect()` and `Driver.acceptsUrl()`.

- `IOExceptions` during a transaction now cause the `Connection` to be closed.

- Fixed missing conversion for `YEAR` type in `ResultSetMetaData.getColumnTypeName()`.

- Don't pick up indexes that start with `pri` as primary keys for `DBMD.getPrimaryKeys()`.

- Throw `SQLExceptions` when trying to do operations on a forcefully closed `Connection` (that is, when a communication link failure occurs).

- You can now toggle profiling on/off using `Connection.setProfileSql(boolean)`.

- Fixed charset issues with database metadata (charset was not getting set correctly).

- Updatable `ResultSets` can now be created for aliased tables/columns when connected to MySQL-4.1 or newer.

- Fixed `LOAD DATA LOCAL INFILE` bug when file > `max_allowed_packet`.

- Fixed escaping of 0x5c (`'\'`) character for GBK and Big5 charsets.

- Fixed `ResultSet.getTimestamp()` when underlying field is of type `DATE`.

- Ensure that packet size from `alignPacketSize()` does not exceed `max_allowed_packet` (JVM bug)

- Don't reset `Connection.isReadOnly()` when autoReconnecting.

### D.3.31. Changes in MySQL Connector/J 3.0.6-stable (18 February 2003)

- Fixed `ResultSetMetaData` to return `""` when catalog not known. Fixes `NullPointerExceptions` with Sun's `CachedRowSet`.

- Fixed `DBMD.getTypeInfo()` and `DBMD.getColumns()` returning different value for precision in `TEXT` and `BLOB` types.

- Allow ignoring of warning for „non transactional tables“ during rollback (compliance/usability) by setting `ignoreNonTxTables` property to `true`.

- Fixed `SQLExceptions` getting swallowed on initial connect.

- Fixed `Statement.setMaxRows()` to stop sending `LIMIT` type queries when not needed (performance).

- Clean up `Statement` query/method mismatch tests (that is, `INSERT` not allowed with `.executeQuery()`).

- More checks added in `ResultSet` traversal method to catch when in closed state.

- Fixed `ResultSetMetaData.isWritable()` to return correct value.

- Add „window“ of different `NULL` sorting behavior to `DBMD.nullsAreSortedAtStart` (4.0.2 to 4.0.10, true; otherwise, no).

- Implemented `Blob.setBytes()`. You still need to pass the resultant `Blob` back into an updatable `ResultSet` or `PreparedStatement` to persist the changes, because MySQL does not support „locators“.

- Backported 4.1 charset field info changes from Connector/J 3.1.

### D.3.32. Changes in MySQL Connector/J 3.0.5-gamma (22 January 2003)

- Fixed `Buffer.fastSkipLenString()` causing `ArrayIndexOutOfBounds` exceptions with some queries when unpacking fields.

- Implemented an empty `TypeMap` for `Connection.getTypeMap()` so that some third-party apps work with MySQL (IBM WebSphere 5.0 Connection pool).

- Added missing `LONGTEXT` type to `DBMD.getColumns()`.

- Retrieve `TX_ISOLATION` from database for `Connection.getTransactionIsolation()` when the MySQL version supports it, instead of an instance variable.

- Quote table names in `DatabaseMetaData.getColumns()`, `getPrimaryKeys()`, `getIndexInfo()`, `getBestRowIdentifier()`.

- Greatly reduce memory required for `setBinaryStream()` in `PreparedStatements`.

- Fixed `ResultSet.isBeforeFirst()` for empty result sets.

- Added update options for foreign key metadata.

### D.3.33. Changes in MySQL Connector/J 3.0.4-gamma (06 January 2003)

- Added quoted identifiers to database names for `Connection.setCatalog`.

- Added support for quoted identifiers in `PreparedStatement` parser.

- Streamlined character conversion and `byte[]` handling in `PreparedStatements` for `setByte()`.

- Reduce memory footprint of `PreparedStatements` by sharing outbound packet with `MysqlIO`.

- Added `strictUpdates` property to allow control of amount of checking for „correctness“ of updatable result sets. Set this to `false` if you want faster updatable result sets and you know that you create them from `SELECT` statements on tables with primary keys and that you have selected all primary keys in your query.

- Added support for 4.0.8-style large packets.

- Fixed `PreparedStatement.executeBatch()` parameter overwriting.

### D.3.34. Changes in MySQL Connector/J 3.0.3-dev (17 December 2002)

- Changed `charsToByte` in `SingleByteCharConverter` to be non-static.

- Changed `SingleByteCharConverter` to use lazy initialization of each converter.

- Fixed charset handling in `Fields.java`.

- Implemented `Connection.nativeSQL()`.

- More robust escape tokenizer: Recognize `--` comments, and allow nested escape sequences (see `testsuite.EscapeProcessingTest`).

- `DBMD.getImported/ExportedKeys()` now handles multiple foreign keys per table.

- Fixed `ResultSetMetaData.getPrecision()` returning incorrect values for some floating-point types.

- Fixed `ResultSetMetaData.getColumnTypeName()` returning `BLOB` for `TEXT` and `TEXT` for `BLOB` types.

- Fixed `Buffer.isLastDataPacket()` for 4.1 and newer servers.

- Added `CLIENT_LONG_FLAG` to be able to get more column flags (`isAutoIncrement()` being the most important).

- Because of above, implemented `ResultSetMetaData.isAutoIncrement()` to use `Field.isAutoIncrement()`.

- Honor `lower_case_table_names` when enabled in the server when doing table name comparisons in `DatabaseMetaData` methods.

- Some MySQL-4.1 protocol support (extended field info from selects).

- Use non-aliased table/column names and database names to fullly qualify tables and columns in `UpdatableResultSet` (requires MySQL-4.1 or newer).

- Allow user to alter behavior of `Statement`/ `PreparedStatement.executeBatch()` via `continueBatchOnError` property (defaults to `true`).

- Check for connection closed in more `Connection` methods (`createStatement`, `prepareStatement`, `setTransactionIsolation`, `setAutoCommit`).

- More robust implementation of updatable result sets. Checks that all primary keys of the table have been selected.

- `LOAD DATA LOCAL INFILE ...` now works, if your server is configured to allow it. Can be turned off with the `allowLoadLocalInfile` property (see the `README`).

- Substitute `'?'` for unknown character conversions in single-byte character sets instead of `'\0'`.

- `NamedPipeSocketFactory` now works (only intended for Windows), see `README` for instructions.

### D.3.35. Changes in MySQL Connector/J 3.0.2-dev (08 November 2002)

- Fixed issue with updatable result sets and `PreparedStatements` not working.

- Fixed `ResultSet.setFetchDirection(FETCH_UNKNOWN)`.

- Fixed issue when calling `Statement.setFetchSize()` when using arbitrary values.

- Fixed incorrect conversion in `ResultSet.getLong()`.

- Implemented `ResultSet.updateBlob()`.

- Removed duplicate code from `UpdatableResultSet` (it can be inherited from `ResultSet`, the extra code for each method to handle updatability I thought might someday be necessary has not been needed).

- Fixed `UnsupportedEncodingException` thrown when „forcing“ a character encoding via properties.

- Fixed various non-ASCII character encoding issues.

- Added driver property `useHostsInPrivileges`. Defaults to true. Affects whether or not `@hostname` will be used in `DBMD.getColumn/TablePrivileges`.

- All `DBMD` result set columns describing schemas now return `NULL` to be more compliant with the behavior of other JDBC drivers for other database systems (MySQL does not support schemas).

- Added SSL support. See `README` for information on how to use it.

- Properly restore connection properties when autoReconnecting or failing-over, including `autoCommit` state, and isolation level.

- Use `SHOW CREATE TABLE` when possible for determining foreign key information for `DatabaseMetaData`. Also allows cascade options for `DELETE` information to be returned.

- Escape `0x5c` character in strings for the SJIS charset.

- Fixed start position off-by-1 error in `Clob.getSubString()`.

- Implemented `Clob.truncate()`.

- Implemented `Clob.setString()`.

- Implemented `Clob.setAsciiStream()`.

- Implemented `Clob.setCharacterStream()`.

- Added `com.mysql.jdbc.MiniAdmin` class, which allows you to send `shutdown` command to MySQL server. This is intended to be used when „embedding“ Java and MySQL server together in an end-user application.

- Added `connectTimeout` parameter that allows users of JDK-1.4 and newer to specify a maxium time to wait to establish a connection.

- Failover and `autoReconnect` work only when the connection is in an `autoCommit(false)` state, in order to stay transaction-safe.

- Added `queriesBeforeRetryMaster` property that specifies how many queries to issue when failed over before attempting to reconnect to the master (defaults to 50).

- Fixed `DBMD.supportsResultSetConcurrency()` so that it returns true for `ResultSet.TYPE_SCROLL_INSENSITIVE` and `ResultSet.CONCUR_READ_ONLY` or `ResultSet.CONCUR_UPDATABLE`.

- Fixed `ResultSet.isLast()` for empty result sets (should return `false`).

- `PreparedStatement` now honors stream lengths in setBinary/Ascii/Character Stream() unless you set the connection property `useStreamLengthsInPrepStmts` to `false`.

- Removed some not-needed temporary object creation by smarter use of `Strings` in `EscapeProcessor`, `Connection` and `DatabaseMetaData` classes.

### D.3.36. Changes in MySQL Connector/J 3.0.1-dev (21 September 2002)

- Fixed `ResultSet.getRow()` off-by-one bug.

- Fixed `RowDataStatic.getAt()` off-by-one bug.

- Added limited `Clob` functionality (`ResultSet.getClob()`, `PreparedStatemtent.setClob()`, `PreparedStatement.setObject(Clob)`.

- Added `socketTimeout` parameter to URL.

- `Connection.isClosed()` no longer „pings“ the server.

- `Connection.close()` issues `rollback()` when `getAutoCommit()` is `false`.

- Added `paranoid` parameter, which sanitizes error messages by removing „sensitive“ information from them (such as hostnames, ports, or usernames), as well as clearing „sensitive“ data structures when possible.

- Fixed `ResultSetMetaData.isSigned()` for `TINYINT` and `BIGINT`.

- Charsets now automatically detected. Optimized code for single-byte character set conversion.

- Implemented `ResultSet.getCharacterStream()`.

- Added `LOCAL TEMPORARY` to table types in `DatabaseMetaData.getTableTypes()`.

- Massive code clean-up to follow Java coding conventions (the time had come).

### D.3.37. Changes in MySQL Connector/J 3.0.0-dev (31 July 2002)

- !!! LICENSE CHANGE !!! The driver is now GPL. If you need non-GPL licenses, please contact me `<mark@mysql.com>`.

- JDBC-3.0 functionality including `Statement/PreparedStatement.getGeneratedKeys()` and `ResultSet.getURL()`.

- Performance enchancements: Driver is now 50–100% faster in most situations, and creates fewer temporary objects.

- Repackaging: New driver name is `com.mysql.jdbc.Driver`, old name still works, though (the driver is now provided by MySQL-AB).

- Better checking for closed connections in `Statement` and `PreparedStatement`.

- Support for streaming (row-by-row) result sets (see `README`) Thanks to Doron.

- Support for large packets (new addition to MySQL-4.0 protocol), see `README` for more information.

- JDBC Compliance: Passes all tests besides stored procedure tests.

- Fix and sort primary key names in `DBMetaData` (SF bugs 582086 and 582086).

- Float types now reported as `java.sql.Types.FLOAT` (SF bug 579573).

- `ResultSet.getTimestamp()` now works for `DATE` types (SF bug 559134).

- `ResultSet.getDate/Time/Timestamp` now recognizes all forms of invalid values that have been set to all zeros by MySQL (SF bug 586058).

- Testsuite now uses Junit (which you can get from http://www.junit.org.

- The driver now only works with JDK-1.2 or newer.

- Added multi-host failover support (see `README`).

- General source-code cleanup.

- Overall speed improvements via controlling transient object creation in `MysqlIO` class when reading packets.

- Performance improvements in string handling and field metadata creation (lazily instantiated) contributed by Alex Twisleton-Wykeham-Fiennes.

### D.3.38. Changes in MySQL Connector/J 2.0.14 (16 May 2002)

- More code cleanup.

- `PreparedStatement` now releases resources on `.close()`. (SF bug 553268)

- Quoted identifiers not used if server version does not support them. Also, if server started with `--ansi` or `--sql-mode=ANSI_QUOTES`, ‘`"`’ will be used as an identifier quote character, otherwise ‘`'`’ will be used.

- `ResultSet.getDouble()` now uses code built into JDK to be more precise (but slower).

- `LogicalHandle.isClosed()` calls through to physical connection.

- Added SQL profiling (to `STDERR`). Set `profileSql=true` in your JDBC URL. See `README` for more information.

- Fixed typo for `relaxAutoCommit` parameter.

### D.3.39. Changes in MySQL Connector/J 2.0.13 (24 April 2002)

- More code cleanup.

- Fixed unicode chars being read incorrectly. (SF bug 541088)

- Faster blob escaping for `PrepStmt`.

- Added `set`/`getPortNumber()` to `DataSource(s)`. (SF bug 548167)

- Added `setURL()` to `MySQLXADataSource`. (SF bug 546019)

- `PreparedStatement.toString()` fixed. (SF bug 534026)

- `ResultSetMetaData.getColumnClassName()` now implemented.

- Rudimentary version of `Statement.getGeneratedKeys()` from JDBC-3.0 now implemented (you need to be using JDK-1.4 for this to work, I believe).

- `DBMetaData.getIndexInfo()` - bad PAGES fixed. (SF BUG 542201)

### D.3.40. Changes in MySQL Connector/J 2.0.12 (07 April 2002)

- General code cleanup.

- Added `getIdleFor()` method to `Connection` and `MysqlLogicalHandle`.

- Relaxed synchronization in all classes, should fix 520615 and 520393.

- Added `getTable/ColumnPrivileges()` to DBMD (fixes 484502).

- Added new types to `getTypeInfo()`, fixed existing types thanks to Al Davis and Kid Kalanon.

- Added support for `BIT` types (51870) to `PreparedStatement`.

- Fixed `getRow()` bug (527165) in `ResultSet`.

- Fixes for `ResultSet` updatability in `PreparedStatement`.

- Fixed time zone off-by-1-hour bug in `PreparedStatement` (538286, 528785).

- `ResultSet`: Fixed updatability (values being set to `null` if not updated).

- `DataSources` - fixed `setUrl` bug (511614, 525565), wrong datasource class name (532816, 528767).

- Added identifier quoting to all `DatabaseMetaData` methods that need them (should fix 518108).

- Added support for `YEAR` type (533556).

- `ResultSet.insertRow()` should now detect auto_increment fields in most cases and use that value in the new row. This detection will not work in multi-valued keys, however, due to the fact that the MySQL protocol does not return this information.

- `ResultSet.refreshRow()` implemented.

- Fixed `testsuite.Traversal` `afterLast()` bug, thanks to Igor Lastric.

### D.3.41. Changes in MySQL Connector/J 2.0.11 (27 January 2002)

- Fixed missing `DELETE_RULE` value in `DBMD.getImported/ExportedKeys()` and `getCrossReference()`.

- Full synchronization of `Statement.java`.

- More changes to fix `Unexpected end of input stream` errors when reading `BLOB` values. This should be the last fix.

### D.3.42. Changes in MySQL Connector/J 2.0.10 (24 January 2002)

- Fixed spurious `Unexpected end of input stream` errors in `MysqlIO` (bug 507456).

- Fixed null-pointer-exceptions when using `MysqlConnectionPoolDataSource` with Websphere 4 (bug 505839).

### D.3.43. Changes in MySQL Connector/J 2.0.9 (13 January 2002)

- Ant build was corrupting included `jar` files, fixed (bug 487669).

- Fixed extra memory allocation in `MysqlIO.readPacket()` (bug 488663).

- Implementation of `DatabaseMetaData.getExported/ImportedKeys()` and `getCrossReference()`.

- Full synchronization on methods modifying instance and class-shared references, driver should be entirely thread-safe now (please let me know if you have problems).

- `DataSource` implementations moved to `org.gjt.mm.mysql.jdbc2.optional` package, and (initial) implementations of `PooledConnectionDataSource` and `XADataSource` are in place (thanks to Todd Wolff for the implementation and testing of `PooledConnectionDataSource` with IBM WebSphere 4).

- Added detection of network connection being closed when reading packets (thanks to Todd Lizambri).

- Fixed quoting error with escape processor (bug 486265).

- Report batch update support through `DatabaseMetaData` (bug 495101).

- Fixed off-by-one-hour error in `PreparedStatement.setTimestamp()` (bug 491577).

- Removed concatenation support from driver (the `||` operator), as older versions of VisualAge seem to be the only thing that use it, and it conflicts with the logical `||` operator. You will need to start mysqld with the `--ansi` flag to use the `||` operator as concatenation (bug 491680).

- Fixed casting bug in `PreparedStatement` (bug 488663).

### D.3.44. Changes in MySQL Connector/J 2.0.8 (25 November 2001)

- Batch updates now supported (thanks to some inspiration from Daniel Rall).

- `XADataSource`/`ConnectionPoolDataSource` code (experimental)

- `PreparedStatement.setAnyNumericType()` now handles positive exponents correctly (adds `+` so MySQL can understand it).

- `DatabaseMetaData.getPrimaryKeys()` and `getBestRowIdentifier()` are now more robust in identifying primary keys (matches regardless of case or abbreviation/full spelling of `Primary Key` in `Key_type` column).

### D.3.45. Changes in MySQL Connector/J 2.0.7 (24 October 2001)

- `PreparedStatement.setCharacterStream()` now implemented

- Fixed dangling socket problem when in high availability (`autoReconnect=true`) mode, and finalizer for `Connection` will close any dangling sockets on GC.

- Fixed `ResultSetMetaData.getPrecision()` returning one less than actual on newer versions of MySQL.

- `ResultSet.getBlob()` now returns `null` if column value was `null`.

- Character sets read from database if `useUnicode=true` and `characterEncoding` is not set. (thanks to Dmitry Vereshchagin)

- Initial transaction isolation level read from database (if avaialable). (thanks to Dmitry Vereshchagin)

- Fixed `DatabaseMetaData.supportsTransactions()`, and `supportsTransactionIsolationLevel()` and `getTypeInfo()` `SQL_DATETIME_SUB` and `SQL_DATA_TYPE` fields not being readable.

- Fixed `PreparedStatement` generating SQL that would end up with syntax errors for some queries.

- Fixed `ResultSet.isAfterLast()` always returning `false`.

- Fixed time zone issue in `PreparedStatement.setTimestamp()`. (thanks to Erik Olofsson)

- Captialize type names when `captializeTypeNames=true` is passed in URL or properties (for WebObjects. (thanks to Anjo Krank)

- Updatable result sets now correctly handle `NULL` values in fields.

- PreparedStatement.setDouble() now uses full-precision doubles (reverting a fix made earlier to truncate them).

- PreparedStatement.setBoolean() will use 1/0 for values if your MySQL version is 3.21.23 or higher.

### D.3.46. Changes in MySQL Connector/J 2.0.6 (16 June 2001)

- Fixed `PreparedStatement` parameter checking.

- Fixed case-sensitive column names in `ResultSet.java`.

### D.3.47. Changes in MySQL Connector/J 2.0.5 (13 June 2001)

- Fixed `ResultSet.getBlob()` `ArrayIndex` out-of-bounds.

- Fixed `ResultSetMetaData.getColumnTypeName` for `TEXT`/`BLOB`.

- Fixed `ArrayIndexOutOfBounds` when sending large `BLOB` queries. (Max size packet was not being set)

- Added `ISOLATION` level support to `Connection.setIsolationLevel()`

- Fixed NPE on `PreparedStatement.executeUpdate()` when all columns have not been set.

- Fixed data parsing of `TIMESTAMP` values with 2-digit years.

- Added `Byte` to `PreparedStatement.setObject()`.

- `ResultSet.getBoolean()` now recognizes `-1` as `true`.

- `ResultSet` has +/-Inf/inf support.

- `ResultSet.insertRow()` works now, even if not all columns are set (they will be set to `NULL`).

- `DataBaseMetaData.getCrossReference()` no longer `ArrayIndexOOB`.

- `getObject()` on `ResultSet` correctly does `TINYINT`->`Byte` and `SMALLINT`->`Short`.

### D.3.48. Changes in MySQL Connector/J 2.0.3 (03 December 2000)

- Implemented `getBigDecimal()` without scale component for JDBC2.

- Fixed composite key problem with updatable result sets.

- Added detection of -/+INF for doubles.

- Faster ASCII string operations.

- Fixed incorrect detection of `MAX_ALLOWED_PACKET`, so sending large blobs should work now.

- Fixed off-by-one error in `java.sql.Blob` implementation code.

- Added `ultraDevHack` URL parameter, set to `true` to allow (broken) Macromedia UltraDev to use the driver.

### D.3.49. Changes in MySQL Connector/J 2.0.1 (06 April 2000)

- Fixed `RSMD.isWritable()` returning wrong value. Thanks to Moritz Maass.

- Cleaned up exception handling when driver connects.

- Columns that are of type `TEXT` now return as `Strings` when you use `getObject()`.

- `DatabaseMetaData.getPrimaryKeys()` now works correctly with respect to `key_seq`. Thanks to Brian Slesinsky.

- No escape processing is done on `PreparedStatements` anymore per JDBC spec.

- Fixed many JDBC-2.0 traversal, positioning bugs, especially with respect to empty result sets. Thanks to Ron Smits, Nick Brook, Cessar Garcia and Carlos Martinez.

- Fixed some issues with updatability support in `ResultSet` when using multiple primary keys.

### D.3.50. Changes in MySQL Connector/J 2.0.0pre5 (21 February 2000)

- Fixed Bad Handshake problem.

### D.3.51. Changes in MySQL Connector/J 2.0.0pre4 (10 January 2000)

- Fixes to ResultSet for insertRow() - Thanks to Cesar Garcia

- Fix to Driver to recognize JDBC-2.0 by loading a JDBC-2.0 class, instead of relying on JDK version numbers. Thanks to John Baker.

- Fixed ResultSet to return correct row numbers

- Statement.getUpdateCount() now returns rows matched, instead of rows actually updated, which is more SQL-92 like.

10-29-99

- Statement/PreparedStatement.getMoreResults() bug fixed. Thanks to Noel J. Bergman.

- Added Short as a type to PreparedStatement.setObject(). Thanks to Jeff Crowder

- Driver now automagically configures maximum/preferred packet sizes by querying server.

- Autoreconnect code uses fast ping command if server supports it.

- Fixed various bugs with respect to packet sizing when reading from the server and when alloc'ing to write to the server.

### D.3.52. Changes in MySQL Connector/J 2.0.0pre (17 August 1999)

- Now compiles under JDK-1.2. The driver supports both JDK-1.1 and JDK-1.2 at the same time through a core set of classes. The driver will load the appropriate interface classes at runtime by figuring out which JVM version you are using.

- Fixes for result sets with all nulls in the first row. (Pointed out by Tim Endres)

- Fixes to column numbers in SQLExceptions in ResultSet (Thanks to Blas Rodriguez Somoza)

- The database no longer needs to specified to connect. (Thanks to Christian Motschke)

### D.3.53. Changes in MySQL Connector/J 1.2b (04 July 1999)

- Better Documentation (in progress), in doc/mm.doc/book1.html

- DBMD now allows null for a column name pattern (not in spec), which it changes to '%'.

- DBMD now has correct types/lengths for getXXX().

- ResultSet.getDate(), getTime(), and getTimestamp() fixes. (contributed by Alan Wilken)

- EscapeProcessor now handles \{ \} and { or } inside quotes correctly. (thanks to Alik for some ideas on how to fix it)

- Fixes to properties handling in Connection. (contributed by Juho Tikkala)

- ResultSet.getObject() now returns null for NULL columns in the table, rather than bombing out. (thanks to Ben Grosman)

- ResultSet.getObject() now returns Strings for types from MySQL that it doesn't know about. (Suggested by Chris Perdue)

- Removed DataInput/Output streams, not needed, 1/2 number of method calls per IO operation.

- Use default character encoding if one is not specified. This is a work-around for broken JVMs, because according to spec, EVERY JVM must support "ISO8859_1", but they don't.

- Fixed Connection to use the platform character encoding instead of "ISO8859_1" if one isn't explicitly set. This fixes problems people were having loading the character- converter classes that didn't always exist (JVM bug). (thanks to Fritz Elfert for pointing out this problem)

- Changed MysqlIO to re-use packets where possible to reduce memory usage.

- Fixed escape-processor bugs pertaining to {} inside quotes.

### D.3.54. Changes in MySQL Connector/J 1.2a (14 April 1999)

- Fixed character-set support for non-Javasoft JVMs (thanks to many people for pointing it out)

- Fixed ResultSet.getBoolean() to recognize 'y' & 'n' as well as '1' & '0' as boolean flags. (thanks to Tim Pizey)

- Fixed ResultSet.getTimestamp() to give better performance. (thanks to Richard Swift)

- Fixed getByte() for numeric types. (thanks to Ray Bellis)

- Fixed DatabaseMetaData.getTypeInfo() for DATE type. (thanks to Paul Johnston)

- Fixed EscapeProcessor for "fn" calls. (thanks to Piyush Shah at locomotive.org)

- Fixed EscapeProcessor to not do extraneous work if there are no escape codes. (thanks to Ryan Gustafson)

- Fixed Driver to parse URLs of the form "jdbc:mysql://host:port" (thanks to Richard Lobb)

### D.3.55. Changes in MySQL Connector/J 1.1i (24 March 1999)

- Fixed Timestamps for PreparedStatements

- Fixed null pointer exceptions in RSMD and RS

- Re-compiled with jikes for valid class files (thanks ms!)

### D.3.56. Changes in MySQL Connector/J 1.1h (08 March 1999)

- Fixed escape processor to deal with unmatched { and } (thanks to Craig Coles)

- Fixed escape processor to create more portable (between DATETIME and TIMESTAMP types) representations so that it will work with BETWEEN clauses. (thanks to Craig Longman)

- MysqlIO.quit() now closes the socket connection. Before, after many failed connections some OS's would run out of file descriptors. (thanks to Michael Brinkman)

- Fixed NullPointerException in Driver.getPropertyInfo. (thanks to Dave Potts)

- Fixes to MysqlDefs to allow all *text fields to be retrieved as Strings. (thanks to Chris at Leverage)

- Fixed setDouble in PreparedStatement for large numbers to avoid sending scientific notation to the database. (thanks to J.S. Ferguson)

- Fixed getScale() and getPrecision() in RSMD. (contrib'd by James Klicman)

- Fixed getObject() when field was DECIMAL or NUMERIC (thanks to Bert Hobbs)

- DBMD.getTables() bombed when passed a null table-name pattern. Fixed. (thanks to Richard Lobb)

- Added check for "client not authorized" errors during connect. (thanks to Hannes Wallnoefer)

### D.3.57. Changes in MySQL Connector/J 1.1g (19 February 1999)

- Result set rows are now byte arrays. Blobs and Unicode work bidriectonally now. The useUnicode and encoding options are implemented now.

- Fixes to PreparedStatement to send binary set by setXXXStream to be sent untouched to the MySQL server.

- Fixes to getDriverPropertyInfo().

### D.3.58. Changes in MySQL Connector/J 1.1f (31 December 1998)

- Changed all ResultSet fields to Strings, this should allow Unicode to work, but your JVM must be able to convert between the character sets. This should also make reading data from the server be a bit quicker, because there is now no conversion from StringBuffer to String.

- Changed PreparedStatement.streamToString() to be more efficient (code from Uwe Schaefer).

- URL parsing is more robust (throws SQL exceptions on errors rather than NullPointerExceptions)

- PreparedStatement now can convert Strings to Time/Date values via setObject() (code from Robert Currey).

- IO no longer hangs in Buffer.readInt(), that bug was introduced in 1.1d when changing to all byte-arrays for result sets. (Pointed out by Samo Login)

### D.3.59. Changes in MySQL Connector/J 1.1b (03 November 1998)

- Fixes to DatabaseMetaData to allow both IBM VA and J-Builder to work. Let me know how it goes. (thanks to Jac Kersing)

- Fix to ResultSet.getBoolean() for NULL strings (thanks to Barry Lagerweij)

- Beginning of code cleanup, and formatting. Getting ready to branch this off to a parallel JDBC-2.0 source tree.

- Added "final" modifier to critical sections in MysqlIO and Buffer to allow compiler to inline methods for speed.

9-29-98

- If object references passed to setXXX() in PreparedStatement are null, setNull() is automatically called for you. (Thanks for the suggestion goes to Erik Ostrom)

- setObject() in PreparedStatement will now attempt to write a serialized representation of the object to the database for objects of Types.OTHER and objects of unknown type.

- Util now has a static method readObject() which given a ResultSet and a column index will re-instantiate an object serialized in the above manner.

### D.3.60. Changes in MySQL Connector/J 1.1 (02 September 1998)

- Got rid of "ugly hack" in MysqlIO.nextRow(). Rather than catch an exception, Buffer.isLastDataPacket() was fixed.

- Connection.getCatalog() and Connection.setCatalog() should work now.

- Statement.setMaxRows() works, as well as setting by property maxRows. Statement.setMaxRows() overrides maxRows set via properties or url parameters.

- Automatic re-connection is available. Because it has to "ping" the database before each query, it is turned off by default. To use it, pass in "autoReconnect=true" in the connection URL. You may also change the number of reconnect tries, and the initial timeout value via "maxReconnects=n" (default 3) and "initialTimeout=n" (seconds, default 2) parameters. The timeout is an exponential backoff type of timeout; for example, if you have initial timeout of 2 seconds, and maxReconnects of 3, then the driver will timeout 2 seconds, 4 seconds, then 16 seconds between each re-connection attempt.

### D.3.61. Changes in MySQL Connector/J 1.0 (24 August 1998)

- Fixed handling of blob data in Buffer.java

- Fixed bug with authentication packet being sized too small.

- The JDBC Driver is now under the LPGL

8-14-98

- Fixed Buffer.readLenString() to correctly read data for BLOBS.

- Fixed PreparedStatement.stringToStream to correctly read data for BLOBS.

- Fixed PreparedStatement.setDate() to not add a day. (above fixes thanks to Vincent Partington)

- Added URL parameter parsing (?user=... and so forth).

### D.3.62. Changes in MySQL Connector/J 0.9d (04 August 1998)

- Big news! New package name. Tim Endres from ICE Engineering is starting a new source tree for GNU GPL'd Java software. He's graciously given me the org.gjt.mm package directory to use, so now the driver is in the org.gjt.mm.mysql package scheme. I'm "legal" now. Look for more information on Tim's project soon.

- Now using dynamically sized packets to reduce memory usage when sending commands to the DB.

- Small fixes to getTypeInfo() for parameters, and so forth.

- DatabaseMetaData is now fully implemented. Let me know if these drivers work with the various IDEs out there. I've heard that they're working with JBuilder right now.

- Added JavaDoc documentation to the package.

- Package now available in .zip or .tar.gz.

### D.3.63. Changes in MySQL Connector/J 0.9 (28 July 1998)

- Implemented getTypeInfo(). Connection.rollback() now throws an SQLException per the JDBC spec.

- Added PreparedStatement that supports all JDBC API methods for PreparedStatement including InputStreams. Please check this out and let me know if anything is broken.

- Fixed a bug in ResultSet that would break some queries that only returned 1 row.

- Fixed bugs in DatabaseMetaData.getTables(), DatabaseMetaData.getColumns() and DatabaseMetaData.getCatalogs().

- Added functionality to Statement that allows executeUpdate() to store values for IDs that are automatically generated for AUTO_INCREMENT fields. Basically, after an executeUpdate(), look at the SQLWarnings for warnings like "LAST_INSERTED_ID = 'some number', COMMAND = 'your SQL query'". If you are using AUTO_INCREMENT fields in your tables and are executing a lot of executeUpdate()s on one Statement, be sure to clearWarnings() every so often to save memory.

### D.3.64. Changes in MySQL Connector/J 0.8 (06 July 1998)

- Split MysqlIO and Buffer to separate classes. Some ClassLoaders gave an IllegalAccess error for some fields in those two classes. Now mm.mysql works in applets and all classloaders. Thanks to Joe Ennis <jce@mail.boone.com> for pointing out the problem and working on a fix with me.

### D.3.65. Changes in MySQL Connector/J 0.7 (01 July 1998)

- Fixed DatabaseMetadata problems in getColumns() and bug in switch statement in the Field constructor. Thanks to Costin Manolache <costin@tdiinc.com> for pointing these out.

### D.3.66. Changes in MySQL Connector/J 0.6 (21 May 1998)

- Incorporated efficiency changes from Richard Swift <Richard.Swift@kanatek.ca> in `MysqlIO.java` and `ResultSet.java`:

- We're now 15% faster than gwe's driver.

- Started working on `DatabaseMetaData`.

- The following methods are implemented:

  - `getTables()`

  - `getTableTypes()`

  - `getColumns`

  - `getCatalogs()`

Dies ist eine Übersetzung des MySQL-Referenzhandbuchs, das sich auf dev.mysql.com befindet. Das ursprüngliche Referenzhandbuch ist auf Englisch, und diese Übersetzung ist nicht notwendigerweise so aktuell wie die englische Ausgabe. Das vorliegende deutschsprachige Handbuch behandelt MySQL bis zur Version 5.1.

Zurück |  | Weiter
Anhang C. Danksagungen | Zum Anfang | Anhang E. Anmerkungen zur Portierung auf andere Systeme