MySQL Connector/J

Optional logging class com.mysql.jdbc.log.Log4JLogger was not included in the source/binary package for 5.1.14.

5.1.15 will ship with an SLF4J logger (which can then be plugged into Log4J). Unfortunately, it is not possible to ship a direct Log4J integration because the GPL is not compatible with Log4J's license. (Bug #59511, Bug #11766408)

The hard-coded list of reserved words in Connector/J was not updated to reflect the list of reserved words in MySQL Server 5.5. (Bug #59224)

MySqlProcedure accepted null arguments as parameters, however the JDBC meta data did not indicate that. (Bug #38367, Bug #11749186)

Using Connector/J to connect from a z/OS machine to a MySQL Server failed when the database name to connect to was included in the connection URL. This was because the name was sent in z/OS default platform encoding, but the MySQL Server expected Latin1.

It should be noted that when connecting from systems that do not use Latin1 as the default platform encoding, the following connection string options can be useful: passwordCharacterEncoding=ASCII and characterEncoding=ASCII. (Bug #18086, Bug #11745647)

Connector/J's load-balancing functionality only allowed the following events to trigger failover:

This meant that connections where auto-commit was enabled were not balanced, except for Exceptions, and this was problematic in the case of distribution of read-only work across slaves in a replication deployment.

The ability to load-balance while auto-commit is enabled has now been added to Connector/J. This introduces two new properties:

Load-balancing will be done after the statement is executed, before control is returned to the application. If rebalancing fails, the driver will silently swallow the resulting Exception (as the statement itself completed successfully). (Bug #55723)

Connection failover left slave/secondary in read-only mode. Failover attempts between two read-write masters did not properly set this.currentConn.setReadOnly(false). (Bug #58706)

Connector/J mapped both 3-byte and 4-byte UTF8 encodings to the same Java UTF8 encoding.

To use 3-byte UTF8 with Connector/J set characterEncoding=utf8 and set useUnicode=true in the connection string.

To use 4-byte UTF8 with Connector/J configure the MySQL server with character_set_server=utf8mb4. Connector/J will then use that setting as long as characterEncoding has not been set in the connection string. This is equivalent to autodetection of the character set. (Bug #58232)

The CallableStatementRegression test suite failed with a Null Pointer Exception because the OUT parameter in the I__S.PARAMETERS table had no name, that is COLUMN_NAME had the value NULL. (Bug #58232)

DatabaseMetaData.supportsMultipleResultSets() was hard-coded to return false, even though Connector/J supports multiple result sets. (Bug #57380)

Using the useOldUTF8Behavior parameter failed to set the connection character set to latin1 as required.

In versions prior to 5.1.3, the handshake was done using latin1, and while there was logic in place to explicitly set the character set after the handshake was complete, this was bypassed when useOldUTF8Behavior was true. This was not a problem until 5.1.3, when the handshake was modified to use utf8, but the logic continued to allow the character set configured during that handshake process to be retained for later use. As a result, useOldUTF8Behavior effectively failed. (Bug #57262)

Invoking a stored procedure containing output parameters by its full name, where the procedure was located in another database, generated the following exception:

Parameter index of 1 is out of range (1, 0)

(Bug #57022)

When a JDBC client disconnected from a remote server using Connection.close(), the TCP connection remained in the TIME_WAIT state on the server side, rather than on the client side. (Bug #56979)

Leaving Trust/ClientCertStoreType properties unset caused an exception to be thrown when connecting with useSSL=true, as no default was used. (Bug #56955)

When load-balanced connections swap servers, certain session state was copied from the previously active connection to the newly-selected connection. State synchronized included:

However, the read-only state was not synchronized, which caused problems if a write was attempted on a read-only connection. (Bug #56706)

When using Connector/J configured for failover (jdbc:mysql://host1,host2,... URLs), the non-primary servers re-balanced when the transactions on the master were committed or rolled-back. (Bug #56429)

An unhandled Null Pointer Exception (NPE) was generated in DatabaseMetaData.java when calling an incorrectly cased function name where no permission to access mysql.proc was available.

In addition to catching potential NPEs, a guard against calling JDBC functions with db_name.proc_name notation was also added. (Bug #56305)

Attempting to use JDBC4 functions on Connection objects resulted in errors being generated:

Exception in thread "main" java.lang.AbstractMethodError:
com.mysql.jdbc.LoadBalancedMySQLConnection.createBlob()Ljava/sql/Blob;
   at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
   at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
   at
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
   at java.lang.reflect.Method.invoke(Method.java:597)
   at
com.mysql.jdbc.LoadBalancingConnectionProxy.invoke(LoadBalancingConnectionProxy.java:476)
   at $Proxy0.createBlob(Unknown Source)

(Bug #56099)

Connector/J did not support utf8mb4 for servers 5.5.2 and newer.

Connector/J now auto-detects servers configured with character_set_server=utf8mb4 or treats the Java encoding utf-8 passed using characterEncoding=... as utf8mb4 in the SET NAMES= calls it makes when establishing the connection. (Bug #54175)

The method unSafeStatementInterceptors() contained an erroneous line of code, which resulted in the interceptor being called, but the result being thrown away. (Bug #53041)

There was a performance regression of roughly 25% between r906 and r907, which appeared to be caused by pushing the Proxy down to the I/O layer. (Bug #52534)

Logic in implementations of LoadBalancingConnectionProxy and LoadBalanceStrategy behaved differently as to which SQLExceptions trigger failover to a new host. The former looked at the first two characters of the SQLState:

if (sqlState.startsWith("08"))
...

The latter used a different test:

if (sqlEx instanceof CommunicationsException
  || "08S01".equals(sqlEx.getSQLState())) {
...

This meant it was possible for a new Connection object to throw an Exception when the first selected host was unavailable. This happened because MySqlIO.createNewIO() could throw an SQLException with a SQLState of “08001”, which did not trigger the “try another host” logic in the LoadBalanceStrategy implementations, so an Exception was thrown after having only attempted connecting to a single host. (Bug #52231)

In the file DatabaseMetadata.java, the function private void getCallStmtParameterTypes failed if the parameter was defined over more than one line by using the '\n' character. (Bug #52167)

The catalog parameter, PARAM_CAT, was not correctly processed when calling for metadata with getMetaData() on stored procedures. This was because PARAM_CAT was hardcoded in the code to NULL. In the case where nullcatalogmeanscurrent was true, which is its default value, a crash did not occur, but the metadata returned was for the stored procedures from the catalog currently attached to. If, however, nullcatalogmeanscurrent was set to false then a crash resulted.

Connector/J has been changed so that when NULL is passed as PARAM_CAT it will not crash when nullcatalogmeanscurrent is false, but rather iterate all catalogs in search of stored procedures. This means that PARAM_CAT is no longer hardcoded to NULL (see Bug #51904). (Bug #51912)

A load balanced Connection object with multiple open underlying physical connections rebalanced on commit(), rollback(), or on a communication exception, without validating the existing connection. This caused a problem when there was no pinging of the physical connections, using queries starting with “/* ping */”, to ensure they remained active. This meant that calls to Connection.commit() could throw a SQLException. This did not occur when the transaction was actually committed; it occurred when the new connection was chosen and the driver attempted to set the auto-commit or transaction isolation state on the newly chosen physical connection. (Bug #51783)

The rollback() method could fail to rethrow a SQLException if the server became unavailable during a rollback. The errant code only rethrew when ignoreNonTxTables was true and the exception did not have the error code 1196, SQLError.ER_WARNING_NOT_COMPLETE_ROLLBACK. (Bug #51776)

When the allowMultiQueries connection string option was set to true, a call to Statement.executeBatch() scanned the query for escape codes, even though setEscapeProcessing(false) had been called previously. (Bug #51704)

When a StatementInterceptor was used and an alternate ResultSet was returned from preProcess(), the original statement was still executed. (Bug #51666)

Objects created by ConnectionImpl, such as prepared statements, hold a reference to the ConnectionImpl that created them. However, when the load balancer picked a new connection, it did not update the reference contained in, for example, the PreparedStatement. This resulted in inserts and updates being directed to invalid connections, while commits were directed to the new connection. This resulted in silent data loss. (Bug #51643)

jdbc:mysql:loadbalance:// would connect to the same host, even though loadBalanceStrategy was set to a value of random, and multiple hosts were specified. (Bug #51266)

An unexpected exception when trying to register OUT parameters in CallableStatement.

Sometimes Connector/J was not able to register OUT parameters for CallableStatements. (Bug #43576)

The catalog parameter was ignored in the DatabaseMetaData.getProcedure() method. It returned all procedures in all databases. (Bug #51022)

A call to DatabaseMetaData.getDriverVersion() returned the revision as mysql-connector-java-5.1.11 ( Revision: ${svn.Revision} ). The variable ${svn.Revision} was not replaced by the SVN revision number. (Bug #50288)

Replication connections, those with URLs that start with jdbc:mysql:replication, now use a jdbc:mysql:loadbalance connection for the slave pool. This means that it is possible to set load balancing properties such as loadBalanceBlacklistTimeout and loadBalanceStrategy to choose a mechanism for balancing the load, and failover or fault tolerance strategy for the slave pool. (Bug #49537)

NullPointerException sometimes occurred in invalidateCurrentConnection() for load-balanced connections. (Bug #50288)

The deleteRow method caused a full table scan, when using an updatable cursor and a multibyte character set. (Bug #49745)

For pooled connections, Connector/J did not process the session variable time_zone when set using the URL, resulting in incorrect timestamp values being stored. (Bug #49700)

The ExceptionInterceptor class did not provide a Connection context. (Bug #49607)

Ping left closed connections in the liveConnections map, causing subsequent Exceptions when that connection was used. (Bug #48605)

Using MysqlConnectionPoolDataSource with a load-balanced URL generated exceptions of type ClassCastException:

ClassCastException in MysqlConnectionPoolDataSource
Caused by: java.lang.ClassCastException: $Proxy0
   at
com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource.getPooledConnection(MysqlConne
ctionPoolDataSource.java:80)

java.lang.ClassCastException: $Proxy2
 at com.mysql.jdbc.jdbc2.optional.StatementWrapper.executeQuery(StatementWrapper.java:744)

(Bug #48486)

The implementation for load-balanced Connection used a proxy, which delegated method calls, including equals() and hashCode(), to underlying Connection objects. This meant that successive calls to hashCode() on the same object potentially returned different values, if the proxy state had changed such that it was utilizing a different underlying connection. (Bug #48442)

The batch rewrite functionality attempted to identify the start of the VALUES list by looking for “VALUES ” (with trailing space). However, valid MySQL syntax permits VALUES to be followed by whitespace or an opening parenthesis:

INSERT INTO tbl VALUES
(1);

INSERT INTO tbl VALUES(1);

Queries written with the above formats did not therefore gain the performance benefits of the batch rewrite. (Bug #48172)

A PermGen memory leaked was caused by the Connector/J statement cancellation timer (java.util.Timer). When the application was unloaded the cancellation timer did not terminate, preventing the ClassLoader from being garbage collected. (Bug #36565)

With the connection string option noDatetimeStringSync set to true, and server-side prepared statements enabled, the following exception was generated if an attempt was made to obtain, using ResultSet.getString(), a datetime value containing all zero components:

java.sql.SQLException: Value '0000-00-00' can not be represented as java.sql.Date

(Bug #32525)

The DriverManager.getConnection() method ignored a non-standard port if it was specified in the JDBC connection string. Connector/J always used the standard port 3306 for connection creation. For example, if the string was jdbc:mysql://localhost:6777, Connector/J would attempt to connect to port 3306, rather than 6777. (Bug #47494)

In the class com.mysql.jdbc.jdbc2.optional.SuspendableXAConnection, which is used when pinGlobalTxToPhysicalConnection=true, there is a static map (XIDS_TO_PHYSICAL_CONNECTIONS) that tracks the Xid with the XAConnection, however this map was not populated. The effect was that the SuspendableXAConnection was never pinned to the real XA connection. Instead it created new connections on calls to start, end, resume, and prepare. (Bug #46925)

When using the ON DUPLICATE KEY UPDATE functionality together with the rewriteBatchedStatements option set to true, an exception was generated when trying to execute the prepared statement:

INSERT INTO config_table (modified,id_) VALUES (?,?) ON DUPLICATE KEY UPDATE modified=?

The exception generated was:

java.sql.SQLException: Parameter index out of range (3 > number of parameters, which is
2).
	at com.sag.etl.job.processors.JdbcInsertProcessor.flush(JdbcInsertProcessor.java:135)
......
Caused by: java.sql.SQLException: Parameter index out of range (3 > number of parameters,
which is 2).
	at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1055)
	at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:956)
	at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:926)
	at com.mysql.jdbc.PreparedStatement.checkBounds(PreparedStatement.java:3657)
	at com.mysql.jdbc.PreparedStatement.setInternal(PreparedStatement.java:3641)
	at
com.mysql.jdbc.PreparedStatement.setBytesNoEscapeNoQuotes(PreparedStatement.java:3391)
	at
com.mysql.jdbc.PreparedStatement.setOneBatchedParameterSet(PreparedStatement.java:4203)
	at com.mysql.jdbc.PreparedStatement.executeBatchedInserts(PreparedStatement.java:1759)
	at com.mysql.jdbc.PreparedStatement.executeBatch(PreparedStatement.java:1441)
	at com.sag.etl.job.processors.JdbcInsertProcessor.flush(JdbcInsertProcessor.java:131)
	... 16 more

(Bug #46788)

When Connector/J encountered an error condition that caused it to create a CommunicationsException, it tried to build a friendly error message that helped diagnose what was wrong. However, if there had been no network packets received from the server, the error message contained the following incorrect text:

The last packet successfully received from the server was 1,249,932,468,916 milliseconds
ago.  The last packet sent successfully to the server was 0 milliseconds ago.

(Bug #46637)

The getSuperTypes method returned a result set with incorrect names for the first two columns. The name of the first column in the result set was expected to be TYPE_CAT and that of the second column TYPE_SCHEM. The method however returned the names as TABLE_CAT and TABLE_SCHEM for first and second column respectively. (Bug #44508)

SQLException for data truncation error gave the error code as 0 instead of 1265. (Bug #44324)

Calling ResultSet.deleteRow() on a table with a primary key of type BINARY(8) silently failed to delete the row, but only in some repeatable cases. The generated DELETE statement generated corrupted part of the primary key data. Specifically, one of the bytes was changed from 0x90 to 0x9D, although the corruption appeared to be different depending on whether the application was run on Windows or Linux. (Bug #43759)

Accessing result set columns by name after the result set had been closed resulted in a NullPointerException instead of a SQLException. (Bug #41484)

QueryTimeout did not work for batch statements waiting on a locked table.

When a batch statement was issued to the server and was forced to wait because of a locked table, Connector/J only terminated the first statement in the batch when the timeout was exceeded, leaving the rest hanging. (Bug #34555)

The parseURL method in class com.mysql.jdbc.Driver did not work as expected. When given a URL such as “jdbc:mysql://www.mysql.com:12345/my_database” to parse, the property PORT_PROPERTY_KEY was found to be null and the HOST_PROPERTY_KEY property was found to be “www.mysql.com:12345”.

(Bug #32216)

Attempting to delete rows using ResultSet.deleteRow() did not delete rows correctly. (Bug #27431)

The setDate method silently ignored the Calendar parameter. The code was implemented as follows:

public void setDate(int parameterIndex, java.sql.Date x, Calendar cal) throws SQLException {
   setDate(parameterIndex, x);
}        
      

From reviewing the code it was apparent that the Calendar parameter cal was ignored. (Bug #23584)

The reported milliseconds since the last server packets were received/sent was incorrect by a factor of 1000. For example, the following method call:

SQLError.createLinkFailureMessageBasedOnHeuristics(
(ConnectionImpl) this.conn, 
System.currentTimeMillis() - 1000,
System.currentTimeMillis() - 2000,
e, 
false);

returned the following string:

The last packet successfully received from the server 
was 2 milliseconds ago. The last packet sent successfully to the 
server was 1 milliseconds ago.

(Bug #45419)

Calling Connection.serverPrepareStatement() variants that do not take result set type or concurrency arguments returned statements that produced result sets with incorrect defaults, namely TYPE_SCROLL_SENSITIVE. (Bug #45171)

The result set returned by getIndexInfo() did not have the format defined in the JDBC API specifications. The fourth column, DATA_TYPE, of the result set should be of type BOOLEAN. Connector/J however returns CHAR. (Bug #44869)

The result set returned by getTypeInfo() did not have the format defined in the JDBC API specifications. The second column, DATA_TYPE, of the result set should be of type INTEGER. Connector/J however returns SMALLINT. (Bug #44868)

The DEFERRABILITY column in database metadata result sets was expected to be of type SHORT. However, Connector/J returned it as INTEGER.

This affected the following methods: getImportedKeys(), getExportedKeys(), getCrossReference(). (Bug #44867)

The result set returned by getColumns() did not have the format defined in the JDBC API specifications. The fifth column, DATA_TYPE, of the result set should be of type INTEGER. Connector/J however returns SMALLINT. (Bug #44865)

The result set returned by getVersionColumns() did not have the format defined in the JDBC API specifications. The third column, DATA_TYPE, of the result set should be of type INTEGER. Connector/J however returns SMALLINT. (Bug #44863)

The result set returned by getBestRowIdentifier() did not have the format defined in the JDBC API specifications. The third column, DATA_TYPE, of the result set should be of type INTEGER. Connector/J however returns SMALLINT. (Bug #44862)

Connector/J contains logic to generate a message text specifically for streaming result sets when there are CommunicationsException exceptions generated. However, this code was never reached.

In the CommunicationsException code:

private boolean streamingResultSetInPlay = false;

public CommunicationsException(ConnectionImpl conn, long lastPacketSentTimeMs,
long lastPacketReceivedTimeMs, Exception underlyingException) {

this.exceptionMessage = SQLError.createLinkFailureMessageBasedOnHeuristics(conn,
      lastPacketSentTimeMs, lastPacketReceivedTimeMs, underlyingException,
      this.streamingResultSetInPlay);

streamingResultSetInPlay was always false, which in the following code in SQLError.createLinkFailureMessageBasedOnHeuristics() never being executed:

if (streamingResultSetInPlay) {
    exceptionMessageBuf.append(
    Messages.getString("CommunicationsException.ClientWasStreaming")); //$NON-NLS-1$
} else {
...

(Bug #44588)

The SQLError.createLinkFailureMessageBasedOnHeuristics() method created a message text for communication link failures. When certain conditions were met, this message included both “last packet sent” and “last packet received” information, but when those conditions were not met, only “last packet sent” information was provided.

Information about when the last packet was successfully received should be provided in all cases. (Bug #44587)

Statement.getGeneratedKeys() retained result set instances until the statement was closed. This caused memory leaks for long-lived statements, or statements used in tight loops. (Bug #44056)

Using useInformationSchema with DatabaseMetaData.getExportedKeys() generated the following exception:

com.mysql.jdbc.exceptions.MySQLIntegrityConstraintViolationException: Column
'REFERENCED_TABLE_NAME' in where clause is ambiguous
...
at com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:1772)
at com.mysql.jdbc.PreparedStatement.executeQuery(PreparedStatement.java:1923)
at
com.mysql.jdbc.DatabaseMetaDataUsingInfoSchema.executeMetadataQuery(
DatabaseMetaDataUsingInfoSchema.java:50)
at
com.mysql.jdbc.DatabaseMetaDataUsingInfoSchema.getExportedKeys(
DatabaseMetaDataUsingInfoSchema.java:603)

(Bug #43714)

LoadBalancingConnectionProxy.doPing() did not have blacklist awareness.

LoadBalancingConnectionProxy implemented doPing() to ping all underlying connections, but it threw any exceptions it encountered during this process.

With the global blacklist enabled, it catches these exceptions, adds the host to the global blacklist, and only throws an exception if all hosts are down. (Bug #43421)

The method Statement.getGeneratedKeys() did not return values for UNSIGNED BIGINTS with values greater than Long.MAX_VALUE.

Unfortunately, because the server does not tell clients what TYPE the auto increment value is, the driver cannot consistently return BigIntegers for the result set returned from getGeneratedKeys(), it will only return them if the value is greater than Long.MAX_VALUE. If your application needs this consistency, it will need to check the class of the return value from .getObject() on the ResultSet returned by Statement.getGeneratedKeys() and if it is not a BigInteger, create one based on the java.lang.Long that is returned. (Bug #43196)

When the MySQL Server was upgraded from 4.0 to 5.0, the Connector/J application then failed to connect to the server. This was because authentication failed when the application ran from EBCDIC platforms such as z/OS. (Bug #43071)

When connecting with traceProtocol=true, no trace data was generated for the server greeting or login request. (Bug #43070)

Connector/J generated an unhandled StringIndexOutOfBoundsException:

java.lang.StringIndexOutOfBoundsException: String index out of range: -1
at java.lang.String.substring(String.java:1938)
at com.mysql.jdbc.EscapeProcessor.processTimeToken(EscapeProcessor.java:353)
at com.mysql.jdbc.EscapeProcessor.escapeSQL(EscapeProcessor.java:257)
at com.mysql.jdbc.StatementImpl.executeUpdate(StatementImpl.java:1546)
at com.mysql.jdbc.StatementImpl.executeUpdate(StatementImpl.java:1524)

(Bug #42253)

A ConcurrentModificationException was generated in LoadBalancingConnectionProxy:

java.util.ConcurrentModificationException
 at java.util.HashMap$HashIterator.nextEntry(Unknown Source)
 at java.util.HashMap$KeyIterator.next(Unknown Source)
 at
com.mysql.jdbc.LoadBalancingConnectionProxy.getGlobalBlacklist(LoadBalancingConnectionProxy.java:520)
 at com.mysql.jdbc.RandomBalanceStrategy.pickConnection(RandomBalanceStrategy.java:55)
 at
com.mysql.jdbc.LoadBalancingConnectionProxy.pickNewConnection(LoadBalancingConnectionProxy.java:414)
 at
com.mysql.jdbc.LoadBalancingConnectionProxy.invoke(LoadBalancingConnectionProxy.java:390)

(Bug #42055)

SQL injection was possible when using a string containing U+00A5 in a client-side prepared statement, and the character set being used was SJIS/Windows-31J. (Bug #41730)

If there was an apostrophe in a comment in a statement that was being sent through Connector/J, the apostrophe was still recognized as a quote and put the state machine in EscapeTokenizer into the inQuotes state. This led to further parse errors.

For example, consider the following statement:

String sql = "-- Customer's zip code will be fixed\n" +
  "update address set zip_code = 99999\n" +
  "where not regexp '^[0-9]{5}([[.-.]])?([0-9]{4})?$'";

When passed through Connector/J, the EscapeTokenizer did not recognize that the first apostrophe was in a comment and thus set inQuotes to true. When that happened, the quote count was incorrect and thus the regular expression did not appear to be in quotation marks. With the parser not detecting that the regular expression was in quotation marks, the curly braces were recognized as escape sequences and were removed from the regular expression, breaking it. The server thus received SQL such as:

-- Customer's zip code will be fixed
update address set zip_code = '99999'
where not regexp '^[0-9]([[.-.]])?([0-9])?$'

(Bug #41566)

MySQL Connector/J 5.1.7 was slower than previous versions when the rewriteBatchedStatements option was set to true.

(Bug #41532)

When accessing a result set column by name using ResultSetImpl.findColumn() an exception was generated:

java.lang.NullPointerException
at com.mysql.jdbc.ResultSetImpl.findColumn(ResultSetImpl.java:1103)
at com.mysql.jdbc.ResultSetImpl.getShort(ResultSetImpl.java:5415)
at org.apache.commons.dbcp.DelegatingResultSet.getShort(DelegatingResultSet.java:219)
at com.zimbra.cs.db.DbVolume.constructVolume(DbVolume.java:297)
at com.zimbra.cs.db.DbVolume.get(DbVolume.java:197)
at com.zimbra.cs.db.DbVolume.create(DbVolume.java:95)
at com.zimbra.cs.store.Volume.create(Volume.java:227)
at com.zimbra.cs.store.Volume.create(Volume.java:189)
at com.zimbra.cs.service.admin.CreateVolume.handle(CreateVolume.java:48)
at com.zimbra.soap.SoapEngine.dispatchRequest(SoapEngine.java:428)
at com.zimbra.soap.SoapEngine.dispatch(SoapEngine.java:285)

(Bug #41484)

The RETURN_GENERATED_KEYS flag was being ignored. For example, in the following code the RETURN_GENERATED_KEYS flag was ignored:

PreparedStatement ps = connection.prepareStatement("INSERT INTO table
  values(?,?)",PreparedStatement.RETURN_GENERATED_KEYS);

(Bug #41448)

When using Connector/J 5.1.7 to connect to MySQL Server 4.1.18 the following error message was generated:

Thu Dec 11 17:38:21 PST 2008 WARN: Invalid value {1} for server variable named {0},
falling back to sane default of {2}

This occurred with MySQL Server version that did not support auto_increment_increment. The error message should not have been generated. (Bug #41416)

When DatabaseMetaData.getProcedureColumns() was called, the value for LENGTH was always returned as 65535, regardless of the column type (fixed or variable) or the actual length of the column.

However, if you obtained the PRECISION value, this was correct for both fixed and variable length columns. (Bug #41269)

PreparedStatement.addBatch() did not check for all parameters being set, which led to inconsistent behavior in executeBatch(), especially when rewriting batched statements into multi-value INSERTs. (Bug #41161)

Error message strings contained variable values that were not expanded. For example:

Mon Nov 17 11:43:18 JST 2008 WARN: Invalid value {1} for server variable named {0},
falling back to sane default of {2}

(Bug #40772)

When using rewriteBatchedStatements=true with:

INSERT INTO table_name_values (...) VALUES (...)

Query rewriting failed because “values” at the end of the table name was mistaken for the reserved keyword. The error generated was as follows:

testBug40439(testsuite.simple.TestBug40439)java.sql.BatchUpdateException: You have an
error in your SQL syntax; check the manual that corresponds to your MySQL server version
for the right syntax to use near 'values (2,'toto',2),(id,data, ordr) values
(3,'toto',3),(id,data, ordr) values (' at line 1
at com.mysql.jdbc.PreparedStatement.executeBatchedInserts(PreparedStatement.java:1495)
at com.mysql.jdbc.PreparedStatement.executeBatch(PreparedStatement.java:1097)
at testsuite.simple.TestBug40439.testBug40439(TestBug40439.java:42)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at testsuite.simple.TestBug40439.main(TestBug40439.java:57)

(Bug #40439)

A statement interceptor received the incorrect parameters when used with a batched statement. (Bug #39426)

Using Connector/J 5.1.6 the method ResultSet.getObject returned a BYTE[] for following:

SELECT TRIM(rowid) FROM tbl

Where rowid had a type of INT(11) PRIMARY KEY AUTO_INCREMENT.

The expected return type was one of CHAR, VARCHAR, CLOB, however, a BYTE[] was returned.

Further, adding functionsNeverReturnBlobs=true to the connection string did not have any effect on the return type. (Bug #38387)

When statements include ON DUPLICATE UPDATE, and rewriteBatchedStatements is set to true, batched statements are not rewritten into the form INSERT INTO table VALUES (), (), (), instead the statements are executed sequentially.

Statement.getGeneratedKeys() returned two keys when using ON DUPLICATE KEY UPDATE and the row was updated, not inserted. (Bug #42309)

When using the replication driver with autoReconnect=true, Connector/J checks in PreparedStatement.execute (also called by CallableStatement.execute) to determine if the first character of the statement is an “S”, in an attempt to block all statements that are not read-only-safe, for example non-SELECT statements. However, this also blocked CALLs to stored procedures, even if the stored procedures were defined as SQL READ DATA or NO SQL. (Bug #40031)

With large result sets ResultSet.findColumn became a performance bottleneck. (Bug #39962)

Connector/J ignored the value of the MySQL Server variable auto_increment_increment. (Bug #39956)

Connector/J failed to parse TIMESTAMP strings for nanos correctly. (Bug #39911)

When the LoadBalancingConnectionProxy handles a SQLException with SQL state starting with “08”, it calls invalidateCurrentConnection, which in turn removes that Connection from liveConnections and the connectionsToHostsMap, but it did not add the host to the new global blacklist, if the global blacklist was enabled.

There was also the possibility of a NullPointerException when trying to update stats, where connectionsToHostsMap.get(this.currentConn) was called:

int hostIndex = ((Integer) this.hostsToListIndexMap.get(this.connectionsToHostsMap.get(this.currentConn))).intValue();

This could happen if a client tried to issue a rollback after catching a SQLException caused by a connection failure. (Bug #39784)

When configuring the Java Replication Driver the last slave specified was never used. (Bug #39611)

When an INSERT ON DUPLICATE KEY UPDATE was performed, and the key already existed, the affected-rows value was returned as 1 instead of 0. (Bug #39352)

When using the random load balancing strategy and starting with two servers that were both unavailable, an IndexOutOfBoundsException was generated when removing a server from the whiteList. (Bug #38782)

Connector/J threw the following exception when using a read-only connection:

java.sql.SQLException: Connection is read-only. Queries leading to data
modification are not allowed.

(Bug #38747)

Connector/J was unable to connect when using a non-latin1 password. (Bug #37570)

The useOldAliasMetadataBehavior connection property was ignored. (Bug #35753)

Incorrect result is returned from isAfterLast() in streaming ResultSet when using setFetchSize(Integer.MIN_VALUE). (Bug #35170)

When getGeneratedKeys() was called on a statement that had not been created with RETURN_GENERATED_KEYS, no exception was thrown, and batched executions then returned erroneous values. (Bug #34185)

The loadBalance bestResponseTime blacklists did not have a global state. (Bug #33861)

Multiple result sets were not supported when using streaming mode to return data. Both normal statements and the resul sets from stored procedures now return multiple results sets, with the exception of result sets using registered OUTPUT parameters. (Bug #33678)

XAConnections and datasources have been updated to the JDBC-4.0 standard.

The profiler event handling has been made extensible using the profilerEventHandler connection property.

Add the verifyServerCertificate property. If set to "false" the driver will not verify the server's certificate when useSSL is set to "true"

When using this feature, the keystore parameters should be specified by the clientCertificateKeyStore* properties, rather than system properties, as the JSSE doesn't it straightforward to have a nonverifying trust store and the "default" key store.

DatabaseMetaData.getColumns() returns incorrect COLUMN_SIZE value for SET column. (Bug #36830)

When trying to read Time values like “00:00:00” with ResultSet.getTime(int) an exception is thrown. (Bug #36051)

JDBC connection URL parameters is ignored when using MysqlConnectionPoolDataSource. (Bug #35810)

When useServerPrepStmts=true and slow query logging is enabled, the connector throws a NullPointerException when it encounters a slow query. (Bug #35666)

When using the keyword “loadbalance” in the connection string and trying to perform load balancing between two databases, the driver appears to hang. (Bug #35660)

JDBC data type getter method was changed to accept only column name, whereas previously it accepted column label. (Bug #35610)

Prepared statements from pooled connections caused a NullPointerException when closed() under JDBC-4.0. (Bug #35489)

In calling a stored function returning a bigint, an exception is encountered beginning:

java.sql.SQLException: java.lang.NumberFormatException: For input string:

followed by the text of the stored function starting after the argument list. (Bug #35199)

The JDBC driver uses a different method for evaluating column names in resultsetmetadata.getColumnName() and when looking for a column in resultset.getObject(columnName). This causes Hibernate to fail in queries where the two methods yield different results, for example in queries that use alias names:

SELECT column AS aliasName from table

(Bug #35150)

MysqlConnectionPoolDataSource does not support ReplicationConnection. Notice that we implemented com.mysql.jdbc.Connection for ReplicationConnection, however, only accessors from ConnectionProperties are implemented (not the mutators), and they return values from the currently active connection. All other methods from com.mysql.jdbc.Connection are implemented, and operate on the currently active connection, with the exception of resetServerState() and changeUser(). (Bug #34937)

ResultSet.getTimestamp() returns incorrect values for month/day of TIMESTAMPs when using server-side prepared statements (not enabled by default). (Bug #34913)

RowDataStatic does't always set the metadata in ResultSetRow, which can lead to failures when unpacking DATE, TIME, DATETIME and TIMESTAMP types when using absolute, relative, and previous result set navigation methods. (Bug #34762)

When calling isValid() on an active connection, if the timeout is nonzero then the Connection is invalidated even if the Connection is valid. (Bug #34703)

It was not possible to truncate a BLOB using Blog.truncate() when using 0 as an argument. (Bug #34677)

When using a cursor fetch for a statement, the internal prepared statement could cause a memory leak until the connection was closed. The internal prepared statement is now deleted when the corresponding result set is closed. (Bug #34518)

When retrieving the column type name of a geometry field, the driver would return UNKNOWN instead of GEOMETRY. (Bug #34194)

Statements with batched values do not return correct values for getGeneratedKeys() when rewriteBatchedStatements is set to true, and the statement has an ON DUPLICATE KEY UPDATE clause. (Bug #34093)

The internal class ResultSetInternalMethods referenced the nonpublic class com.mysql.jdbc.CachedResultSetMetaData. (Bug #33823)

A NullPointerException could be raised when using client-side prepared statements and enabled the prepared statement cache using the cachePrepStmts. (Bug #33734)

Using server side cursors and cursor fetch, the table metadata information would return the data type name instead of the column name. (Bug #33594)

ResultSet.getTimestamp() would throw a NullPointerException instead of a SQLException when called on an empty ResultSet. (Bug #33162)

Load balancing connection using best response time would incorrectly "stick" to hosts that were down when the connection was first created.

We solve this problem with a black list that is used during the picking of new hosts. If the black list ends up including all configured hosts, the driver will retry for a configurable number of times (the retriesAllDown configuration property, with a default of 120 times), sleeping 250ms between attempts to pick a new connection.

We've also went ahead and made the balancing strategy extensible. To create a new strategy, implement the interface com.mysql.jdbc.BalanceStrategy (which also includes our standard "extension" interface), and tell the driver to use it by passing in the class name using the loadBalanceStrategy configuration property. (Bug #32877)

During a Daylight Savings Time (DST) switchover, there was no way to store two timestamp/datetime values , as the hours end up being the same when sent as the literal that MySQL requires.

Note that to get this scenario to work with MySQL (since it doesn't support per-value timezones), you need to configure your server (or session) to be in UTC, and tell the driver not to use the legacy date/time code by setting useLegacyDatetimeCode to "false". This will cause the driver to always convert to/from the server and client timezone consistently.

This bug fix also fixes BUG#15604, by adding entirely new date/time handling code that can be switched on by useLegacyDatetimeCode being set to "false" as a JDBC configuration property. For Connector/J 5.1.x, the default is "true", in trunk and beyond it will be "false" (that is, the old date/time handling code will be deprecated) (Bug #32577, Bug #15604)

When unpacking rows directly, we don't hand off error message packets to the internal method which decodes them correctly, so no exception is raised, and the driver than hangs trying to read rows that aren't there. This tends to happen when calling stored procedures, as normal SELECTs won't have an error in this spot in the protocol unless an I/O error occurs. (Bug #32246)

When using a connection from ConnectionPoolDataSource, some Connection.prepareStatement() methods would return null instead of the prepared statement. (Bug #32101)

Using CallableStatement.setNull() on a stored function would throw an ArrayIndexOutOfBounds exception when setting the last parameter to null. (Bug #31823)

MysqlValidConnectionChecker doesn't properly handle connections created using ReplicationConnection. (Bug #31790)

Retrieving the server version information for an active connection could return invalid information if the default character encoding on the host was not ASCII compatible. (Bug #31192)

Further fixes have been made to this bug in the event that a node is nonresponsive. Connector/J will now try a different random node instead of waiting for the node to recover before continuing. (Bug #31053)

ResultSet returned by Statement.getGeneratedKeys() is not closed automatically when statement that created it is closed. (Bug #30508)

DatabaseMetadata.getColumns() doesn't return the correct column names if the connection character isn't UTF-8. A bug in MySQL server compounded the issue, but was fixed within the MySQL 5.0 release cycle. The fix includes changes to all the sections of the code that access the server metadata. (Bug #20491)

Fixed ResultSetMetadata.getColumnName() for result sets returned from Statement.getGeneratedKeys() - it was returning null instead of "GENERATED_KEY" as in 5.0.x.

Support for JDBC-4.0 NCHAR, NVARCHAR and NCLOB types.

JDBC-4.0 support for setting per-connection client information (which can be viewed in the comments section of a query using SHOW PROCESSLIST on a MySQL server, or can be extended to support custom persistence of the information using a public interface).

Support for JDBC-4.0 XML processing using JAXP interfaces to DOM, SAX and StAX.

JDBC-4.0 standardized unwrapping to interfaces that include vendor extensions.

Added autoSlowLog configuration property, overrides slowQueryThreshold* properties, driver determines slow queries by those that are slower than 5 * stddev of the mean query time (outside the 96% percentile).

When a connection is in read-only mode, queries that are wrapped in parentheses were incorrectly identified DML statements. (Bug #28256)

When calling setTimestamp on a prepared statement, the timezone information stored in the calendar object was ignored. This resulted in the incorrect DATETIME information being stored. The following example illustrates this:

Timestamp t = new Timestamp( cal.getTimeInMillis() );
ps.setTimestamp( N, t, cal );

(Bug #15604)

Support for JDBC-4.0 NCHAR, NVARCHAR and NCLOB types.

JDBC-4.0 support for setting per-connection client information (which can be viewed in the comments section of a query using SHOW PROCESSLIST on a MySQL server, or can be extended to support custom persistence of the information using a public interface).

Support for JDBC-4.0 XML processing using JAXP interfaces to DOM, SAX and StAX.

JDBC-4.0 standardized unwrapping to interfaces that include vendor extensions.

Connector/J now connects using an initial character set of utf-8 solely for the purpose of authentication to permit user names or database names in any character set to be used in the JDBC connection URL. (Bug #29853)

Added two configuration parameters:

Setting rewriteBatchedStatements to true now causes CallableStatements with batched arguments to be re-written in the form "CALL (...); CALL (...); ..." to send the batch in as few client/server round trips as possible.

The driver now picks appropriate internal row representation (whole row in one buffer, or individual byte[]s for each column value) depending on heuristics, including whether or not the row has BLOB or TEXT types and the overall row-size. The threshold for row size that will cause the driver to use a buffer rather than individual byte[]s is configured by the configuration property largeRowSizeThreshold, which has a default value of 2KB.

The data (and how it is stored) for ResultSet rows are now behind an interface which enables us (in some cases) to allocate less memory per row, in that for "streaming" result sets, we re-use the packet used to read rows, since only one row at a time is ever active.

Added experimental support for statement "interceptors" through the com.mysql.jdbc.StatementInterceptor interface, examples are in com/mysql/jdbc/interceptors. Implement this interface to be placed "in between" query execution, so that it can be influenced (currently experimental).

The driver will automatically adjust the server session variable net_write_timeout when it determines its been asked for a "streaming" result, and resets it to the previous value when the result set has been consumed. (The configuration property is named netTimeoutForStreamingResults, with a unit of seconds, the value '0' means the driver will not try and adjust this value).

JDBC-4.0 ease-of-development features including auto-registration with the DriverManager through the service provider mechanism, standardized Connection validity checks and categorized SQLExceptions based on recoverability/retry-ability and class of the underlying error.

Statement.setQueryTimeout()s now affect the entire batch for batched statements, rather than the individual statements that make up the batch.

Errors encountered during Statement/PreparedStatement/CallableStatement.executeBatch() when rewriteBatchStatements has been set to true now return BatchUpdateExceptions according to the setting of continueBatchOnError.

If continueBatchOnError is set to true, the update counts for the "chunk" that were sent as one unit will all be set to EXECUTE_FAILED, but the driver will attempt to process the remainder of the batch. You can determine which "chunk" failed by looking at the update counts returned in the BatchUpdateException.

If continueBatchOnError is set to "false", the update counts returned will contain all updates up-to and including the failed "chunk", with all counts for the failed "chunk" set to EXECUTE_FAILED.

Since MySQL doesn't return multiple error codes for multiple-statements, or for multi-value INSERT/REPLACE, it is the application's responsibility to handle determining which item(s) in the "chunk" actually failed.

New methods on com.mysql.jdbc.Statement: setLocalInfileInputStream() and getLocalInfileInputStream():

Setting useBlobToStoreUTF8OutsideBMP to true tells the driver to treat [MEDIUM/LONG]BLOB columns as [LONG]VARCHAR columns holding text encoded in UTF-8 that has characters outside the BMP (4-byte encodings), which MySQL server can't handle natively.

Set utf8OutsideBmpExcludedColumnNamePattern to a regex so that column names matching the given regex will still be treated as BLOBs The regex must follow the patterns used for the java.util.regexpackage. The default is to exclude no columns, and include all columns.

Set utf8OutsideBmpIncludedColumnNamePattern to specify exclusion rules to utf8OutsideBmpExcludedColumnNamePattern". The regex must follow the patterns used for the java.util.regex package.

setObject(int, Object, int, int) delegate in PreparedStatementWrapper delegates to wrong method. (Bug #30892)

NPE with null column values when padCharsWithSpace is set to true. (Bug #30851)

Collation on VARBINARY column types would be misidentified. A fix has been added, but this fix only works for MySQL server versions 5.0.25 and newer, since earlier versions didn't consistently return correct metadata for functions, and thus results from subqueries and functions were indistinguishable from each other, leading to type-related bugs. (Bug #30664)

An ArithmeticException or NullPointerException would be raised when the batch had zero members and rewriteBatchedStatements=true when addBatch() was never called, or executeBatch() was called immediately after clearBatch(). (Bug #30550)

Closing a load-balanced connection would cause a ClassCastException. (Bug #29852)

Connection checker for JBoss didn't use same method parameters using reflection, causing connections to always seem "bad". (Bug #29106)

DatabaseMetaData.getTypeInfo() for the types DECIMAL and NUMERIC will return a precision of 254 for server versions older than 5.0.3, 64 for versions 5.0.3 to 5.0.5 and 65 for versions newer than 5.0.5. (Bug #28972)

CallableStatement.executeBatch() doesn't work when connection property noAccessToProcedureBodies has been set to true.

The fix involves changing the behavior of noAccessToProcedureBodies,in that the driver will now report all paramters as IN paramters but permit callers to call registerOutParameter() on them without throwing an exception. (Bug #28689)

DatabaseMetaData.getColumns() doesn't contain SCOPE_* or IS_AUTOINCREMENT columns. (Bug #27915)

Schema objects with identifiers other than the connection character aren't retrieved correctly in ResultSetMetadata. (Bug #27867)

Connection.getServerCharacterEncoding() doesn't work for servers with version >= 4.1. (Bug #27182)

The automated SVN revisions in DBMD.getDriverVersion(). The SVN revision of the directory is now inserted into the version information during the build. (Bug #21116)

Specifying a "validation query" in your connection pool that starts with "/* ping */" _exactly_ will cause the driver to instead send a ping to the server and return a fake result set (much lighter weight), and when using a ReplicationConnection or a LoadBalancedConnection, will send the ping across all active connections.

Setting the configuration property rewriteBatchedStatements to true will now cause the driver to rewrite batched prepared statements with more than 3 parameter sets in a batch into multi-statements (separated by ";") if they are not plain (that is, without SELECT or ON DUPLICATE KEY UPDATE clauses) INSERT or REPLACE statements.

Incompatible Change: Pulled vendor-extension methods of Connection implementation out into an interface to support java.sql.Wrapper functionality from ConnectionPoolDataSource. The vendor extensions are javadoc'd in the com.mysql.jdbc.Connection interface.

For those looking further into the driver implementation, it is not an API that is used for plugability of implementations inside our driver (which is why there are still references to ConnectionImpl throughout the code).

We've also added server and client prepareStatement() methods that cover all of the variants in the JDBC API.

Connection.serverPrepare(String) has been re-named to Connection.serverPrepareStatement() for consistency with Connection.clientPrepareStatement().

Row navigation now causes any streams/readers open on the result set to be closed, as in some cases we're reading directly from a shared network packet and it will be overwritten by the "next" row.

Made it possible to retrieve prepared statement parameter bindings (to be used in StatementInterceptors, primarily).

Externalized the descriptions of connection properties.

The data (and how it is stored) for ResultSet rows are now behind an interface which enables us (in some cases) to allocate less memory per row, in that for "streaming" result sets, we re-use the packet used to read rows, since only one row at a time is ever active.

Similar to Connection, we pulled out vendor extensions to Statement into an interface named com.mysql.Statement, and moved the Statement class into com.mysql.StatementImpl. The two methods (javadoc'd in com.mysql.Statement are enableStreamingResults(), which already existed, and disableStreamingResults() which sets the statement instance back to the fetch size and result set type it had before enableStreamingResults() was called.

Driver now picks appropriate internal row representation (whole row in one buffer, or individual byte[]s for each column value) depending on heuristics, including whether or not the row has BLOB or TEXT types and the overall row-size. The threshold for row size that will cause the driver to use a buffer rather than individual byte[]s is configured by the configuration property largeRowSizeThreshold, which has a default value of 2KB.

Added experimental support for statement "interceptors" through the com.mysql.jdbc.StatementInterceptor interface, examples are in com/mysql/jdbc/interceptors.

Implement this interface to be placed "in between" query execution, so that you can influence it. (currently experimental).

StatementInterceptors are "chainable" when configured by the user, the results returned by the "current" interceptor will be passed on to the next on in the chain, from left-to-right order, as specified by the user in the JDBC configuration property statementInterceptors.

See the sources (fully javadoc'd) for com.mysql.jdbc.StatementInterceptor for more details until we iron out the API and get it documented in the manual.

Setting rewriteBatchedStatements to true now causes CallableStatements with batched arguments to be re-written in the form CALL (...); CALL (...); ... to send the batch in as few client/server round trips as possible.

Refactored CommunicationsException into a JDBC-3.0 version, and a JDBC-4.0 version (which extends SQLRecoverableException, now that it exists).

Added support for JDBC-4.0 categorized SQLExceptions.

Added support for JDBC-4.0's NCLOB, and NCHAR/NVARCHAR types.

com.mysql.jdbc.java6.javac: Full path to your Java-6 javac executable

Added support for JDBC-4.0's SQLXML interfaces.

Re-worked Ant buildfile to build JDBC-4.0 classes separately, as well as support building under Eclipse (since Eclipse can't mix/match JDKs).

To build, you must set JAVA_HOME to J2SDK-1.4.2 or Java-5, and set the following properties on your Ant command line:

New feature—driver will automatically adjust session variable net_write_timeout when it determines it has been asked for a "streaming" result, and resets it to the previous value when the result set has been consumed. (configuration property is named netTimeoutForStreamingResults value and has a unit of seconds, the value 0 means the driver will not try and adjust this value).

Added support for JDBC-4.0's client information. The backend storage of information provided using Connection.setClientInfo() and retrieved by Connection.getClientInfo() is pluggable by any class that implements the com.mysql.jdbc.JDBC4ClientInfoProvider interface and has a no-args constructor.

The implementation used by the driver is configured using the clientInfoProvider configuration property (with a default of value of com.mysql.jdbc.JDBC4CommentClientInfoProvider, an implementation which lists the client information as a comment prepended to every query sent to the server).

This functionality is only available when using Java-6 or newer.

com.mysql.jdbc.java6.rtjar: Full path to your Java-6 rt.jar file

Added support for JDBC-4.0's Wrapper interface.

blobsAreStrings: Should the driver always treat BLOBs as Strings. Added specifically to work around dubious metadata returned by the server for GROUP BY clauses. Defaults to false.

Added two configuration parameters:

functionsNeverReturnBlobs: Should the driver always treat data from functions returning BLOBs as Strings. Added specifically to work around dubious metadata returned by the server for GROUP BY clauses. Defaults to false.

XAConnections now start in auto-commit mode (as per JDBC-4.0 specification clarification).

Driver will now fall back to sane defaults for max_allowed_packet and net_buffer_length if the server reports them incorrectly (and will log this situation at WARN level, since it is actually an error condition).

Connections established using URLs of the form jdbc:mysql:loadbalance:// weren't doing failover if they tried to connect to a MySQL server that was down. The driver now attempts connections to the next "best" (depending on the load balance strategy in use) server, and continues to attempt connecting to the next "best" server every 250 milliseconds until one is found that is up and running or 5 minutes has passed.

If the driver gives up, it will throw the last-received SQLException. (Bug #31053)

setObject(int, Object, int, int) delegate in PreparedStatementWrapper delegates to wrong method. (Bug #30892)

NPE with null column values when padCharsWithSpace is set to true. (Bug #30851)

Collation on VARBINARY column types would be misidentified. A fix has been added, but this fix only works for MySQL server versions 5.0.25 and newer, since earlier versions didn't consistently return correct metadata for functions, and thus results from subqueries and functions were indistinguishable from each other, leading to type-related bugs. (Bug #30664)

An ArithmeticException or NullPointerException would be raised when the batch had zero members and rewriteBatchedStatements=true when addBatch() was never called, or executeBatch() was called immediately after clearBatch(). (Bug #30550)

Closing a load-balanced connection would cause a ClassCastException. (Bug #29852)

Connection checker for JBoss didn't use same method parameters using reflection, causing connections to always seem "bad". (Bug #29106)

DatabaseMetaData.getTypeInfo() for the types DECIMAL and NUMERIC will return a precision of 254 for server versions older than 5.0.3, 64 for versions 5.0.3 to 5.0.5 and 65 for versions newer than 5.0.5. (Bug #28972)

CallableStatement.executeBatch() doesn't work when connection property noAccessToProcedureBodies has been set to true.

The fix involves changing the behavior of noAccessToProcedureBodies,in that the driver will now report all paramters as IN paramters but permit callers to call registerOutParameter() on them without throwing an exception. (Bug #28689)

When a connection is in read-only mode, queries that are wrapped in parentheses were incorrectly identified DML statements. (Bug #28256)

UNSIGNED types not reported using DBMD.getTypeInfo(), and capitalization of type names is not consistent between DBMD.getColumns(), RSMD.getColumnTypeName() and DBMD.getTypeInfo().

This fix also ensures that the precision of UNSIGNED MEDIUMINT and UNSIGNED BIGINT is reported correctly using DBMD.getColumns(). (Bug #27916)

DatabaseMetaData.getColumns() doesn't contain SCOPE_* or IS_AUTOINCREMENT columns. (Bug #27915)

Schema objects with identifiers other than the connection character aren't retrieved correctly in ResultSetMetadata. (Bug #27867)

Cached metadata with PreparedStatement.execute() throws NullPointerException. (Bug #27412)

Connection.getServerCharacterEncoding() doesn't work for servers with version >= 4.1. (Bug #27182)

The automated SVN revisions in DBMD.getDriverVersion(). The SVN revision of the directory is now inserted into the version information during the build. (Bug #21116)

Specifying a "validation query" in your connection pool that starts with "/* ping */" _exactly_ will cause the driver to instead send a ping to the server and return a fake result set (much lighter weight), and when using a ReplicationConnection or a LoadBalancedConnection, will send the ping across all active connections.

The driver will now automatically set useServerPrepStmts to true when useCursorFetch has been set to true, since the feature requires server-side prepared statements to function.

tcpKeepAlive - Should the driver set SO_KEEPALIVE (default true)?

Give more information in EOFExceptions thrown out of MysqlIO (how many bytes the driver expected to read, how many it actually read, say that communications with the server were unexpectedly lost).

Driver detects when it is running in a ColdFusion MX server (tested with version 7), and uses the configuration bundle coldFusion, which sets useDynamicCharsetInfo to false (see previous entry), and sets useLocalSessionState and autoReconnect to true.

tcpNoDelay - Should the driver set SO_TCP_NODELAY (disabling the Nagle Algorithm, default true)?

Added configuration property slowQueryThresholdNanos - if useNanosForElapsedTime is set to true, and this property is set to a nonzero value the driver will use this threshold (in nanosecond units) to determine if a query was slow, instead of using millisecond units.

tcpRcvBuf - Should the driver set SO_RCV_BUF to the given value? The default value of '0', means use the platform default value for this property.

Setting useDynamicCharsetInfo to false now causes driver to use static lookups for collations as well (makes ResultSetMetadata.isCaseSensitive() much more efficient, which leads to performance increase for ColdFusion, which calls this method for every column on every table it sees, it appears).

Added configuration properties to enable tuning of TCP/IP socket parameters:

Setting the configuration parameter useCursorFetch to true for MySQL-5.0+ enables the use of cursors that enable Connector/J to save memory by fetching result set rows in chunks (where the chunk size is set by calling setFetchSize() on a Statement or ResultSet) by using fully-materialized cursors on the server.

tcpSndBuf - Should the driver set SO_SND_BUF to the given value? The default value of '0', means use the platform default value for this property.

tcpTrafficClass - Should the driver set traffic class or type-of-service fields? See the documentation for java.net.Socket.setTrafficClass() for more information.

Added new debugging functionality - Setting configuration property includeInnodbStatusInDeadlockExceptions to true will cause the driver to append the output of SHOW ENGINE INNODB STATUS to deadlock-related exceptions, which will enumerate the current locks held inside InnoDB.

Added configuration property useNanosForElapsedTime - for profiling/debugging functionality that measures elapsed time, should the driver try to use nanoseconds resolution if available (requires JDK >= 1.5)?

Don't send any file data in response to LOAD DATA LOCAL INFILE if the feature is disabled at the client side. This is to prevent a malicious server or man-in-the-middle from asking the client for data that the client is not expecting. Thanks to Jan Kneschke for discovering the exploit and Andrey "Poohie" Hristov, Konstantin Osipov and Sergei Golubchik for discussions about implications and possible fixes. (Bug #29605)

Parser in client-side prepared statements runs to end of statement, rather than end-of-line for '#' comments. Also added support for '--' single-line comments. (Bug #28956)

Parser in client-side prepared statements eats character following '/' if it is not a multi-line comment. (Bug #28851)

PreparedStatement.getMetaData() for statements containing leading one-line comments is not returned correctly.

As part of this fix, we also overhauled detection of DML for executeQuery() and SELECTs for executeUpdate() in plain and prepared statements to be aware of the same types of comments. (Bug #28469)

Added an experimental load-balanced connection designed for use with SQL nodes in a MySQL Cluster/NDB environment (This is not for master-slave replication. For that, we suggest you look at ReplicationConnection or lbpool).

If the JDBC URL starts with jdbc:mysql:loadbalance://host-1,host-2,...host-n, the driver will create an implementation of java.sql.Connection that load balances requests across a series of MySQL JDBC connections to the given hosts, where the balancing takes place after transaction commit.

Therefore, for this to work (at all), you must use transactions, even if only reading data.

Physical connections to the given hosts will not be created until needed.

The driver will invalidate connections that it detects have had communication errors when processing a request. A new connection to the problematic host will be attempted the next time it is selected by the load balancing algorithm.

There are two choices for load balancing algorithms, which may be specified by the loadBalanceStrategy JDBC URL configuration property:

bestResponseTime: The driver will route the request to the host that had the best response time for the previous transaction.

Added configuration property padCharsWithSpace (defaults to false). If set to true, and a result set column has the CHAR type and the value does not fill the amount of characters specified in the DDL for the column, the driver will pad the remaining characters with space (for ANSI compliance).

When useLocalSessionState is set to true and connected to a MySQL-5.0 or later server, the JDBC driver will now determine whether an actual commit or rollback statement needs to be sent to the database when Connection.commit() or Connection.rollback() is called.

This is especially helpful for high-load situations with connection pools that always call Connection.rollback() on connection check-in/check-out because it avoids a round-trip to the server.

Added configuration property useDynamicCharsetInfo. If set to false (the default), the driver will use a per-connection cache of character set information queried from the server when necessary, or when set to true, use a built-in static mapping that is more efficient, but isn't aware of custom character sets or character sets implemented after the release of the JDBC driver.

New configuration property, enableQueryTimeouts (default true).

When enabled, query timeouts set with Statement.setQueryTimeout() use a shared java.util.Timer instance for scheduling. Even if the timeout doesn't expire before the query is processed, there will be memory used by the TimerTask for the given timeout which won't be reclaimed until the time the timeout would have expired if it hadn't been cancelled by the driver. High-load environments might want to consider disabling this functionality. (this configuration property is part of the maxPerformance configuration bundle).

Give better error message when "streaming" result sets, and the connection gets clobbered because of exceeding net_write_timeout on the server.

random: The driver will pick a random host for each request. This tends to work better than round-robin, as the randomness will somewhat account for spreading loads where requests vary in response time, while round-robin can sometimes lead to overloaded nodes if there are variations in response times across the workload.

com.mysql.jdbc.[NonRegistering]Driver now understands URLs of the format jdbc:mysql:replication:// and jdbc:mysql:loadbalance:// which will create a ReplicationConnection (exactly like when using [NonRegistering]ReplicationDriver) and an experimental load-balanced connection designed for use with SQL nodes in a MySQL Cluster/NDB environment, respectively.

In an effort to simplify things, we're working on deprecating multiple drivers, and instead specifying different core behavior based upon JDBC URL prefixes, so watch for [NonRegistering]ReplicationDriver to eventually disappear, to be replaced with com.mysql.jdbc[NonRegistering]Driver with the new URL prefix.

Fixed issue where a failed-over connection would let an application call setReadOnly(false), when that call should be ignored until the connection is reconnected to a writable master unless failoverReadOnly had been set to false.

Driver will now use INSERT INTO ... VALUES (DEFAULT)form of statement for updatable result sets for ResultSet.insertRow(), rather than pre-populating the insert row with values from DatabaseMetaData.getColumns()(which results in a SHOW FULL COLUMNS on the server for every result set). If an application requires access to the default values before insertRow() has been called, the JDBC URL should be configured with populateInsertRowWithDefaultValues set to true.

This fix specifically targets performance issues with ColdFusion and the fact that it seems to ask for updatable result sets no matter what the application does with them.

More intelligent initial packet sizes for the "shared" packets are used (512 bytes, rather than 16K), and initial packets used during handshake are now sized appropriately as to not require reallocation.

More useful error messages are generated when the driver thinks a result set is not updatable. (Thanks to Ashley Martens for the patch). (Bug #28085)

Connection.getTransactionIsolation() uses "SHOW VARIABLES LIKE" which is very inefficient on MySQL-5.0+ servers. (Bug #27655)

Fixed issue where calling getGeneratedKeys() on a prepared statement after calling execute() didn't always return the generated keys (executeUpdate() worked fine however). (Bug #27655)

CALL /* ... */ some_proc() doesn't work. As a side effect of this fix, you can now use /* */ and # comments when preparing statements using client-side prepared statement emulation.

If the comments happen to contain parameter markers (?), they will be treated as belonging to the comment (that is, not recognized) rather than being a parameter of the statement.

(Bug #27400)

ResultSet.get*() with a column index < 1 returns misleading error message. (Bug #27317)

Using ResultSet.get*() with a column index less than 1 returns a misleading error message. (Bug #27317)

Comments in DDL of stored procedures/functions confuse procedure parser, and thus metadata about them can not be created, leading to inability to retrieve said metadata, or execute procedures that have certain comments in them. (Bug #26959)

Fast date/time parsing doesn't take into account 00:00:00 as a legal value. (Bug #26789)

PreparedStatement is not closed in BlobFromLocator.getBytes(). (Bug #26592)

When the configuration property useCursorFetch was set to true, sometimes server would return new, more exact metadata during the execution of the server-side prepared statement that enables this functionality, which the driver ignored (using the original metadata returned during prepare()), causing corrupt reading of data due to type mismatch when the actual rows were returned. (Bug #26173)

CallableStatements with OUT/INOUT parameters that are "binary" (BLOB, BIT, (VAR)BINARY, JAVA_OBJECT) have extra 7 bytes. (Bug #25715)

Whitespace surrounding storage/size specifiers in stored procedure parameters declaration causes NumberFormatException to be thrown when calling stored procedure on JDK-1.5 or newer, as the Number classes in JDK-1.5+ are whitespace intolerant. (Bug #25624)

Client options not sent correctly when using SSL, leading to stored procedures not being able to return results. Thanks to Don Cohen for the bug report, testcase and patch. (Bug #25545)

Statement.setMaxRows() is not effective on result sets materialized from cursors. (Bug #25517)

BIT(> 1) is returned as java.lang.String from ResultSet.getObject() rather than byte[]. (Bug #25328)

Usage Advisor will now issue warnings for result sets with large numbers of rows. You can configure the trigger value by using the resultSetSizeThreshold parameter, which has a default value of 100.

The rewriteBatchedStatements feature can now be used with server-side prepared statements.

Important change: Due to a number of issues with the use of server-side prepared statements, Connector/J 5.0.5 has disabled their use by default. The disabling of server-side prepared statements does not affect the operation of the connector in any way.

To enable server-side prepared statements you must add the following configuration property to your connector string:

useServerPrepStmts=true

The default value of this property is false (that is, Connector/J does not use server-side prepared statements).

Improved speed of datetime parsing for ResultSets that come from plain or nonserver-side prepared statements. You can enable old implementation with useFastDateParsing=false as a configuration parameter.

Usage Advisor now detects empty results sets and does not report on columns not referenced in those empty sets.

Fixed logging of XA commands sent to server, it is now configurable using logXaCommands property (defaults to false).

Added configuration property localSocketAddress, which is the host name or IP address given to explicitly configure the interface that the driver will bind the client side of the TCP/IP connection to when connecting.

We've added a new configuration option treatUtilDateAsTimestamp, which is false by default, as (1) We already had specific behavior to treat java.util.Date as a java.sql.Timestamp because it is useful to many folks, and (2) that behavior will very likely be required for drivers JDBC-post-4.0.

Connection property socketFactory wasn't exposed using correctly named mutator/accessor, causing data source implementations that use JavaBean naming conventions to set properties to fail to set the property (and in the case of SJAS, fail silently when trying to set this parameter). (Bug #26326)

A query execution which timed out did not always throw a MySQLTimeoutException. (Bug #25836)

Storing a java.util.Date object in a BLOB column would not be serialized correctly during setObject. (Bug #25787)

Timer instance used for Statement.setQueryTimeout() created per-connection, rather than per-VM, causing memory leak. (Bug #25514)

EscapeProcessor gets confused by multiple backslashes. We now push the responsibility of syntax errors back on to the server for most escape sequences. (Bug #25399)

INOUT parameters in CallableStatements get doubly-escaped. (Bug #25379)

When using the rewriteBatchedStatements connection option with PreparedState.executeBatch() an internal memory leak would occur. (Bug #25073)

Fixed issue where field-level for metadata from DatabaseMetaData when using INFORMATION_SCHEMA didn't have references to current connections, sometimes leading to Null Pointer Exceptions (NPEs) when introspecting them using ResultSetMetaData. (Bug #25073)

StringUtils.indexOfIgnoreCaseRespectQuotes() isn't case-insensitive on the first character of the target. This bug also affected rewriteBatchedStatements functionality when prepared statements did not use uppercase for the VALUES clause. (Bug #25047)

Client-side prepared statement parser gets confused by in-line comments /*...*/ and therefore cannot rewrite batch statements or reliably detect the type of statements when they are used. (Bug #25025)

Results sets from UPDATE statements that are part of multi-statement queries would cause an SQLException error, "Result is from UPDATE". (Bug #25009)

Specifying US-ASCII as the character set in a connection to a MySQL 4.1 or newer server does not map correctly. (Bug #24840)

Using DatabaseMetaData.getSQLKeywords() does not return a all of the of the reserved keywords for the current MySQL version. Current implementation returns the list of reserved words for MySQL 5.1, and does not distinguish between versions. (Bug #24794)

Calling Statement.cancel() could result in a Null Pointer Exception (NPE). (Bug #24721)

Using setFetchSize() breaks prepared SHOW and other commands. (Bug #24360)

Calendars and timezones are now lazily instantiated when required. (Bug #24351)

Using DATETIME columns would result in time shifts when useServerPrepStmts was true. This occurred due to different behavior when using client-side compared to server-side prepared statements and the useJDBCCompliantTimezoneShift option. This is now fixed if moving from server-side prepared statements to client-side prepared statements by setting useSSPSCompatibleTimezoneShift to true, as the driver can't tell if this is a new deployment that never used server-side prepared statements, or if it is an existing deployment that is switching to client-side prepared statements from server-side prepared statements. (Bug #24344)

Connector/J now returns a better error message when server doesn't return enough information to determine stored procedure/function parameter types. (Bug #24065)

A connection error would occur when connecting to a MySQL server with certain character sets. Some collations/character sets reported as "unknown" (specifically cias variants of existing character sets), and inability to override the detected server character set. (Bug #23645)

Inconsistency between getSchemas and INFORMATION_SCHEMA. (Bug #23304)

DatabaseMetaData.getSchemas() doesn't return a TABLE_CATALOG column. (Bug #23303)

When using a JDBC connection URL that is malformed, the NonRegisteringDriver.getPropertyInfo method will throw a Null Pointer Exception (NPE). (Bug #22628)

Some exceptions thrown out of StandardSocketFactory were needlessly wrapped, obscuring their true cause, especially when using socket timeouts. (Bug #21480)

When using a server-side prepared statement the driver would send timestamps to the server using nanoseconds instead of milliseconds. (Bug #21438)

When using server-side prepared statements and timestamp columns, value would be incorrectly populated (with nanoseconds, not microseconds). (Bug #21438)

ParameterMetaData throws NullPointerException when prepared SQL has a syntax error. Added generateSimpleParameterMetadata configuration property, which when set to true will generate metadata reflecting VARCHAR for every parameter (the default is false, which will cause an exception to be thrown if no parameter metadata for the statement is actually available). (Bug #21267)

Fixed an issue where XADataSources couldn't be bound into JNDI, as the DataSourceFactory didn't know how to create instances of them.

Avoid static synchronized code in JVM class libraries for dealing with default timezones.

Performance enhancement of initial character set configuration, driver will only send commands required to configure connection character set session variables if the current values on the server do not match what is required.

Re-worked stored procedure parameter parser to be more robust. Driver no longer requires BEGIN in stored procedure definition, but does have requirement that if a stored function begins with a label directly after the "returns" clause, that the label is not a quoted identifier.

Throw exceptions encountered during timeout to thread calling Statement.execute*(), rather than RuntimeException.

Changed cached result set metadata (when using cacheResultSetMetadata=true) to be cached per-connection rather than per-statement as previously implemented.

Reverted back to internal character conversion routines for single-byte character sets, as the ones internal to the JVM are using much more CPU time than our internal implementation.

When extracting foreign key information from SHOW CREATE TABLE in DatabaseMetaData, ignore exceptions relating to tables being missing (which could happen for cross-reference or imported-key requests, as the list of tables is generated first, then iterated).

Fixed some Null Pointer Exceptions (NPEs) when cached metadata was used with UpdatableResultSets.

Take localSocketAddress property into account when creating instances of CommunicationsException when the underlying exception is a java.net.BindException, so that a friendlier error message is given with a little internal diagnostics.

Fixed cases where ServerPreparedStatements weren't using cached metadata when cacheResultSetMetadata=true was used.

Use a java.util.TreeMap to map column names to ordinal indexes for ResultSet.findColumn() instead of a HashMap. This enables us to have case-insensitive lookups (required by the JDBC specification) without resorting to the many transient object instances needed to support this requirement with a normal HashMap with either case-adjusted keys, or case-insensitive keys. (In the worst case scenario for lookups of a 1000 column result set, TreeMaps are about half as fast wall-clock time as a HashMap, however in normal applications their use gives many orders of magnitude reduction in transient object instance creation which pays off later for CPU usage in garbage collection).

When using cached metadata, skip field-level metadata packets coming from the server, rather than reading them and discarding them without creating com.mysql.jdbc.Field instances.

DBMD.getColumns() does not return expected COLUMN_SIZE for the SET type, now returns length of largest possible set disregarding whitespace or the "," delimitters to be consistent with the ODBC driver. (Bug #22613)

Added new _ci collations to CharsetMapping - utf8_unicode_ci not working. (Bug #22456)

Driver was using milliseconds for Statement.setQueryTimeout() when specification says argument is to be in seconds. (Bug #22359)

Workaround for server crash when calling stored procedures using a server-side prepared statement (driver now detects prepare(stored procedure) and substitutes client-side prepared statement). (Bug #22297)

Driver issues truncation on write exception when it shouldn't (due to sending big decimal incorrectly to server with server-side prepared statement). (Bug #22290)

Newlines causing whitespace to span confuse procedure parser when getting parameter metadata for stored procedures. (Bug #22024)

When using information_schema for metadata, COLUMN_SIZE for getColumns() is not clamped to range of java.lang.Integer as is the case when not using information_schema, thus leading to a truncation exception that isn't present when not using information_schema. (Bug #21544)

Column names don't match metadata in cases where server doesn't return original column names (column functions) thus breaking compatibility with applications that expect 1-to-1 mappings between findColumn() and rsmd.getColumnName(), usually manifests itself as "Can't find column ('')" exceptions. (Bug #21379)

Driver now sends numeric 1 or 0 for client-prepared statement setBoolean() calls instead of '1' or '0'.

Fixed configuration property jdbcCompliantTruncation was not being used for reads of result set values.

DatabaseMetaData correctly reports true for supportsCatalog*() methods.

Driver now supports {call sp} (without "()" if procedure has no arguments).

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 using SHOW CREATE PROCEDURE or selecting from mysql.proc instead of throwing an exception. The default value for this option is false

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

If the connection to the server has been closed due to a server failure, then the cleanup process will call Statement.cancel(), triggering a NullPointerException, even though there is no active connection. (Bug #20650)

MysqlXaConnection.recover(int flags) now permits 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. (Bug #20242)

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

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 enables 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). (Bug #20242)

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

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

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 system variable to the character set that is used for error messages. (Bug #18086)

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

Added support for Connector/MXJ integration using url subprotocol jdbc:mysql:mxj://.... (Bug #14729)

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

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

Added service-provider entry to META-INF/services/java.sql.Driver for JDBC-4.0 support. (Bug #14729)

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

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

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

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. (Bug #14729)

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

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

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

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

Do not permit .setAutoCommit(true), or .commit() or .rollback() on an XA-managed connection as per the JDBC specification.

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.

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

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 is 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.

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.

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).

Specifying US-ASCII as the character set in a connection to a MySQL 4.1 or newer server does not map correctly. (Bug #24840)

Check and store value for continueBatchOnError property in constructor of Statements, rather than when executing batches, so that Connections closed out from underneath statements don't cause NullPointerExceptions when it is required to check this property. (Bug #22290)

Fixed BUG#18258 - DatabaseMetaData.getTables(), columns() with bad catalog parameter threw exception rather than return empty result set (as required by spec). (Bug #22290)

Driver now sends numeric 1 or 0 for client-prepared statement setBoolean() calls instead of '1' or '0'. (Bug #22290)

Fixed bug where driver would not advance to next host if roundRobinLoadBalance=true and the last host in the list is down. (Bug #22290)

Driver issues truncation on write exception when it shouldn't (due to sending big decimal incorrectly to server with server-side prepared statement). (Bug #22290)

Fixed bug when calling stored functions, where parameters weren't numbered correctly (first parameter is now the return value, subsequent parameters if specified start at index "2"). (Bug #22290)

Removed logger autodetection altogether, must now specify logger explicitly if you want to use a logger other than one that logs to STDERR. (Bug #21207)

DDriver throws NPE when tracing prepared statements that have been closed (in asSQL()). (Bug #21207)

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

Escape of quotation marks 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 (that is, '' or ""). (Bug #20888)

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

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

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

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

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

Fixed calling toString() on ResultSetMetaData for driver-generated (that is, from DatabaseMetaData method calls, or from getGeneratedKeys()) result sets would raise a NullPointerException. (Bug #19993)

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

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

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

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

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)

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. (Bug #19282)

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

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

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. (Bug #18496)

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. (Bug #18041)

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

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. (Bug #17587)

Added additional accessor and mutator methods on ConnectionProperties so that DataSource users can use same naming as regular URL properties. (Bug #17587)

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

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

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)

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

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

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

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

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

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)

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)

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

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

Added support for Apache Commons logging, use "com.mysql.jdbc.log.CommonsLogger" as the value for the "logger" configuration property. (Bug #13469)

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 presence of log4j, too many different incompatible versions out there in the wild to do this reliably.

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. (Bug #13469)

LogFactory now prepends com.mysql.jdbc.log to the log class name if it cannot be found as specified. This enables you to use “short names” for the built-in log factories, for example, logger=CommonsLogger instead of logger=com.mysql.jdbc.log.CommonsLogger. (Bug #13469)

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

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

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

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)

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

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

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

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

storesMixedCaseIdentifiers() returns false (Bug #14562)

storesLowerCaseIdentifiers() returns true (Bug #14562)

storesMixedCaseQuotedIdentifiers() returns false (Bug #14562)

storesMixedCaseQuotedIdentifiers() returns true (Bug #14562)

If lower_case_table_names=0 (on server):

(Bug #14562)

storesUpperCaseIdentifiers() returns false (Bug #14562)

storesUpperCaseQuotedIdentifiers() returns true (Bug #14562)

If lower_case_table_names=1 (on server):

(Bug #14562)

storesLowerCaseQuotedIdentifiers() returns true (Bug #14562)

Fixed DatabaseMetaData.stores*Identifiers():