Connector/J 8.0.11, the Face for Your Brand New Document-oriented Database

This is exciting news: MySQL 8.0 is officially GA!

This time around we do not only offer you a new MySQL Server full of exciting new features, but also a brand new toolset that let you make the most out of MySQL, including the now GA Java database driver, MySQL Connector/J 8.0.11!

This story is about Connector/J but before even I get started I must say a few words about the new features that conducted the development of this new driver. If you prefer, you can jump directly to the Connector/J 8.0 topic below.

What’s new in MySQL Server 8.0?

There’s a new Client/Server communication protocol in MySQL: the X Protocol

The X Protocol introduced in MySQL 8.0 series is the backbone for the document-oriented paradigm in the MySQL ecosystem. The new X Protocol and the old MySQL Client/Server Protocol are both available in this new MySQL Server. It is up to the clients to choose which one to implement for connecting to MySQL servers, either through pure protocol implementations or via a MySQL C API library, for example. Clearly the easiest option is to use one of the MySQL connectors that already implement either one or both of the protocols that we offer for the programming language of your choice.

The X Protocol is implemented as a plugin for the MySQL Server—the X Plugin. By default the X Plugin is listening on TCP port 33060.

Among the main features in the X Protocol you’ll find data serialization via Protocol Buffers, Vectored I/O, Pipelining, SASL authentication, extensible messages via protobuf, and so on. We are also working on other interesting features so stay tuned. I invite you to go to the X Protocol documentation to learn all about it.

So, there’s also the new X Plugin

As mentioned before, the X Plugin implements the X Protocol on the MySQL Server side.

Besides implementing the X Protocol, the X Plugin is responsible for defining the message structure that provides the base for the X DevAPI – the API that exposes a MySQL server as a document-oriented database. It is also responsible for communicating with the internal components of the server: the storage engines, the query parser, the query optimizer, query executors, and so on. In the other end, it also manages all active X DevAPI sessions and handles clients’ requests.

As of MySQL 8.0 GA the X Plugin is loaded by default. Chances are that it is already available for you in your new server installation.

Knowledge of the X Plugin will provide you insights into the features of the X DevAPI as well as how MySQL handles those features. The X Plugin documentation is, again, your best companion for learning about the plugin.

MySQL as a document-oriented database: the X DevAPI

It is through the new X DevAPI that the document-oriented database features in MySQL are exposed. This is how you use MySQL as a document store, a schema-less, and therefore schema-flexible storage system for documents. When using MySQL as a document store you do not need to know and define all possible attributes of your data before storing and operating with it. This differs from working with a relational database and storing data in a table, where all columns of the table must be known and defined before adding data to the database.

Long ago MySQL added support for JSON data along with a large variety of functions and operations that allow creating, manipulating, and handling JSON structures and values. This new data type combined with the old and reliable InnoDB based tables, with the ability to create dynamically generated columns and indexes over them, constituted the right environment for spawning MySQL’s interpretation of our document store.

The X DevAPI provides you with a unifying API for creating and handling documents in JSON format in MySQL, which you can use to develop applications. It offers a modern programming interface with a simple yet powerful design that provides support for established industry-standard concepts. One of the major keynotes in the X DevAPI is harmony you get when working with different MySQL Connectors that implement it. It becomes so easy for a developer to switch between different programming languages and still get the same “look & feel” from different Connectors.

Although MySQL Connectors are the typical entry point for using the X DevAPI, you can actually start using it even without jumping into a programming language; just try it in the new command-line client: MySQL Shell.

MySQL Reference Manual contains an overview of MySQL as a Document Store which I recommend reading. The X DevAPI User Guide is the central source of information for all common aspects of this new and exiting API.

And here’s the new MySQL command-line client: MySQL Shell

MySQL Shell is an advanced command-line client and code editor for MySQL server. In addition to the usual SQL functionality provided by the mysql client, MySQL Shell provides scripting capabilities for JavaScript and Python and includes APIs for working with MySQL. When MySQL Shell is connected to the MySQL server through the X Protocol, the X DevAPI can be used to work with both relational tables and document data.

This is the perfect companion tool for your development work with any of the new Connectors supporting X DevAPI, as it allows viewing and manipulating documents and collections easily, so that you can prototype X DevAPI calls, expressions syntax, and a lot more before starting coding them into your projects.

As of MySQL Server 8.0.11, MySQL Shell is not included in the server’s default toolset, so you will have to install it separately. Get started with MySQL Shell by downloading it from MySQL Downloads and get more info from its User Guide.

TL;DR: After all, this post is about Connector/J!

Connector/J 8.0, the new GA JDBC/X DevAPI driver for MySQL databases

I am particularly proud to announce that Connector/J 8.0 is now GA. This is the officially recommended version to use in your projects from now on. And it doesn’t matter what server version you are using.

Note that Connector/J became GA with version 8.0.11, skipping version 8.0.10, which was expected to appear after the last Release Candidate. If you haven’t heard about it, just know that several MySQL products, including Connector/J, will be version aligned with MySQL Server releases from now on. This means that you can expect new releases of Connector/J every time there is a MySQL Server 8.0 release. This doesn’t mean, however, that you must also align the Connector/J library in your projects with the server version you are connecting to. As always, our recommendation is to use the latest Connector/J library, no matter what server version you use.

Connector/J 8.0 is the rightful successor of the widely used Connector/J 5.1. Now compiled in Java 8 only, it comes with huge refactoring. Connector/J 8.0 is better organized and follows better and more up-to-date coding practices, as well as many of the exciting features of Java 8. This is also the driver to use with the new X DevAPI in the Java ecosystem.

We know that, despite our best efforts, no code is ever perfect. This is why we are continuously working on it and we really appreciate your comments and suggestions for improving this product. Therefore, please continue to use the resources we provide to get in touch with us, including the MySQL bug system, the Connector/J forum, the GitHub repository or MySQL Community Slack, with which you can talk to us directly.

Connector/J 8.0 does not only implement the JDBC 4.2 API, but also the X DevAPI for new document store features, so you can use them interchangeably. As matter of fact, the two API implementations share a lot of core base code. This is so to offer you a better user experience and versatility in your projects.

The new X DevAPI implementation provides an up to date and more user-friendly programming method with its Fluent Interface API. It all starts with obtaining a Session object, which is similar to getting a JDBC Connection, and, from then on, you have a tool to work with with Schemas, Collections and even old-style Tables. Always remember to keep Connector/J Developer Guide and the Connector/J X DevAPI Reference handy for quick reference.

Getting started with Connector/J 8.0 and X DevAPI

Initial setup & getting Connector/J binaries

Your first step should be setting up a new Java project using whatever method you prefer, immediately followed by attaching the Connector/J library. You can do it either by setting up a Maven dependency in your pom.xml or by downloading the Connector/J bundle from the official MySQL Downloads page.

In order to setup a Maven dependency just add the following in the <dependencies> section of your project’s pom.xml file, then proceed with the usual Maven commands to build and run your project:

If you choose to download the Connector/J bundle from the MySQL repositories, you must extract its contents to some temporary place and copy the following files to your project’s libraries directory:

  • mysql-connector-java-8.0.11.jar
  • lib/protobuf-java-2.6.0.jar

Instead of using the provided Protocol Buffers Java API library, you could also get protobuf-java-2.6.0.jar from its official repositories. Note that there are a few other Java libraries in the libs directory and you are not required to add them to your project if you don’t use any of the features that need them.

If you are bold enough, you can even grab the Connector/J source code and compile it yourself. This is not a task for a Java novice but you will find some help in Connector/J Developer Guide – Installing from source.

I will not go into more details but you must make sure the classpath settings include the two libraries in all further Java commands or project configurations in your IDE.

Needless to say that you will also need a MySQL Server 8.0.11 (at least) in order to proceed. If you don’t have one, you can install it in few easy steps; just choose the right package for you and follow the instructions in the Reference Manual.

Hello World, using JSON documents and X DevAPI

It is time to create the a simple demo Java class. Lets call it

You should implement proper exception handling in your application. For the sake of this demo I’ll just throw Exception  in the method main .

First thing to do is to establish a connection to the MySQL server, that is, obtaining a Session in X DevAPI terminology. Lets assume the X Plugin is listening on the default port 33060. To do this in Connector/J you first need to instantiate a SessionFactory  and then use it to create the Session  object for you:

Replace the user and password according to your database setup. The same goes for the host and port parts.

Note that jonhdoe is just a standard MySQL user. Since this user will be used to create objects in the database, please make sure that it has the required permissions to do so.

The connection string in this sample is pretty straightforward. It identifies the protocol to use (mysqlx), the user, password, hostname and port. Except for the part johndoe:password@ this is quite similar to the old JDBC connection strings. In fact, Connector/J 8.0 lets you use this same syntax for JDBC connections too.

The previous code returns a Session  object you can to use manage schemas. A Schema is essentially a MySQL database. Lets create one for this demo:

By now there should be a new database named demo in your MySQL server instance.

The Schema object you have got lets you manage collections and tables in the database. Just keep in mind that collections are just tables with a specific column structure, which you shouldn’t modify in any way other than through a X DevAPI interface.

Let’s now create a collection and add a few documents to it:

So, this creates a table named greetings in the demo database. This table has two columns: doc and _id:

The X DevAPI, through the X Plugin, manages this 1:1 mapping between the collection greetings and the table with the same name. Following X DevAPI code related to this collection operates over this relational table using a panoply of JSON functions available in MySQL server, however, all this happens internally in the server and it is transparent to clients.

Lets wrap this demo up with a couple of data retrieving operations:

This time we work with the Collection instance in order to fetch its data using two simple filters, exactly as what you would do using standard SQL tables.

The returned object DocResult  can then be used to get the list of the documents filtered from the collection. Each document is exposed as a DbDoc  instance. DbDoc  is particularly important in Connector/J X DevAPI implementation, because it represents a JSON object, something that Java doesn’t support natively.

This should be the end result of this simple demo:

With exception of the _id values, which are generated each time you add a document to a collection, you should get the same results as me, if you try out the demo.

What else?

This little demo was about a few basic CRUD operations on Collections, but there’s a lot more in the X DevAPI:

  • CRUD operations on Collections and Tables;
  • Parameter binding;
  • Document patching;
  • Various types of results and metadata;
  • Raw (SQL) statements execution;
  • Transaction save-points;
  • Row locking mechanisms;
  • Simplified expression syntax, etc.

Closing comments

MySQL Connector/J 8.0.11 is the new GA version of Connector/J for MySQL databases. It implements the X DevAPI, an exciting new feature that enables the use of MySQL Server 8.0 as a document-oriented database.

The 8.0 series of the Connector/J driver, fully re-factored from the previous GA version 5.1, requires Java 8 or above to work with. If that is a limitation for you, you can still use the Connector/J 5.1 series that supports Java 5 up to Java 8. We’ll keep maintaining the 5.1 series for the time being, but be mindful that you will only be able to use JDBC with it.

Although a feature preview version of the X DevAPI is also available in the MySQL Server 5.7 series, which you could use with Connector/J 8.0.11 and later, I recommend that you use the X DevAPI with MySQL 8.0. The X Plugin implementation in the  5.7 series has some known limitations and, most likely, no new features will be back ported to MySQL 5.7.

Exiting times are coming for all of us. Enjoy the new features we offer you and let us know what you think about them.

On behalf of the MySQL Connector/J development team, I wish you a pleasant programming experience with Connector/J 8.0.

MySQL Connector/J 8.0.11 GA has been released

Dear MySQL users,

MySQL Connector/J Version 8.0.11 is the first General Availability
release of the 8.0 series of MySQL Connector/J. It is suitable for use
with MySQL Server versions 8.0, 5.7, 5.6, and 5.5. It supports the
Java Database Connectivity (JDBC) 4.2 API, and implements the X DevAPI.

This release includes the following new features and changes, also
described in more detail on

As always, we recommend that you check the “CHANGES” file in the download
archive to be aware of changes in behavior that might affect your application.

To download MySQL Connector/J 8.0.11 GA, see the “Generally Available (GA)
Releases” tab at


Changes in MySQL Connector/J 8.0.11   (2018-04-19)

Functionality Added or Changed

* X DevAPI: The locking options lockShared() and
lockExclusive(), available when retrieving data from
collection.find() and, now also accept an
optional locking contention value, which is exposed
though the enumeration Statement.LockContention. The
combinations of lockShared([lockCont]) or
lockExclusive([lockCont]) with
Statement.LockContention.NOWAIT or
Statement.LockContention.SKIP_LOCKED map directly to the
UPDATE with the SQL option NOWAIT or SKIP LOCKED, for the
different InnoDB locking read modes.

* X DevAPI: Connector/J now supports the new server-side
document ID generation feature. Client-side document ID
generation is no longer supported. As a result, the
methods getDocumentId() and getDocumentIds() have been
removed and the method getGeneratedIds() has been added
to the AddResult and AddResultImpl classes.

* X DevAPI: The SHA256_MEMORY authentication mechanism is
now supported by Connector/J for connections using the X
Protocol. See the entry for the connection property
xdevapi.auth in Configuration Properties
-reference-configuration-properties.html) for details.

* Connector/J now recognizes the data type GEOMCOLLECTION,
which has been introduced in MySQL 8.0.11 as an alias and
preferred name to the previously known GEOMETRYCOLLECTION
data type. (Bug #27678308)

* Connector/J now supports the use of a custom
SSLSocketFactory for returning a custom-constructed SSL
socket at the time of connection establishment. (Bug
#26092824, Bug #86278)

* The source directory and Java package layouts of
Connector/J have been revised to make it easier to use
custom protocols, APIs, value decoders, and value
factories with Connector/J. See the Connector/J source
code and the MySQL Connector/J X DevAPI Reference
( for more

Bugs Fixed

* When an integer value in a JSON document is modified, it
becomes a a DOUBLE value to the MySQL server, which is
returned with a decimal when fetched from the JSON
document. Therefore, calling getInteger() upon the
changed value with Connector/J resulted in an
NumberFormatException. With this fix, getInteger() parses
such a value correctly and returns an integer. (Bug

On Behalf of Oracle/MySQL Release Engineering Team

MySQL Connector/Java 5.1.46 GA has been released

Dear MySQL Users,

MySQL Connector/J 5.1.46, a maintenance release of the production 5.1
branch has been released. Connector/J is the Type-IV pure-Java JDBC
driver for MySQL.

MySQL Connector Java is available in source and binary form from the
Connector/J download pages at
and mirror sites as well as Maven-2 repositories.

MySQL Connector Java (Commercial) is already available for download on the
My Oracle Support (MOS) website. This release will shortly be available on
eDelivery (OSDC).

As always, we recommend that you check the “CHANGES” file in the
download archive to be aware of changes in behavior that might affect
your application.

MySQL Connector/J 5.1.46 includes the following general bug fixes and
improvements, also available in more detail on

Changes in MySQL Connector/J 5.1.46 (2018-03-12)

Version 5.1.46 is a maintenance release of the production 5.1
branch. It is suitable for use with MySQL Server versions
5.5, 5.6, 5.7, and 8.0. It supports the Java Database
Connectivity (JDBC) 4.2 API.

Functionality Added or Changed

* Because Connector/J restricted TLS versions to v1.1 and
below by default when connecting to MySQL Community
Server 8.0 (which used to be compiled with yaSSL by
default and thus supporting only TLS v1.1 and below), it
failed to connect to to a MySQL 8.0.4 Community Server
(which has been compiled with OpenSSL by default and thus
supports TLS v1.2) that was configured to only allow TLS
v1.2 connections. TLS v1.2 is now enabled for connections
with MySQL Community Server 8.0.4 and later. (Bug

* The bundle for Connector/J 5.1 delivered by Oracle now
contains an additional jar package with the name
(mysql-connector-java-commercial-5.1.ver.jar for
commercial bundles). It is identical with the other jar
package with the original package named
(mysql-connector-java-commercial-5.1.ver-bin.jar for
commercial bundles), except for its more Maven-friendly
file name. (Bug #27231383)

* The lower bound for the connection property
packetDebugBufferSize has been changed to 1, to avoid the
connection errors that occur when the value is set to 0.
(Bug #26819691)

* For multi-host connections, when a MySQL Server was
configured with autocommit=0, Connection.getAutoCommit()
did not return the correct value. This was because
useLocalSessionState=true was assumed for multi-host
connections, which might not be the case, resulting thus
in inconsistent session states.
With this fix, by default, Connector/J executes some
extra queries in the connection synchronization process
to guarantee consistent session states between the client
and the server at any connection switch. This would mean,
however, that when none of the hosts are available during
an attempted server switch, an exception for closed
connection will be thrown immediately while, in earlier
Connector/J versions, there would be a connection error
thrown first before a closed connection error. Error
handling in some applications might need to be adjusted
Applications can skip the new session state
synchronization mechanism by having
useLocalSessionState=true. (Bug #26314325, Bug #86741)

* Connector/J now supports the new caching_sha2_password
authentication plugin for MySQL 8.0, which is the default
authentication plugin for MySQL 8.0.4 and later (see
Caching SHA-2 Pluggable Authentication
gable-authentication.html) for details).
To authenticate accounts with the caching_sha2_password
plugin, either a secure connection to the server using
reference-using-ssl.html) or an unencrypted connection
that supports password exchange using an RSA key pair
(enabled by setting one or both of the connecting
properties allowPublicKeyRetrieval and
serverRSAPublicKeyFile) must be used.
Because earlier versions of Connector/J 5.1 do not
support the caching_sha2_password authentication plugin
and therefore will not be able to connect to accounts
that authenticate with the new plugin (which might
include the root account created by default during a new
installation of a MySQL 8.0 Server), it is highly
recommended that you upgrade now to Connector/J 5.1.46,
to help ensure that your applications continue to work
smoothly with the latest MySQL 8.0 Server.

Bugs Fixed

* When Connector/J 5.1.44 or earlier connected to MySQL
5.7.20 or later, warnings are issued because Connector/J
used the deprecated system variables tx_isolation and
tx_read_only. These SQL-level warnings, returned from a
SHOW WARNINGS statement, might cause some applications to
throw errors and stop working. With this fix, the
deprecated variables are no longer used for MySQL 5.7.20
and later; also, to avoid similar issues, a SHOW WARNINGS
statement is no longer issued for the use of deprecated
variables. (Bug #27029657, Bug #88227)

* When the default database was not specified for a
connection, the connection attributes did not get stored
in the session_connect_attrs table in the Performance
Schema of the MySQL Server. (Bug #22362474, Bug #79612)

On Behalf of Oracle/MySQL Release Engineering Team
Hery Ramilison

MySQL Connector/Java 8.0.8-dmr has been released

Dear MySQL users,

MySQL Connector/J 8.0.8 Development Release is a development milestone
release for the 8.0.x series.

This release includes the following new features and changes, also
described in more detail on

MySQL Connectors and other MySQL client tools and applications now
synchronize the first digit of their version number with the (highest)
MySQL server version they support.
This change makes it easy and intuitive to decide which client version
to use for which server version.

As always, we recommend that you check the “CHANGES” file in the download
archive to be aware of changes in behavior that might affect your application.

To download MySQL Connector/J 8.0.8 dmr, see the “Development
Releases” tab at


Changes in MySQL Connector/J 8.0.8 (2017-09-28, Development Milestone)

   Version 8.0.8 Development Milestone is the latest development
   release of the 8.0 branch of MySQL Connector/J, providing an
   insight into upcoming features. It is suitable for use with
   MySQL Server versions 5.5, 5.6, 5.7, and 8.0. It supports the
   Java Database Connectivity (JDBC) 4.2 API.

   Functionality Added or Changed

     * Packaging: RPM and Debian packages for installing
       Connector/J are now available from the Connector/J
       Download page

     * X DevAPI: Connector/J has implemented a new interface of
       the X Dev API that allows the retrieving, adding,
       removing, and updating of persistent session continuation
       data. The implementation includes the following:

          + A SessionConfig object that holds the information
            for a session configuration data set.

          + A PersistenceHandler interface that allows custom
            implementations of persistence handlers.

          + A PasswordHandler interface that allows custom
            implementations of password handling code.

          + A SessionConfigManager class for editing and
            fetching Sessionconfig objects, and defining
            instances of the PersistenceHandler and
       See MySQL Connector/J X DevAPI Reference
       ( for more

     * X DevAPI: A new connection property, xdevapi.auth, has
       been added for specifying the authentication mechanism
       for connections using the X Protocol. Allowed values are
       MYSQL41, PLAIN, and EXTERNAL. See the entry for the new
       property in Configuration Properties
       for details. 

     * X DevAPI: To support row locks
       for the find() method of the X DevAPI, the
       FindStatement and the SelecStatement interfaces have been
       extended with the following methods:

          + lockExclusive(), which works like SELECT ... FOR
            UPDATE for relational tables.

          + lockShared(), which works like the SELECT ... LOCK
            IN SHARED MODE (for MySQL 5.7) or SELECT ... FOR
            SHARE (for MySQL 8.0) for relational tables.
       See MySQL Connector/J X DevAPI Reference
       ( for more

     * X DevAPI: Connector/J now supports the expanded syntax
       for the IN and NOT IN operator, which can check if a
       sub-expression is contained inside another one; for
       // For documents
       coll.find("$.b IN [100,101,102]").execute();
       coll.find("'some text with 5432' in $.a").execute();
       coll.find("1 in [1, 2, 4]").execute();
       coll.find("{'a': 3} not in {'a': 1, 'b': 2}").execute();
       // For relational tables"3 not in [1, 2, 4]").execute();"'qqq' not in $.a").execute();"{'a': 1} in {'a': 1, 'b': 2}").execute();

     * X DevAPI: A number of changes have been implemented for
       the "drop" methods for the X DevAPI:

          + Removed dropCollection(schemaName, collectionName)
            and dropTable(schemaName, tableName) from Session.

          + Added dropCollection(collectionName) and
            dropTable(tableName) to Schema.

          + Schema.dropView() now executes immediately and
            returns void; also, the ViewDrop interface has been

          + Collection.dropIndex() now executes immediately and
            returns void; also the DropCollectionIndexStatement
            interface has been removed.

          + The "drop" methods now succeed even if the objects
            to be dropped do not exist.

     * Conversion from the MySQL TIME data to java.sql.Date is
       now supported. In the past, a getDate() retrieving data
       from a TIME column would throw an SQLException. Now, such
       a retrieval returns a java.sql.Date object containing the
       time value expressed in number of milliseconds from the
       Java epoch; also returned is the warning: "Date part does
       not exist in SQL TIME field, thus it is set to January 1,
       1970 GMT while converting to java.sql.Date." (Bug

     * A new connection property, enabledTLSProtocols, can now
       be used to override the default restrictions on the TLS
       versions to be used for connections, which are determined
       by the version of the MySQL Server that is being
       connected to. By providing a comma-separated list of
       values to this option (for example,
       "TLSv1,TLSv1.1,TLSv1.2") users can, for example, prevent
       connections from using older TLS version, or allow
       connections to use TLS versions only supported by a
       user-compiled MySQL Server. See the entry for the new
       property in Configuration Properties
       for details.
       Thanks to Todd Farmer for contributing the code. (Bug

     * Updated the timezone mappings using the latest IANA and
       CLDR time zone databases. (Bug #25946965)

     * A new option for the loadBalancingStrategy connection
       property called serverAffinity has been added. The
       servers listed in the new connection property
       serverAffinityOrder (which should be a subset of the
       servers in the host list of the connection URL) are
       contacted in the order they are listed until a server is
       available or until the list of servers is exhausted, at
       which point a random load-balancing strategy is used with
       the hosts not listed by serverAffinityOrder. See
       descriptions for loadBalancingStrategy and
       serverAffinityOrder in Configuration Properties
       for details. (Bug #20182108)

   Bugs Fixed

     * Important Change: Following the changes in MySQL Server
       8.0.3, the system variables tx_isolation and tx_read_only
       have been replaced with transaction_isolation and
       transaction_read_only in the code of Connector/J. Users
       should update Connector/J to this latest release in order
       to connect to MySQL 8.0.3. They should also make the same
       adjustments to their own applications if they use the old
       variables in their codes. (Bug #26440544)

     * X DevAPI: Calling schema.dropView() with a null argument
       resulted in a NullPointerException. (Bug #26750807)

     * X DevAPI: When dropCollection() was applied on a null
       collection, a NullPointerException occurred. (Bug

     * When using cached server-side prepared statements, a
       memory leak occurred as references to opened statements
       were being kept while the statements were being decached;
       it happened when either the close() method has been
       called twice on a statement, or when there were
       conflicting cache entries for a statement and the older
       entry had not been closed and removed from the opened
       statement list. This fix makes sure the statements are
       properly closed in both cases. Thanks to Eduard Gurskiy
       for contributing to the fix. (Bug #26633984, Bug #87429)

     * The regression test for Bug#63800 failed because the
       default value of the system variable
       explicit_defaults_for_timestamp of MySQL Server has been
       changed since release 8.0.2. The test has been adjusted
       to take the change into consideration. (Bug #26501245)

     * Running callable statements against MySQL Server 8.0
       resulted in the SQLException: ResultSet is from UPDATE.
       No Data. (Bug #26259384)

     * Secure JDBC connections did not fall back to the default
       truststore when a custom one was not provided. (Bug

     * In com/mysql/jdbc/, the
       arguments resultSetType and resultSetConcurrency for a
       call of Connection.preparedStatement() were swapped. (Bug
       #25874048, Bug #85885)

     * Some JDBC proxied objects were missing the proper
       handlings of the equals() methods, thus even comparison
       of one of these proxied objects to its own self with
       equals() yielded false. This patch introduces proper
       handlings for the equals() method in all the relevant
       proxies. (Bug #21931572, Bug #78313)

     * A server-side prepared statement was not closed when the
       same statement was being prepared again while the
       original statement was being cached. This was caused by
       the silent replacement of the cache entry of the old
       statement by the new. When this happened repeatedly, it
       caused eventually the complaint that
       max_prepared_stmt_count was exceeded. This fix makes sure
       that when a cache entry for a statement replaces an older
       one, the older statement is immediately closed. (Bug
       #20066806, Bug #74932)

On behalf of Oracle MySQL Release Team
Balasubramanian Kandasamy

MySQL Connector/J 5.1.40 has been released

I’m pleased to announce the newest MySQL Connector/J 5.1 Maintenance Release.

As usual, MySQL Connector/J 5.1 can be downloaded from the official distribution channels MySQL Downloads and The Central Repository. The commercially licensed version is available for download at My Oracle Support.

Please don’t forget to consult the CHANGES file in the download archive and/or the release notes page to know what is new and if there are any changes that might affect your applications.

MySQL Connector/J 5.1.40 is the official JDBC driver for MySQL databases and, as such, we are continuously working to make it better, more reliable and faster. This new version delivers several bug fixes and upgrades. This is the current recommend  version and you should upgrade to it as soon as possible.

I’d like to highlight the most relevant fixes and improvements in this release:

Recovered & new features

Previous versions used to silently disable local transaction states management (connection property useLocalTransactionState=true) when server side query cache was enable. This used to be workaround for a know server bug that it’s long time gone. The workaround in Connector/J side, though, survived till these days. I’m pretty sure that the effects will be almost unnoticed but certainly this helps empowering the developer and provides better control over the Connector.

The XA errors mapping in Connector/J was updated with the missing error codes that the server may throw back.

MySQL Fabric support issues

Connector/J 5.1 maintains support for MySQL Fabric, as such, this release comes with a couple fixes to it. Fabric connections are especially prone to problems as they rely on both a connection to a Fabric node and multiple connections to MySQL servers while having to be able to refresh themselves to topology changes, failures and such. A couple of issues caused by communication failures to the Fabric node are now fixed.

Continuous improvement of MySQL data types support

The JSON data type is relatively new in Connector/J. As such, every now and then there is something that needs to be fixed or adjusted. This time it was an encoding issue observed when the JSON strings contained non Latin characters. Additionally, the specific combination of updatable result sets with cursor based fetches was missing the support for the JSON type.

Getting data from BIT columns as numeric values was behaving inconsistently when binary values and ASCII values of numbers matched. As a result, instead of the expected value, it was occurring an extra conversion to String before the data was returned. Also fixed in this release.

Improved internals

Although we aim to, it’s almost impossible to guarantee that the code is free from memory leaks, deadlocks, NPEs and so on. A few of those where caused by some bugs that are now fixed.

Under certain situations the exception interceptor mechanism was being triggered twice. This, not only caused an unwanted additional  processing, but also was hiding the real cause that triggered the interceptor.

Client-side caching of prepared statements while using server-side prepared statements requires extra care because it can easily be a source of memory leaks, both on client and server sides. In this particular scenario, setting a statement as non-poolable was causing a never ending number of prepared statements on server and never deallocated. Per se, this wasn’t a problem for the driver because it is prepared to switch-over to client prepared statements as soon as it is unable to create more on the server, but it wasn’t the desired behavior for sure.

Transactions states managed locally got fixed for when there were exceptions while on the middle of one. Without the fix the rollback and commit wasn’t operating as expected.

The database connection URL syntax got support for several extensions over the year. With that also increased the corner cases that its parsers have to deal with. A couple of them were fixed in this release, specifically a NPE and an incompatibility with host names starting with the word “address”.


Enjoy this new Connector/J release. Get the most out of it by reading its official documentation or by getting the developer’s support directly from the forum channel.

Special thanks to Dong Song Ling and Ryosuke Yamazaki for their valuable contributions.

Thank you all for your support and feedback, and keep in touch!

On behalf of the MySQL Connector/J Team

MySQL Connector/J 6.0.4 has been released

We are pleased to announce the next development release of MySQL Connector/J 6.0 which supports both JDBC 4.2 API and the new X DevAPI.

MySQL Connector/J 6.0.4 can be downloaded from the official distribution channels MySQL Downloads (see the “Development Releases” tab) and The Central repository. MySQL Connector/J source is also available on GitHub.

As always, we recommend that you check the CHANGES file in the download archive and/or the release notes to be aware of changes in behavior that might affect your application.

For documentation please visit the MySQL Connector/J 6.0 Developer Guide.

Note that Connector/J 6.0.4 is a milestone release and not intended for production usage.

I’d like to highlight the most important changes in this release:

X DevAPI connection string

The prefix used in connection string for X DevAPI is now unified between MySQL connectors. The “mysql:x:” we used in previous Connector/J 6.0 releases doesn’t work anymore, please use the “mysqlx:” one to establish XSession:

X DevAPI support for views

The com.mysql.cj.api.x.Table interface now represents both database tables and views. Schema.getTables() returns a list of Table objects for each existing database Table and View. Schema.getTable(name) also returns a Table object if the object with a given name is a View.

A new Table interface method was added:

The com.mysql.cj.api.x.View interface existed in previous Connector/J 6.0 releases isn’t available in Connector/J 6.0.4.

MySQL server compliance

MySQL Connector/J 6.0.4 is suitable for use with MySQL server versions 5.5, 5.6, and 5.7 via Java Database Connectivity (JDBC) 4.2 API.

Due to changes in X Protocol implementation MySQL Connector/J 6.0.4 requires at least MySQL 5.7.14 server when working via X DevAPI.


Enjoy this new Connector/J and thank you all for your support!

On behalf of the MySQL Connector/J Team.

MySQL Connector/J 5.1.39 has been released

I’m pleased to announce that MySQL Connector/J 5.1.39 Maintenance Release is now generally available.

MySQL Connector/J can be downloaded from the official distribution channels MySQL Downloads and The Central Repository. The commercially licensed version is available for download at My Oracle Support.

As always, we recommend that you check the CHANGES file in the download archive and/or the release notes page to know what is new and if there are any changes that might affect your applications.

With MySQL Connector/J 5.1.39 you get the continuously improved JDBC driver for MySQL databases, now including several fixes and upgrades. Even if you didn’t face any of the fixed issues, we do recommend that you upgrade to the latest version.

I’d like to highlight the most relevant fixes and improvements in this release:

MySQL Fabric support related issues

As you well know by now, MySQL Fabric support in Connector/J is built on its generic multi-host connections feature, more specifically on replication connections. This feature, along with load-balanced connections support, have received several improvements all over the latest releases. This time, we fixed and tuned up a few incoherences that were spotted on a few corner cases, namely when, due to the Fabric management process, the list of known hosts in an active connection could actually become empty for a short period of time while performing the fail-over, and so causing a whole set of new problems. As a consequence of these developments, we introduced a new connection property:

loadBalanceHostRemovalGracePeriod. This property sets the time, in milliseconds, that the driver should wait for a load-balanced connection to be allowed to switch to a different host when the currently active one is being removed, either by an internal process such as in a Fabric or a replication connection, or by dynamic hosts management, through the JMX interfaces the driver provides. Default value is 15000 milliseconds.

Additional improvements and fixes

  • Unnecessary exception throwing and capturing when establishing connections.
  • Temporal data corruption in prepared statements under special circumstances.
  • Incorrect JDBC 4.2 Java 8 Time support when using cached prepared statements.
  • Application server using multiple class loaders could face a NullPointerException when setting up the driver’s time zone configurations.
  • Exception caused by missing metadata information in updatable result sets.
  • Concurrent modification issue on closing statements and connections concurrently from different threads.
  • Maintenance fixes in the test suite.
  • Source code formatting, Copyright notice fixes.
  • Build script adjustments, new code coverage reports, compiler warnings cleanup.
  • Manifest fixed to expose Fabric connections.
  • Support for latest changes in MySQL protocol, introduced in MySQL 5.7, namely the deprecation of EOF packets.


Enjoy this new release of Connector/J and stay tuned for the next releases as there is still much to deliver.

Get the most out of this Connector/J release by reading its official documentation or by getting the developer’s support directly from the forum channel.

Thank you all for your support and keep in touch!

On behalf of the MySQL Connector/J Team

MySQL Connector/J 5.1.38 has been released

I’m pleased to announce that MySQL Connector/J 5.1.38 Maintenance Release is now generally available.

MySQL Connector/J can be downloaded from the official distribution channels MySQL Downloads and The Central repository. The commercially licensed version is available for download at My Oracle Support.

As always, we recommend that you check the CHANGES file in the download archive and/or the release notes to be aware of changes in behavior that might affect your application.

MySQL Connector/J 5.1.38, although released shortly after its predecessor, includes several important fixes and improvements. Most of them related to MySQL Fabric, multi-host replication aware connections support and support for TLSv1.2 and new encryption defaults. Even if you don’t require such features, we do recommend the upgrade to the latest version.

I’d like to highlight some of the most relevant fixes and improvements in this release:

MySQL Fabric and Multi-Host Replication Connections Revision

MySQL Fabric support in Connector/J is based on multi-host replication aware connections and the ability to dynamically manage server groups. Most of the server groups management is done automatically and, possibly, concurrently. The combination of all these features was never thoroughly used and stressed as much as now and the consequence is that they were effectively in need of some improvements.

This release ships with a fully re-factored multi-host replication aware connections support, which now inherits from the same base architecture as the remaining multi-host connections alternatives, the fail-over connections and load-balanced connections. This architecture provides a layered connection support structure and an improved statement execution routing model that effectively determines the correct physical connection to use at execution time, also fixing, by this way, a couple of existing bugs. The synchronization model in the server groups management was revised as well in order to overcome a few known thread deadlock situations. As a direct result the fail-over in MySQL Fabric support is now way more robust.

In the process of the improvements made in multi-host replication aware connections, two new connection properties were added:

allowSlaveDownConnections. This property sets the behavior for establishing replication aware connections when no slave hosts available. While, previously, this would result in a failed connection attempt, now we can define the behavior we prefer. This property takes a boolean value:

readFromMasterWhenNoSlaves. This property sets the behavior for the situations where, at run-time, all slave hosts in a replication aware connection become unavailable. The alternatives “should it fail?”, the only possible outcome before introducing this property, or “should the master host(s) be used in their place?”, are now available to the developer. Mind that when you set the option to use the master host(s), they will be used in read-only state as if they were slave hosts. Also mind that setting this property to true might, transparently, incur in extra load to the master host(s). This property takes a boolean value:

Security Compliance and Improvements

In its way of complying with the up-to-date security regulations and requirements, MySQL server 5.7 is now shipped with SSL/TLS enabled by default and any clients connecting to it should make use of such data protection features by default as well. Following this path, Connector/J 5.1.38 prioritizes the usage of SSL/TLS when establishing connections to this server. The missing support for TLSv1.2 and TLSv1.1 was additionally included in this release.

Connector/J now attempts to use the highest security layer available at run-time, starting from TLSv1.2 and, at the end, providing the best encryption system possible for the moment. This obviously depends on the MySQL server version we are connecting to and on the JVM version in use. In some situations it may be somewhat complex to find a compatible set of cyphers that can be used in both ends and some tweaks or adjustments could be required. The connection property enabledSSLCipherSuites may be a good companion in such cases.

Additional Bug Fixes

This release also includes a few other minor bug fixes. Although not especially relevant, these fixes help improving the overall quality of this Connector/J release.


Thank you all for your support. Enjoy this new Connector/J and keep in touch!

On behalf of the MySQL Connector/J Team.

MySQL Connector/J 5.1.37 has been released

I’m pleased to announce: MySQL Connector/J 5.1.37 Maintenance Release is now available.

MySQL Connector/J can be downloaded from the official distribution channels MySQL Downloads and The Central repository. Commercial license version is available for download at My Oracle Support.

As always, we recommend that you check the “CHANGES” file in the
download archive and/or the release notes to be aware of changes in behavior that might affect your application.

MySQL Connector/J 5.1.37 includes several bug fixes and other improvements. I’d like to highlight just a few:

Support for JDBC 4.2

Connector/J now provides implementations for pretty much all new JDBC 4.2 methods, namely for large update counts and max rows support.

The other big change is the support for the new temporal classes from java.time package. LocalDate, LocalDateTime, LocalTime are fully supported and can now be used in the multiple versions of setObject(...) and getObject(...) methods. They deliver results very similar to their counterparts, Date, Time and Timestamp respectively. The types OffsetDateTime and OffsetTime are partially supported via conversion to *CHAR types as MySQL doesn’t provide support for temporal data containing time zone information and, thus, doesn’t support the new TIME_WITH_TIMEZONE and TIMESTAMP_WITH_TIMEZONE JDBC types as well.

As a consequence to this upgrade, Connector/J 5.1.37 and future versions require Java 8 for its building process. We maintained, however, full compatibility with the already supported Java versions – Java 5 and above, Thus, this is a seamless replacement for the previous drivers versions you may be using in your projects.

New Connection Properties

sendFractionalSeconds. This property controls whether fractional seconds in timestamps are to be truncated on the client side or to be sent to the server side where they may be subject to rounding. It takes a boolean value:

Rounding fractional seconds may lead to undesired situations, especially when this results in apparently “big” temporal leaps, such as advancing a timestamp value to the next minute, day or even year. Many times this is not the required behavior for applications and setting this property to false safely cancels it.

Mind that this option applies only to prepared statements, callable statements and updatable result sets.

enableEscapeProcessing. This property, introduced as part of the support for JDBC 4.2, sets the default escape processing behavior for Statement objects. It takes a boolean value:

The method Statement.setEscapeProcessing() allows to set the escape processing behavior for individual statements. This method’s documentation refers that the connection property escapeProcessing can be used to set the default behavior, however, in Connector/J, this property is actually named enableEscapeProcessing.

Note that the default escape processing behavior in prepared statements is set by the long time available property processEscapeCodesForPrepStmts.

Changes in the Building Process

With JDBC 4.2 support comes a dependency on the Java 8 compiler and with it some changes in the building from source procedure. The documentation contains all the details you need to know but, the fast shortcut is that the previous ant property com.mysql.jdbc.jdk6 was upgraded to com.mysql.jdbc.jdk8 and holds the obvious reference to the JDK 8 path.

The optional property com.mysql.jdbc.java6.rtjar was added as well and is used to obtain the most accurate byte codes for every single JDBC implementation contained in this driver. You are not required to use it unless you are building for production, in which case we recommend you to set it too.

Bug Fixes

Several bug fixes were introduced aiming to improve your Connector/J experience.

We were able to fix a few things in the meta data structures, a time zone related adjustment, a couple of null point exceptions and corrected the right type of exception, all observed in very specific situations. We improved the authentication procedure, making it more robust. And, finally, we tweaked the driver to be fully compliant with latest MySQL server releases.


This release contains some contributions from end users. Special thanks to Jie Han and KwonNam for their valuable contributions.

Thank you all for your support as well. Enjoy this new Connector/J and keep in touch!

On behalf of the MySQL Connector/J Team.

Connector/J moves to Git

I’m pleased to announce that Connector/J has a new home.

Just as several other MySQL products, Connector/J source code management moved to Git and, pretty much as expected, to GitHub. Our reasoning is nothing else than listening to our users demands and trying to follow best trends and practices. There was nothing significantly wrong with Bazaar and Launchpad, as they served us well for the last seven years. It was just time to move on.

Rest assured, all will work as before, no complications no hassles. Our public GitHub repository will expose Connector/J source code as it is in the latest generally available (GA) release, as it has been for the last years.

From now on you will find Connector/J source code in the well known Git repository hosting service, GitHub, at mysql-connector-j under the umbrella of MySQL organization. Other MySQL products will follow in time. This repository contains all history since Connector/J early days so nothing was lost. Those who are used to our old launchpad repository will only have to change tools.


GitHub allows you to explore source code, project history, get to know about contributions and a lot more. But you probably already know all of this anyway.

So, to get the Connector/J source code you can just execute the following command in your preferred shell or command prompt:

You can also fetch the code through SSH protocol, using Subversion or simply download it as a zip file. Obviously, in order for you to execute git commands, you’ll have to have it installed in your computer. Just follow the official getting started guide if you don’t have it yet.

Building MySQL Connector/J 5.1 from source

Some time ago I have blogged about building Connector/J from source code. Nothing changes in this post, except for the replacement of Bazaar and Launchpad by Git and GitHub respectively and the  bzr  command that is replaced by the  git  command mentioned above.

We love to hear from you

As always, don’t forget to use our official channels to report us your wishes, findings or just ask for help when you need it. We can be found at MySQL Bugs database or MySQL Connector/JDBC and Java forum. Thank you!

Welcome to Connector/J on Git!
Farewell Bazaar. Farewell Launchpad. Thank you for the 7 years of good services.