Understanding MySQL X (All Flavors)

what is MySQL X ProtocolSince 5.7.12 MySQL includes what is called the X plugin, but also it includes X protocol and X DevApi. But what is all this and how does it work? Let me share a personal short story on how I found myself investigating this feature. In a previous post I wrote about the MySQL Router tool, and our colleague Mr. Lefred pointed out that I was wrong about X protocol, because I mentioned it was created to be used with JSON docs. Given this input, I wanted to investigate in a little bit more depth about what all this “X” means and how it can be used in our day to day operations.

First problem I found is that the documentation is pretty extensive in the how’s but it was really hard to find the what’s. This is a bit strange, because for people trying to research about this new feature the documentation is not very helpful. In fact, I had to go to different websites to get a sense of what X means, how it works, and what it was created for.

Let’s start from the very beginning: what does the X stand for? Basically, it’s a way to name the crossover between relational and document models with extended capabilities, and the X is used for naming the three components we are describing: the plugin, the protocol and the DevApi.

X Plugin

This is the actual interface between MySQL server and the clients. By clients we can consider a variety of clients, not only the MySQL shell. It has to be installed in MySQL 5.7 versions via the INSTALL PLUGIN command but comes installed by default in MySQL 8. The plugin adds all the functionality, configuration variables, and status counters we need to use it.

It has the ability to work with both traditional SQL and Document objects, and also supports CRUD (Create, Read, Update, Delete) operations,  asynchronous query execution and so on – this provides a great capacity to extend the current way we work with MySQL.

X Protocol

This is a new client protocol created to ‘talk’ between the X Plugin and Clients.  I think it is fair to say this is an eXtended version of the MySQL protocol.
It was designed with the idea of having the capacity for asynchronous calls, meaning that you can send more than one query to server from same client without the need of waiting for first query to finish before sending the second and so. This improves the overall execution time by saving network round trips between clients and server.

Additionally, the protocol accepts CRUD operations and, of course, the handling of JSON documents and plain SQL. The protocol is fully implemented in MySQLShell and has several connectors for popular languages (Java and .Net for example)


The last piece of this package is the X DevAPI protocol. Probably the best documented of these pieces is the API implemented on the MySQL Shell and connectors that supports the X Protocol. This API is designed to easily write programs from a given client using some popular languages. For example, we can easily create/test a program from MySQL Shell using Python or JavaScript.

The API defines few interesting concepts to handle sessions. These sessions can handle several connections to a server so in a specific session we can encapsulate more than one MySQL connection. You can define a basic session connection as follows (in JavaScript) using the MySQL Shell:

So what’s new here? How does it help, and how I can make use of it? First let’s try to illustrate the architecture:


MySQL X the components

As you may notice, the X plugin adds a new interface that talks to X protocol, then this protocol is able to interact with connectors that supports the protocol (as mentioned above). The classic functionality is still present, so we just extended its functionality. The good part of this is that the protocol is capable of operating with both relational data and document store.

So now let’s check the funny part by putting all pieces together using a simple example using MySQL Shell:

Interesting right? Within the same shell, I’ve created session to run over X protocol, and handled both document and relational objects, all without quitting from shell.

Is this all? Of course not! We are just scratching the surface, we haven’t used asynchronous calls nor CRUD operations. In fact, these topics are enough for a blog post each. Hopefully, though, the What’s are answered for now – at least a little –and if that’s the case, I’ll be very happy!

Photo by Deva Darshan on Unsplash

Share this post

Comments (5)

  • Daniël van Eeden Reply

    So this is not related to “XXX: Return of Xander Cage”?

    January 7, 2019 at 2:57 pm
    • Francisco Bordenave Reply

      Daniël hopefully not, I don’t really like Vin Diesel X-D

      January 7, 2019 at 2:59 pm
  • Vlad Reply

    MySQL X will only take off when you introduce a MongoDB compatibility layer so people can immediately use it with their MongoDB-enabled projects.

    Until that happens, MySQL X will keep being perceived as just an interesting curiosity.

    Learn from what Amazon has done with DocumentDB.

    January 11, 2019 at 9:23 pm
  • Shivanand Reply

    Hi,is is possible to use connection pool with mysqlx(Xdev API), if yes can you give some ideas how to use that

    July 20, 2020 at 3:38 am
    • Francisco Bordenave Reply


      Connection pool is another layer not fully related to Protocol X, at server side you can use MySQL Enterprise connection pooling or you can use Percona Server connection pool, in both cases they replace one-thread-per-connection default and doesn’t require any special config as far as I recall.
      If you’re looking for Application side connection pooling (i.e. Java) you need to make sure they are compatible with Protocol X (basically talk same protocol language than MySQL)
      Hope this helps.

      July 20, 2020 at 9:13 am

Leave a Reply