MySQL Connector/C++ 8.0.13 has been released

Dear MySQL users,

MySQL Connector/C++ 8.0.13 is a new release version of the MySQL
Connector/C++ 8.0 series.

Connector/C++ 8.0 can be used to access MySQL implementing Document Store or in a traditional way, using SQL queries. It allows writing both C++ and plain C applications using X DevAPI and X DevAPI for C. It also supports the legacy API of Connector/C++ 1.1 based on JDBC4.

To learn more about how to write applications using X DevAPI, see “X DevAPI User Guide”

https://dev.mysql.com/doc/x-devapi-userguide/en/

See also “X DevAPI Reference” at

https://dev.mysql.com/doc/dev/connector-cpp/devapi_ref.html

and “X DevAPI for C Reference” at

https://dev.mysql.com/doc/dev/connector-cpp/xapi_ref.html

For generic information on using Connector/C++ 8.0, see

https://dev.mysql.com/doc/dev/connector-cpp/

For general documentation about how to get started using MySQL
as a document store, see

http://dev.mysql.com/doc/refman/8.0/en/document-store.html

To download MySQL Connector/C++ 8.0.13, see the “Generally Available (GA)
Releases” tab at

https://dev.mysql.com/downloads/connector/cpp/



Changes in MySQL Connector/C++ 8.0.13 (2018-10-22, General Availability)

* Character Set Support

* Packaging Notes

* X DevAPI Notes

* Functionality Added or Changed

* Bugs Fixed

Character Set Support


* For connections to the server made using the legacy JDBC
API (that is, not made using X DevAPI or X DevAPI for C),
the default connection character set is now utf8mb4
rather than utf8. Connections to the server made using X
DevAPI or X DevAPI for C continue to use the connection
character set determined by the server. (Bug #28204677)

Packaging Notes


* Connector/C++ 32-bit MSI packages are now available for
Windows. These 32-bit builds enable use of the legacy
JDBC connector.

* Connector/C++ compressed tar file packages are now
available for Solaris.
It is also possible to build Connector/C++ from source on
Solaris. For platform-specific build notes, see Building
Connector/C++ Applications: Platform-Specific Considerations
(http://dev.mysql.com/doc/connector-cpp/8.0/en/connector-cpp-apps-platform-considerations.html).


X DevAPI Notes


* Connector/C++ now provides connection pooling for
applications using X Protocol. This capability is based
on client objects, a new type of X DevAPI object. A
client can be used to create sessions, which take
connections from a pool managed by that client. For a
complete description, see Connecting to a Single MySQL
Server Using Connection Pooling
(http://dev.mysql.com/doc/x-devapi-userguide/en/connecting-connection-pool.html).
X DevAPI example:
using namespace mysqlx;

Client cli("user:password@host_name/db_name", ClientOption::POOL_MAX_SIZE, 7);
Session sess = cli.getSession();

// use sess as before

cli.close();  // close session sess

X DevAPI for C example:
char error_buf[255];
int  error_code;

mysqlx_client_t *cli
= mysqlx_get_client_from_url(
"user:password@host_name/db_name", "{ \"maxSize\": 7 }", error_buf, &error_code);
mysqlx_session_t *sess = mysqlx_get_session_from_client(cli);

// use sess as before

mysqlx_close_client(cli);  // close session sess


* For X DevAPI, a new connect-timeout option can be
specified in connection strings or URIs to indicate a
connection timeout in milliseconds. The
SessionSettings::Options object supports a new
CONNECT_TIMEOUT option.
For X DevAPI for C, the mysqlx_opt_type_t constant is
MYSQLX_OPT_CONNECT_TIMEOUT together with the
OPT_CONNECT_TIMEOUT() macro.
If no timeout option is specified, the default is 10000
(10 seconds). A value of 0 disables the timeout. The
following examples set the connection timeout to 10
milliseconds:
X DevAPI examples:
Session sess("user@host/db?connect-timoeut=10");

Session sess(..., SessionOption::CONNECT_TIMEOUT, 10, ...);

Session sess(
...,
SessionOption::CONNECT_TIMEOUT, std::chrono::milliseconds(10),
...
);

X DevAPI for C example:
mysqlx_session_options_t *opt = mysqlx_session_options_new();
mysqlx_session_option_set(opt, ..., OPT_CONNECT_TIMEOUT(10), ...);

Functionality Added or Changed


* JSON: Connector/C++ now uses RapidJSON for improved
performance of operations that involve parsing JSON
strings. There are no user-visible API changes for X
DevAPI or X DevAPI for C.

Bugs Fixed


* On SLES 15, Connector/C++ installation failed if
libmysqlcppcon7 was already installed. (Bug #28658120)

* Applications that were statically linked to the legacy
JDBC connector could encounter a read access violation at
exit time due to nondeterministic global destruction
order. (Bug #28525266, Bug #91820)

* Configuring with -DCMAKE_BUILD_TYPE=Release did not work
on Linux. (Bug #28045274)

* Field references in .having() expressions could be
interpreted incorrectly and produce errors.
(Bug #26310713)


Enjoy and thanks for the support!

On Behalf of Oracle/MySQL Release Engineering Team,
Balasubramanian Kandasamy

MySQL Connector/Node.js 8.0.13 has been released

Dear MySQL users,

MySQL Connector/Node.js is a new Node.js driver for use with the X
DevAPI. This release, v8.0.13, is a maintenance release of the
MySQL Connector/Node.js 8.0 series.

The X DevAPI enables application developers to write code that combines
the strengths of the relational and document models using a modern,
NoSQL-like syntax that does not assume previous experience writing
traditional SQL.

MySQL Connector/Node.js can be downloaded through npm (see
https://www.npmjs.com/package/@mysql/xdevapi for details) or from
https://dev.mysql.com/downloads/connector/nodejs/.

To learn more about how to write applications using the X DevAPI, see
http://dev.mysql.com/doc/x-devapi-userguide/en/. For more information
about how the X DevAPI is implemented in MySQL Connector/Node.js, and
its usage, see http://dev.mysql.com/doc/dev/connector-nodejs/.

Please note that the X DevAPI requires at least MySQL Server version
8.0 or higher with the X Plugin enabled. For general documentation
about how to get started using MySQL as a document store, see
http://dev.mysql.com/doc/refman/8.0/en/document-store.html.

Changes in MySQL Connector/Node.js 8.0.13 (2018-10-22, General availability)

Functionality Added or Changed

* To go with the existing asynchronous
mysqlx.getSession(conn_str) method, a new synchronous
mysqlx.getClient(conn_str, options) method was added that
creates a connection pool handler that provides an
asynchronous getSession() method to create and retrieve
connections from the pool. The collection pooling options
are:

+ enabled: enables or disables connection pooling;
boolean and defaults to true.

+ maxSize: maximum number of connections available in
the pool; positive integer and defaults to 25.

+ maxIdleTime: maximum number of milliseconds a
connection can be idle in the queue before being
closed; integer >= 0 and defaults to 0 (infinite).

+ queueTimeout: maximum number of milliseconds a
request will wait for a connection to become
available; integer >= 0 and defaults to 0
(infinite).
This is different than connectTimeout that’s used
for non-pooling. In a pooling scenario, there might
already be connections in the pool and queueTimeout
controls how long to wait for a connection in the
pool.
Example usage:
var mysqlx = require(‘@mysql/xdevapi’)
var client = mysqlx.getClient(
{ user: ‘root’, host: ‘localhost’, port: 33060 },
{ pooling: { enabled: true, maxIdleTime: 5000, maxSize: 25, queueTimeout: 20000 } }
);

client.getSession()
.then(session => {
console.log(session.inspect())
return session.close() // the connection becomes idle in the client pool
})
.then(() => {
return client.getSession()
})
.then(session => {
console.log(session.inspect())
return client.close() // closes all connections and destroys the pool
})

Closing a session attached to the pool makes the
connection available in the pool for subsequent
getSession() calls, while closing (destroying) the pool
effectively closes all server connections.

* Added a connection timeout query parameter. This defines
the length of time (milliseconds) the client waits for a
MySQL server to become available in the given network
addresses. It was added to both the mysqlx.getSession()
(non-pooling sessions) and mysqlx.getClient() (pooling
sessions) interfaces. This option defaults to 10000 (10
seconds). The value 0 disables the timeout so the client
will wait until the underlying socket (platform
dependent) times out.
Similar to other option formatting rules, this option
defined as connection-timeout (kebab-case) for URI
definitions and connectionTimeout (camelCase) for plain
JavaScript configuration objects.
Example usage:
const mysqlx = require(‘@mysql/xdevapi’);
var client = mysqlx.getClient(‘root@localhost?connect-timeout=5000’)
client.getSession()
.catch(err => {
console.log(err.message) // “Connection attempt to the server was aborted. Timeout of 5000 ms was exceeded.”
})

// Or

const mysqlx = require(‘@mysql/xdevapi’);
var client = mysqlx.getClient(‘mysqlx://root:passwd@[localhost:33060, 127.0.0.1:33060]?connect-timeout=5000’)
client.getSession()
.catch(err => {
// connection could not be established after 10 seconds (5 seconds for each server)
console.log(err.message); // All server connection attempts we re aborted. Timeout of 5000 ms was exceeded for each selected server.
});

In a multi-host scenario, the connect-timeout value
applies to each individual host.

Bugs Fixed

* Improved the handling of X Protocol global notices by
properly logging and then ignoring non-fatal errors, and
making the connection unusable for subsequent operations
in the case of a fatal error. (Bug #28653781)

* Calling getCollationName() on non-textual fields, such as
INT, threw the following error “TypeError: Cannot read
property ‘collation’ of undefined”. (Bug #28608923)

* The fields() method did not function with valid
expressions generated by the expr() method. (Bug
#28409639)

* The returned Session.inspect() object now includes the
‘user’ property in addition to the ‘dbUser’ property but
containing the same value. (Bug #28362115)

On Behalf of the MySQL/Oracle Release Engineering Team,
Hery Ramilison

MySQL Connector/ODBC 8.0.13 has been released

Dear MySQL users,

MySQL Connector/ODBC 8.0.13 is a new version in the MySQL Connector/ODBC 8.0 series, the ODBC driver for the MySQL Server.

The available downloads include both a Unicode driver and an ANSI driver based on the same modern codebase. Please select the driver type you need based on the type of your application – Unicode or ANSI. Server-side prepared statements are enabled by default. It is suitable for use with any MySQL server version from 5.5.

This release of the MySQL ODBC driver is conforming to the ODBC 3.8 specification. It contains implementations of key 3.8 features, including self-identification as a ODBC 3.8 driver, streaming of output parameters (supported for binary types only), and support of the SQL_ATTR_RESET_CONNECTION connection attribute (for the Unicode driver only).

The release is now available in source and binary form for a number of platforms from our download pages at

https://dev.mysql.com/downloads/connector/odbc/

For information on installing, please see the documentation at

https://dev.mysql.com/doc/connector-odbc/en/connector-odbc-installation.html

Changes in MySQL Connector/ODBC 8.0.13 (2018-10-22, General Availability)

Functionality Added or Changed

  • Added dynamic libmysql linking support via the -DMYSQLCLIENT_STATIC_LINKING:BOOL=TRUE|FALSE option; defaults to FALSE to enable dynamic linking.

Bugs Fixed

  • Fixed column metadata handling with Microsoft Access.
    (Bug #28670725, Bug #91856)
  • The following obsolete options were removed: NO_SCHEMA (use NO_CATALOG instead), DISABLE_SSL_DEFAULT (use SSLMODE instead), and SSL_ENFORCE (use SSLMODE instead). (Bug #28407520)
  • The ODBC Driver returned 0 for the SQL_MAX_SCHEMA_NAME_LEN attribute, and now returns 64 as the maximum length for a MySQL schema name.
    (Bug #28385722)
  • Because the MySQL ODBC driver ignored the SQL_RD_OFF value for the SQL_ATTR_RETRIEVE_DATA attribute, it incorrectly kept writing into the data buffers. This led to write access violation errors when data was written into the buffer when the user application explicitly requested not to write there.
    (Bug #28098219, Bug #91060)

On Behalf of Oracle/MySQL Release Engineering Team,
Kent Boortz

MySQL Connector/NET 6.10.8 has been released

Dear MySQL users,

MySQL Connector/NET 6.10.8 is the fifth GA release with .NET Core
now supporting various connection-string options and MySQL 8.0 server
features.

To download MySQL Connector/NET 6.10.8 GA, see the “Generally Available
(GA) Releases” tab at http://dev.mysql.com/downloads/connector/net/

Changes in Connector/NET 6.10.8 (2018-08-14, General Availability)

Functionality Added or Changed

* Optimistic locking for database-generated fields was
improved with the inclusion of the [ConcurrencyCheck,
DatabaseGenerated(DatabaseGeneratedOption.Computed)]
attribute. Thanks to Tony Ohagan for the patch. (Bug
#28095165, Bug #91064)

* All recent additions to .NET Core 2.0 now are compatible
with the Connector/NET 6.10 implementation.

* With the inclusion of the Functions.Like extended method,
scalar-function mapping, and table-splitting
capabilities, Entity Framework Core 2.0 is fully
supported.

Bugs Fixed

* EF Core: An invalid syntax error was generated when a new
property (defined as numeric, has a default value, and is
not a primary key) was added to an entity that already
contained a primary-key column with the AUTO_INCREMENT
attribute. This fix validates that the entity property
(column) is a primary key first before adding the
attribute. (Bug #28293927)

* EF Core: The implementation of some methods required to
scaffold an existing database were incomplete. (Bug
#27898343, Bug #90368)

* The Entity Framework Core implementation did not render
accented characters correctly on bases with different
UTF-8 encoding. Thanks to Kleber kleberksms for the
patch. (Bug #27818822, Bug #90316)

* The Microsoft.EntityFrameworkCore assembly (with EF Core
2.0) was not loaded and the absence generated an error
when the application project was built with any version
of .NET Framework. This fix ensures the following
support:

+ EF Core 1.1 with .NET Framework 4.5.2 only

+ EF Core 2.0 with .NET Framework 4.6.1 or later
(Bug #27815706, Bug #90306)

* Attempts to create a new foreign key from within an
application resulted in an exception when the key was
generated by a server in the MySQL 8.0 release series.
(Bug #27715069)

* A variable of type POINT when used properly within an
application targeting MySQL 8.0 generated an SQL syntax
error. (Bug #27715007)

* The case-sensitive lookup of field ordinals was
initialized using case-insensitive comparison logic. This
fix removes the original case-sensitive lookup. (Bug
#27285641, Bug #88950)

* The TreatTinyAsBoolean connection option was ignored when
the MySqlCommand.Prepare() method was called. (Bug
#27113566, Bug #88472)

* The MySql.Data.Types.MySqlGeometry constructor called
with an array of bytes representing an empty geometry
collection generated an ArgumentOutOfRangeException
exception, rather than creating the type as expected.
Thanks to Peet Whittaker for the patch. (Bug #26421346,
Bug #86974)

* Slow connections made to MySQL were improved by reducing
the frequency and scope of operating system details
required by the server to establish and maintain a
connection. (Bug #22580399, Bug #80030)

* All columns of type TINYINT(1) stopped returning the
expected Boolean value after the connector encountered a
NULL value in any column of this type. Thanks to David
Warner for the patch. (Bug #22101727, Bug #78917)

Nuget packages are available at:

https://www.nuget.org/packages/MySql.Data/6.10.8
https://www.nuget.org/packages/MySql.Web/6.10.8
https://www.nuget.org/packages/MySql.Data.Entity/6.10.8
https://www.nuget.org/packages/MySql.Data.EntityFrameworkCore/6.10.8
https://www.nuget.org/packages/MySql.Data.EntityFrameworkCore.Design/6.10.8

Enjoy and thanks for the support!

On Behalf of the MySQL/Oracle Release Engineering Team,
Hery Ramilison

MySQL Shell 8.0.12 for MySQL Server 8.0 and 5.7 has been released

Dear MySQL users,

MySQL Shell 8.0.12 is a maintenance release of MySQL Shell 8.0 Series
(a component of the MySQL Server). The MySQL Shell is provided under
Oracle’s dual-license.

MySQL Shell 8.0 is highly recommended for use with MySQL Server 8.0 and 5.7.
Please upgrade to MySQL Shell 8.0.12.

MySQL Shell is an interactive JavaScript, Python and SQL console
interface, supporting development and administration for the MySQL
Server. It provides APIs implemented in JavaScript and Python that
enable you to work with MySQL InnoDB cluster and use MySQL as a document
store.

The AdminAPI enables you to work with MySQL InnoDB cluster, providing
an integrated solution for high availability and scalability using
InnoDB based MySQL databases, without requiring advanced MySQL
expertise. For more information about how to configure and work with
MySQL InnoDB cluster see
https://dev.mysql.com/doc/refman/en/mysql-innodb-cluster-userguide.html.

The X DevAPI enables you to create “schema-less” JSON document
collections and perform Create, Update, Read, Delete (CRUD) operations
on those collections from your favorite scripting language.
For more information about how to use MySQL Shell and the MySQL Document
Store support see https://dev.mysql.com/doc/refman/en/document-store.html.
For more information about the X DevAPI see
https://dev.mysql.com/doc/x-devapi-userguide/en/.

If you want to write applications that use the the CRUD based X DevAPI
you can also use the latest MySQL Connectors for your language of
choice. For more information about Connectors see
https://dev.mysql.com/doc/index-connectors.html.

For more information on the APIs provided with MySQL Shell
see https://dev.mysql.com/doc/dev/mysqlsh-api-javascript/8.0/
and https://dev.mysql.com/doc/dev/mysqlsh-api-python/8.0/.

Using MySQL Shell’s SQL mode you can communicate with servers using the
legacy MySQL protocol. Additionally, MySQL Shell provides partial
compatibility with the mysql client by supporting many of the same
command line options.

For full documentation on MySQL Server, MySQL Shell and related topics,
see https://dev.mysql.com/doc/mysql-shell/8.0/en/

For more information about how to download MySQL Shell 8.0.12, see
the “Generally Available (GA) Releases” tab at http://dev.mysql.com/downloads/shell/

We welcome and appreciate your feedback and bug reports, see
http://bugs.mysql.com/

Enjoy!

Changes in MySQL Shell 8.0.12 (2018-07-27, General Availability)

Functionality Added or Changed

* Important Change: An RPM package for installing ARM
64-bit (aarch64) binaries of MySQL Shell on Oracle Linux
7 is now available in the MySQL Yum Repository and for
direct download.
Known Limitation for this ARM release: You must enable
the Oracle Linux 7 Software Collections Repository
(ol7_software_collections) to install this package, and
must also adjust the libstdc++7 path. See Yum’s Platform
Specific Notes
(http://dev.mysql.com/doc/refman/8.0/en/linux-installatio
n-yum-repo.html#yum-install-platform-specifics) for
additional details.

* MySQL Shell now enables you to store user credentials in
an operating system specific secret store. You can then
enter a MySQL user’s password during connection and store
it for future connections. Currently the following secret
stores are supported:

+ MySQL login-path

+ MacOS keychain

+ Windows API
(Bug #23304789, Bug #81484)

* The way you access the online Shell help has been
standardized. Use the \help pattern command to search the
help. The scope of the command has been increased to
support retrieving help for the following categories:

+ Class and function help for the Admin API, X DevAPI
and Shell API. Previously, to retrieve help for API
objects, you had to create an instance of the object
and use the object.help() method.

+ SQL syntax help, provided that a global session
object exists.
Wildcards can now be used to search for help. A number of
additional bugs relating to incomplete help information
have also been fixed. (Bug #23255291, Bug #81277, Bug
#24963435, Bug #25732663, Bug #85481, Bug #25739522, Bug
#85511, Bug #25739664, Bug #85514, Bug #26393155, Bug
#86950, Bug #24943074, Bug #26429399, Bug #87037, Bug
#27870491, Bug #90455, Bug #27870503, Bug #90456, Bug
#27875150, Bug #90474, Bug #24948933, Bug #83527)

* The util.checkForServerUpgrade() operation has an
additional outputFormat parameter that you can specify
when running the utility. The utility can now generate
output in two formats:

+ TEXT format, which is the default. This option
provides output suitable for humans, as previously
returned by the utility.

+ JSON format. This option provides output suitable
for machines, which can be parsed and processed for
various further use cases.

* The cluster.removeInstance() command has been improved,
with the following changes:

+ A new interactive option has been added to enable or
disable interactive mode for the command. The output
displayed in interactive mode has been improved,
displaying more useful information.In interactive
mode, you are prompted to continue with the removal
of the instance (or not) in case it is not
reachable.

+ The operation now ensures that the instance is
removed from the metadata of all the cluster members
and itself. This only applies to ONLINE members.

+ A new global option dba.gtidWaitTimeout is available
to define the timeout to wait for transactions
(GTIDs) to be applied when required by AdminAPI
commands. If the timeout value defined by
dba.gtidWaitTimeout is reached when waiting for the
cluster transactions to be applied for
cluster.removeInstance() and force: false (or not
defined) then an error is issued and the operation
aborted. When force: true then the operation
continues and does not generate an error.
References: See also: Bug #27817894.

* When using the ipWhitelist to define which servers could
access the cluster, the internal user accounts were not
matching the whitelist. Now AdminAPI applies the same
filtering logic from ipWhitelist for the internal
administrative accounts.
References: See also: Bug #26140094, Bug #28165891.

* In order to be compliant with the X DevAPI specification,
the following changes have been made:

+ Collection.modify(condition).arrayDelete() and
Collection.modify(condition).merge() have been
deprecated.

+ Collection.find().limit(x).skip(y) has been renamed
to Collection.find().limit(x).offset(y).

+ Collection.find().limit(x).skip(y) has been
deprecated.

+ Collection.find().limit(x).offset(y) has been
implemented.

+ BaseResult.getAffectedItemsCount() has been
implemented.

+ BaseResult.getWarningCount() has been deprecated.

+ BaseResult.getWarningsCount() has been implemented.

+ Result.getAffectedItemCount() has been deprecated.

+ SqlResult.getAffectedRowCount() has been deprecated.

+ SqlResult.nextDataSet() has been renamed to
SqlResult.nextResult().

+ SqlResult.nextDataSet() has been deprecated.

+ SqlResult.nextResult() has been implemented.

Bugs Fixed

* The sample prompt theme files for MySQL Shell were
deployed to an incorrect location on the Windows
platform, in the root install folder. The files are now
correctly deployed in the \share\mysqlsh\prompt
sub-folder. (Bug #28188761)

* The cluster.forceQuorumUsingPartitionOf() operation sets
the group_replication_force_members variable on the
target instance to force a new group membership and
restore the quorum, but it did not reset the value of the
variable at the end of the process. Consequently, if
Group Replication later needed to be restarted on the
target instance it failed because the
group_replication_force_members variable was still set.
Now, the group_replication_force_members variable is
reset to an empty string at the end of the
cluster.forceQuorumUsingPartitionOf() operation. (Bug
#28064621)

* When upgrading from version 1.0.11 to version 8.0.11 of
MySQL Shell on Linux, the upgrade failed if the original
package was the community edition and the new package was
the commercial edition, or vice versa. Upgrading from one
edition to the other edition is now enabled. (Bug
#28037407)

* The util.checkForServerUpgrade() operation can now use
either an X Protocol connection or a classic MySQL
protocol connection. (Bug #28027707)

* The checkForServerUpgrade() operation to verify upgrade
prerequisites included an unnecessary check relating to
ZEROFILL and display length attributes in columns. The
check has now been removed. (Bug #27927641, Bug #90634)

* Some messages displayed by MySQL Shell were showing a
MySQL server version that does not exist. (Bug #27924694)

* For sessions using the classic MySQL protocol, if the
session_track_gtids system variable is set on the server
to capture and return GTIDs to the client, MySQL Shell
now displays the GTIDs for successfully committed
transactions. The returned GTID values are also now
recorded in tracing information. (Bug #27871148)

* When the defaultMode MySQL Shell configuration option had
been set with the –persist option, batch code execution
from a file was always attempted using the specified
default language, even if the file extension indicated a
different supported language. Now when a file is loaded
for batch processing using the –file or -f option, files
with the extensions .js, .py, and .sql are processed in
the appropriate language mode, regardless of the set
default language. (Bug #27861407)

* The methods provided in the shell.options configuration
interface to set and save persistent option values used
underscores in JavaScript as well as in Python mode. The
methods have now been changed to
shell.options.setPersist() and
shell.options.unsetPersist() in JavaScript to follow the
appropriate naming convention. (Bug #27861141)

* When executing a SQL script using MySQL Shell, delimiters
( such as the default semi-colon character) present in
multi-line comments caused execution to fail. Delimiters
are now ignored inside multi-line comments. (Bug
#27841719)

* MySQL Shell returned an error when querying timestamp
values that were zero, because a zero value for the month
or day in a date was not accepted. Zero timestamp values
can now be used without producing an error. (Bug
#27833822, Bug #90355)

* The shell.getSession() function returns a reference to
the session global object representing the already
established connection between MySQL Shell and a MySQL
server, known as a global session. MySQL Shell now
gracefully handles the situation where the function is
called when no global session has yet been established.
(Bug #27809310)

* It was possible to use AdminAPI operations on server
instances running an incompatible version of MySQL. (Bug
#27765769)

* The setting of the bind_address variable is no longer a
requirement. (Bug #27765484)

* When creating a cluster or adding an instance, if the
localAddress option is not specified, the port used for
group_replication_local_address is automatically assigned
with the value: port * 10 + 1. However, if the resulting
port determined by the previous rule was already in use
then a random port was generated and used. Now MySQL
Shell checks that the group_replication_local_address
port is available, and fails if it is not. (Bug
#27758041)

* The MySQL Shell application icon on Microsoft Windows was
not being displayed for the MySQL Shell 8.0 GA release,
due to an incorrect association introduced for the icon
during code refactoring. The icon is now displayed
correctly. (Bug #27746532)

* The dbPassword option is no longer valid in the options
dictionary of all AdminAPI commands. (Bug #27745106)

* The \status (\s) command in MySQL Shell now displays full
information about the version and build of the connected
MySQL server. (Bug #27740420)

* The check for reserved keywords carried out by the
util.checkForServerUpgrade() operation was updated to
match the list of reserved keywords for the MySQL 8.0 GA
release. (Bug #27724201)

* When handling escape sequences, MySQL Shell now
identifies and skips over SQL comments and string
literals within quotation marks. (Bug #27665229)

* Python’s mapping type has been added to MySQL Shell, so
that dictionary syntax can be used to interact with data
in Python mode. (Bug #27614110)

* When a file was redirected to standard input for
execution in MySQL Shell, on Unix, the first part of the
file was taken as being the password. The password prompt
now looks for user input first before resorting to
standard input. (Bug #27572380)

* It was possible to use the
dba.forceQuorumUsingPartition() operation on a cluster
which had not lost quorum. (Bug #27508698)

* The help message for
dba.rebootClusterFromCompleteOutage() operation was
incorrectly suggesting to use
dba.forceQuorumUsingPartition(). (Bug #27508627)

* If Ctrl + C was entered or an unexpected error occurred
at a password prompt in MySQL Shell, the terminal state
was not restored correctly afterwards. (Bug #27379834)

* The dba.rebootClusterFromCompleteOutage() operation was
creating a new user on the target instances, which could
lead to the existence of an increasing number of users.
The fix ensures that these users are not created by the
dba.rebootClusterFromCompleteOutage() operation. (Bug
#27344040)

* Now when you issue dba.getCluster() and retrieve a
cluster without quorum a warning is issued in addition to
the log message. (Bug #27148943)

* The memberSslMode option could be used with
cluster.addInstance() and cluster.rejoinInstance()
operations but if you specified a different value than
the one used at cluster creation an error was thrown. Now
set the SSL mode at the cluster level only, in other
words when issuing dba.createCluster(). The memberSslMode
option has been removed from cluster.addInstance() and
cluster.rejoinInstance(). (Bug #27062122)

* When you issued dba.configureLocalInsance() on an
instance, it configured the disabled_storage_engines
variable with the MyISAM, BLACKHOLE, FEDERATED, CSV, and
ARCHIVE storage engines to ensure that the storage engine
was set to InnoDB, as required by Group Replication. The
change to this option was not being reported correctly by
AdminAPI, and hence the required restart after changing
the disabled_storage_engines variable was not clear. This
change was deemed a recommendation, rather than a
requirement, hence dba.configureLocalInsance() no longer
configures disabled_storage_engines. (Bug #26754410)

* Creating a cluster using an account which was missing the
global grant option failed with an ambiguous error
message, even though dba.checkInstanceConfiguration() did
not return any errors. Now when you create a cluster, the
account being used to administer the cluster is checked
to ensure that it has the global grant option. (Bug
#25966235)

* MySQL Shell is able to automatically reconnect global
session when running in the interactive mode, but
AdminAPI methods lacked this feature. This resulted in
you having to reconnect manually. Now, the AdminAPI
methods which utilize the global session object have been
improved in order to detect an interrupted session and
trigger the reconnection mechanism. The Cluster object
uses its own internal session instance, which does not
support automatic reconnection. If connection to the
cluster is lost, you need to manually recreate the
Cluster object. (Bug #24702489)

* In the event of a whole cluster stopping unexpectedly,
upon reboot the memberSslMode was not preserved. In a
cluster where SSL had been disabled, upon issuing
dba.rebootClusterFromCompleteOutage() this could prevent
instances from rejoining the cluster. (Bug #90793, Bug
#27986413)

On Behalf of the MySQL/Oracle Release Engineering Team,
Hery Ramilison

MySQL Connector/C++ 8.0.12 has been released

Dear MySQL users,

MySQL Connector/C++ 8.0.12 is the second GA release version of the MySQL Connector/C++ 8.0 series.

Connector/C++ 8.0 can be used to access MySQL implementing Document Store or in a traditional way, using SQL queries. It allows writing both C++ and plain C applications using X DevAPI and X DevAPI for C. It also supports the legacy API of Connector/C++ 1.1 based on JDBC4.

To learn more about how to write applications using X DevAPI, see “X DevAPI User Guide”

https://dev.mysql.com/doc/x-devapi-userguide/en/

See also “X DevAPI Reference” at

https://dev.mysql.com/doc/dev/connector-cpp/devapi_ref.html

and “X DevAPI for C Reference” at

https://dev.mysql.com/doc/dev/connector-cpp/xapi_ref.html.

For generic information on using Connector/C++ 8.0, see
https://dev.mysql.com/doc/dev/connector-cpp/

Note: For X DevAPI applications, Connector/C++ 8.0 requires MySQL Server 5.7.12 or higher with X Plugin enabled. For applications that use the legacy JDBC API, Connector/C++ 8.0 can use MySQL Server 5.5 or higher, and X Plugin is not required.

https://dev.mysql.com/doc/refman/5.7/en/document-store.html

To download MySQL Connector/C++ 8.0.12, see the “Generally Available (GA)
Releases” tab at
https://dev.mysql.com/downloads/connector/cpp/



Changes in MySQL Connector/C++ 8.0.12 (2018-07-27, General Availability)
  • Installation Notes
  • Packaging Notes
  • Security Notes
  • X DevAPI Notes
  • Bugs Fixed
Installation Notes * Because the Microsoft Visual C++ 2017 Redistributable installer deletes the Microsoft Visual C++ 2015 Redistributable registry keys that identify its installation, standalone MySQL MSIs may fail to detect the Microsoft Visual C++ 2015 Redistributable if both it and the Microsoft Visual C++ 2017 Redistributable are installed. The solution is to repair the Microsoft Visual C++ 2017 Redistributable via the Windows Control Panel to recreate the registry keys needed for the runtime detection. Unlike the standalone MSIs, MySQL Installer for Windows contains a workaround for the detection problem. Packaging Notes * An RPM package for installing ARM 64-bit (aarch64) binaries of Connector/C++ on Oracle Linux 7 is now available in the MySQL Yum Repository and for direct download. Known Limitation for this ARM release: You must enable the Oracle Linux 7 Software Collections Repository (ol7_software_collections) to install this package, and must also adjust the libstdc++7 path. See Yum's Platform Specific Notes (http://dev.mysql.com/doc/refman/8.0/en/linux- installation-yum-repo.html#yum-install-platform-specifics) for additional details. * Installers for Connector/C++ are now available in these formats: MSI packages (Windows); RPM packages (Linux); DMG packages (macOS). Security Notes * yaSSL is no longer included in Connector/C++ source distributions. wolfSSL may be used as a functionally equivalent alternative that has a GPLv2-compatible license. In addition, wolfSSL (like OpenSSL) supports the TLSv1.2 protocol, which yaSSL does not. To build Connector/C++ using wolfSSL, use the -DWITH_SSL=path_name CMake option, where path_name indicates the location of the wolfSSL sources. For more information, see Source Installation System Prerequisites (http://dev.mysql.com/doc/connector-cpp/8.0/en/connector -cpp-installation-source-prerequisites.html), and Connector/C++ Source-Configuration Options (http://dev.mysql.com/doc/connector-cpp/8.0/en/connector-cpp -source-configuration-options.html). X DevAPI Notes * Connector/C++ now supports NOWAIT and SKIP LOCKED lock contention modes to be used with lockExclusive() and lockShared() clauses of CRUD find/select operations (see Locking Read Concurrency with NOWAIT and SKIP LOCKED (http://dev.mysql.com/doc/refman/8.0/en/innodb -locking-reads.html#innodb-locking-reads-nowait-skip-locked), and a default lock contention mode. The following list names the permitted constants. For each item, the first and second constants apply to X DevAPI and X DevAPI for C, respectively. + LockContention::DEFAULT, LOCK_CONTENTION_DEFAULT: Block the query until existing row locks are released. + LockContention::NOWAIT, LOCK_CONTENTION_NOWAIT: Return an error if the lock cannot be obtained immediately. + LockContention::SKIP_LOCKED, LOCK_CONTENTION_SKIP_LOCKED: Execute the query immediately, excluding from the query items that are locked. For X DevAPI and X DevAPI for C applications, lock mode methods accept these lock contention constants as a parameter. For X DevAPI applications, lock mode methods can be called without this parameter, as before; this is equivalent to passing a lock mode of DEFAULT. * Connector/C++ now supports the SHA256_MEMORY authentication mechanism for connections using the X Protocol. For X DevAPI applications, SessionOption::AUTH supports the new value AuthMethod::SHA256_MEMORY. For X DevAPI for C applications, the session option MYSQLX_OPT_AUTH supports the new value MYSQLX_AUTH_SHA256_MEMORY. These new values request using the sha256_memory authentication mechanism when creating a session. * For compliance with the Core DevAPI, these Connector/C++ changes were made: + getAffectedItemsCount() was moved from Result to Result_common. + Collection.modify(condition).arrayDelete() was removed. + getAffectedRowsCount() was removed. Use getAffectedItemsCount() instead. + getWarningCount() was renamed to getWarningsCount(). Bugs Fixed * utf8mb4 character data was handled incorrectly. (Bug#28240202) * Session creation had a memory leak. (Bug #27917942) * When configuring to build Connector/C++ with the legacy connector, CMake did not account for the MYSQL_CONFIG_EXECUTABLE option. (Bug #27874173, Bug#90389) * Improper error handling for unknown hosts when creating a session could result in unexpected application exit. (Bug#27868302) * The mysqlx_row_fetch_one() X DevAPI for C function could fail to return for large result set exceeding the maximum packet size. Now such result sets produce an error. (Bug#27732224)

Enjoy and thanks for the support!

On Behalf of Oracle/MySQL Release Engineering Team,
Balasubramanian Kandasamy

What is new in Connector/C++ 8.0

We are proud to announce that with version 8.0.11 the new MySQL Connector/C++ 8.0 series becomes GA! Connector/C++ 8.0 is your gateway to the new exciting features of MySQL Server 8.0 such as MySQL Document Store. It also lets you perform your usual database tasks in a simpler and more powerful way using new, modern APIs that bring to you the full advantage of modern C++ programming language.

The 8.0 series is a true milestone in the development of Connector/C++. We have not only added new APIs but also completely re-implemented the connector to create good foundation for future innovation and improvements.The new implementation of Connector/C++ is based entirely on the new X Protocol of MySQL Server 8.0 and is highly modular to allow rapid development of new features. For the first time we aligned our APIs with other MySQL connectors. Also, for the first time Connector/C++ is offering a plain C API for code written in C.

New APIs of Connector/C++ 8.0

Up to now Connector/C++ implemented a single API based on JDBC4 standard. While keeping the old API for backward compatibility, the 8.0 series introduces two new APIs that can be used for accessing MySQL database.

  • X DevAPI: a C++ implementation of the new, fluent CRUD API defined for accessing MySQL Document Store and relational data. The same API is also implemented by xshell and other connectors and provides a uniform interface to the MySQL database.
  • XAPI: a new plain C API with functionality similar to that of X DevAPI. This API allows applications written in plain C to have access to the new MySQL features such as Document Store (it might feel strange to have plain C API in a C++ connector but in fact plain C can be seen as a subset of the C++ language; also, placing both APIs in the same connector allows re-using common implementation components).

To give you a feeling of the new APIs, here is a sample code which opens a session, creates a document collection, adds a document to that collection and then lists documents in the collection.

The same thing implemented in plain C, using XAPI, looks as follows (for simplicity, error handling logic is omitted).

Note that the choice of the API is done by including appropriate public header: either <mysqlx/xdevapi.h> or <mysqlx/xapi.h>.

Apart from a CRUD style interface for accessing the MySQL Document Store, which is shared with other MySQL connectors, the new APIs give you full access to SQL and relational data, including transactions, parameter binding, row locking, convenient classes for representing query results and more. For example, the following code shows how to execute a plain SQL query against a relational table using X DevAPI. Similar code can be written using XAPI.

The new APIs can be used as a modern replacement for the previous, JDBC based API of Connector/C++ 1.1 and for the CAPI of the MySQL client library. The X DevAPI brings the advantage and power of modern C++ programming with support for language constructs such as iterators, range loops, method chaining, RAII, overloaded operators, custom type conversions etc. The plain C XAPI is also a major re-design of the traditional MySQL CAPI with automatic memory management, better separation of public interface from internal implementation and with functions for accessing the MySQL Document Store. Note however that these new APIs are implemented over X Protocol and for that reason they will not work with older versions of MySQL Server.

For more information check available documentation on MySQL Document Store and X DevAPI User Guide. See also reference documentation for the Connector/C++ implementation of X DevAPI and XAPI reference documentation.

Getting started with Connector/C++ 8.0

Installing Connector/C++ 8.0

To develop applications that use Connector/C++ 8.0 you need the following files

  • Public headers containing declarations for the APIs implemented by the connector.
  • Connector libraries that contain implementation of the APIs. There are actually two libraries shipped with Connector/C++ 8.0 – the main library with base name mysqlcppconn8, implementing the new APIs (X DevAPI and XAPI), and a legacy library with base name mysqlcppconn which is a drop-in replacement for the 1.1 connector library. Both static and shared variants of each library are shipped.

These files are distributed as TGZ or ZIP packages that you can unpack to the location of your choice. There are several options for how to use the connector during compile time and at run-time, all depending on the platform you are working on and whether you want to install connector locally or system-wide. Below is some basic information to get you started. For more details see usage instructions in the reference manual.

Building code which uses Connector/C++ 8.0

Building code that uses Connector/C++ requires correctly setting include path, so that connector’s public headers can be found by the compiler, and passing connector library to the linker invocation. Assuming that Connector/C++ was installed under $MYSQL_CPPCONN_DIR the include path should be set to $MYSQL_CPPCONN_DIR/include (for gcc use -I option, for MSVC the C/C++ > Additional Include Directories  project setting). After that X DevAPI or XAPI declarations can be loaded using #include <mysqlx/xdevapi.h> or #include <mysqlx/xapi.h> directive, respectively.

Note: The X DevAPI uses C++11 language features. For some compilers C++11 must be explicitly enabled. For example gcc needs option -std=c++11 to understand C++11. This is not required for MSVC nor for XAPI code (which is plain C)

Depending on the platform, the shared Connector/C++ library is named:

  • libmysqlcppconn8.so on Unix platforms (soname libmysqlcppconn8.so.1)
  • libmysqlcppconn8.dylib on the OSX platform (link name libmysqlcppconn8.1.dylib)
  • mysqlcppconn8-1-vs14.dll on Windows platforms (with import library vs14/mysqlcppconn8.lib)

You need to add this library to your compiler/linker invocation when building code that uses the connector  (for gcc add -lmysqlcppconn8 to the linker options, for MSVC add vs14/mysqlcppconn8.lib to Linker > Input > Additional Dependencies  setting of your project). You also need to specify path where the connector library can be found (for gcc use -L option, for MSVC Linker > Additional Library Directories  setting). Assuming that Connector/C++ was installed under $MYSQL_CONCPP_DIR the libraries can be found under $MYSQL_CONCPP_DIR/lib on 32-bit platforms and $MYSQL_CONCPP_DIR/lib64 on 64-bit platforms.

Example gcc invocation for building application with sources in app.cc might look as follows (assuming that environment variable MYSQL_CONCPP_DIR is set to the location where Connector/C++ was installed)

Due to ABI incompatiblities between different compiler versions, the code that uses Connector/C++ libraries should be built with the same compiler version as the connector itself. The information about compiler version used to build connector libraries can be found inside BUILDINFO.txt file distributed with the connector. In principle a different version of the compiler can be used provided that it is ABI compatible, but it is difficult to determine what versions of the compiler are ABI compatible with each other.

Running code which uses Connector/C++ 8.0

Code built against Connector/C++ depends on the shared connector library which must be found at run-time by the dynamic linker. It also requires OpenSSL libraries that are used by Connector/C++.  Here are example run-time dependencies shown by ldd for an application built with Connector/C++.

To be able to run such an application the dynamic linker must be able to find the connector library in its predefined locations. The easiest way of arranging this is to copy the shared connector library to the location of the executable. This method works for any operating system. Otherwise the exact way of registering Connector/C++ libraries with the dynamic linker depends on the operating system.

Note: For platforms such as Windows, that normally do not have OpenSSL libraries available, Connector/C++ packages include these libraries. Putting these libraries next to the connector ones usually ensures that the dynamic linker can find them at run-time.

Note: On Windows the executable will depend on the MSVC 2015 runtime DLLs, that need to be installed on the target system.

Note: Connector/C++ also ships static libraries that can be used to build applications that do not require shared connector libraries to be present on the target system. However, an application linked statically with Connector/C++ will still depend on shared OpenSSL libraries and on MSVC runtime in case of Windows.

In summary

MySQL 8 brings a lot of new, exciting features which allow you to work with your data in new ways, going beyond the traditional SQL paradigm. Connector/C++ 8.0 is a part of this story and it also invites you to exploring new ways of working with MySQL from your C++ or C code. It is a result of a long effort and we are eager to hear about your impressions of the new features we brought to you. Happy coding!

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 HelloWorld.java.

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/C++ 8.0.11 GA has been released

Dear MySQL users,

MySQL Connector/C++ 8.0.11 is the first GA release version of the
MySQL Connector/C++ 8.0 series.

Connector/C++ 8.0 can be used to access MySQL implementing Document
Store or in a traditional way, using SQL queries. It allows writing
both C++ applications using X DevAPI or plain C applications using
XAPI.

To learn more about how to write applications using X DevAPI, see
“X DevAPI User Guide”

https://dev.mysql.com/doc/x-devapi-userguide/en/

and “X DevAPI Reference” at

https://dev.mysql.com/doc/dev/connector-cpp/devapi_ref.html

For more information about using plain C XAPI see “XAPI Reference” at

https://dev.mysql.com/doc/dev/connector-cpp/xapi_ref.html

For generic information on using Connector/C++ 8.0, see

https://dev.mysql.com/doc/dev/connector-cpp/

Note
For X DevAPI or XAPI applications, Connector/C++ 8.0 requires
MySQL Server 5.7.12 or higher with X Plugin enabled. For
applications that use the legacy JDBC API, Connector/C++ 8.0
can use MySQL Server 5.5 or higher, and X Plugin is not required.

https://dev.mysql.com/doc/refman/5.7/en/document-store.html

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

https://dev.mysql.com/downloads/connector/cpp/


Changes in MySQL Connector/C++ 8.0.11 (2018-04-19,
General Availability)

For MySQL Connector/C++ 8.0.11 and higher, Commercial and
Community distributions require the Visual C++
Redistributable for Visual Studio 2015 to work on Windows
platforms. The Redistributable is available at the Microsoft
Download Center
(http://www.microsoft.com/en-us/download/default.aspx);
install it before installing Connector/C++.

Functionality Added or Changed

* Incompatible Change: When documents without an _id
attribute are added to a collection, the server now
automatically generates IDs for them. The server
determines the ID format, which should be considered
opaque from the API perspective (they are no longer
UUID-based). As before, no _id attribute is generated if
a document already contains one. User-provided document
IDs must not conflict with IDs of other documents in the
collection.
This capability requires a MySQL 8.0 GA server. If the
server does not support document ID generation, the
document-add operation returns an error indicating that
document IDs were missing.
For X DevAPI, the generated IDs resulting from a
document-add operation can be obtained using the new
Result.getGeneratedIds() method, which returns a list.
For XAPI, the generated IDs can be obtained using the new
mysqlx_fetch_generated_id() function, which returns IDs
one by one for successive calls, until it returns NULL to
indicate no more generated IDs are available. For both X
DevAPI and XAPI, document IDs specified explicitly in
added documents are not returned.
Incompatibility: The getGeneratedIds() method replaces
getDocumentId() and getDocumentIds(), which are now
removed. The mysqlx_fetch_generated_id() function
replaces mysqlx_fetch_doc_id(), which is now removed.

* A patch operation has been implemented that enables
specifying a JSON-like object that describes the changes
to apply to documents in a collection.
For X DevAPI, the CollectionModify operation supports a
new patch() clause for patching documents. For XAPI,
there are two new functions:
mysqlx_collection_modify_patch() directly executes
patching on documents in a collection that satisfy given
criteria. mysqlx_set_modify_patch() adds a patch
operation to a modify statement created with the
mysql_collection_modify_new() function.

* For connections to the server made using the legacy JDBC
API (that is, not made using X DevAPI or XAPI),
Connector/C++ 8.0 now supports an
OPT_GET_SERVER_PUBLIC_KEY connection option that enables
requesting the RSA public key from the server. For
accounts that use the caching_sha2_password or
sha256_password authentication plugin, this key can be
used during the connection process for RSA key-pair based
password exchange with TLS disabled. This capability
requires a MySQL 8.0 GA server, and is supported only for
Connector/C++ built using OpenSSL.

Bugs Fixed

* Single-document methods such as Collection.replaceOne()
did not accept expr() as the document specification, but
instead treated it as a plain JSON string. (Bug
#27677910)

* Compiling X DevAPI and XAPI test programs failed with an
error. (Bug #27610760)

* Connecting with an incorrect SSL_CA value could result in
a memory leak. (Bug #27434254)

* For debug builds, specifying a document as _id raised an
assertion rather than producing an error. (Bug #27433969)

As always, a big THANK YOU for using MySQL!

MySQL Connector/NET 8.0.10-rc has been released

Dear MySQL users,

MySQL Connector/NET 8.0.10 is the first release candidate of MySQL
Connector/NET to add support for the new X DevAPI. The X DevAPI enables
application developers to write code that combines the strengths of the
relational and document models using a modern, NoSQL-like syntax that
does not assume previous experience writing traditional SQL.

To learn more about how to write applications using the X DevAPI, see
http://dev.mysql.com/doc/x-devapi-userguide/en/index.html. For more
information about how the X DevAPI is implemented in Connector/NET, see
http://dev.mysql.com/doc/dev/connector-net.

Please note that the X DevAPI requires at least MySQL Server version
5.7.12 or higher with the X Plugin enabled. For general documentation
about how to get started using MySQL as a document store, see
http://dev.mysql.com/doc/refman/5.7/en/document-store.html.

To download MySQL Connector/NET 8.0.10-rc, see the “Development
Releases” tab at
http://dev.mysql.com/downloads/connector/net/


Changes in MySQL Connector/NET 8.0.10 (2018-01-30, Release Candidate)

   Functionality Added or Changed

     * The .NET Core 2.0 implementation now supports the
       following connection-string options: AutoEnlist,
       InteractiveSession, Logging, Replication, and
       UseUsageAdvisor. For more information about the options,
       see Connector/NET Connection-String Options Reference
(http://dev.mysql.com/doc/connector-net/en/connector-net-connection-options.html).
       (Bug #27297337)

     * X DevAPI: In the process of refining the definition of
       the X DevAPI to cover the most relevant usage scenarios,
       the following API components have been removed from the X
       DevAPI implementation for MySQL Connector/NET:

          + API components that support session configurations
            The MySqlX.XDevAPI.Config namespace and all members
            of the namespace.

          + API components that support views
            CreateView(), DropView(), and ModifyView() methods
            from the MySqlX.XDevAPI.Schema class.
            ViewAlgorithm, ViewSqlSecurityEnum, and
            ViewCheckOptionEnum enumerations from the
            MySqlX.DataAccess namespace.
            Note
            The Table.IsView property remains available for
            query operations.

     * Support for .NET Core 2.0 and .NET Standard 2.0 has been
       added (.NET Core 1.1 support continues). With .NET Core
       2.0, most of the common ADO.NET classes are available for
       use, such as:

          + System.Data.DataTable, System.Data.DataColumn, and
            System.Data.DataRow

          + System.Data.DataSet

          + System.Data.Common.DataAdapter

     * Support for Entity Framework Core 2.0 has been added
       (Entity Framework 1.1 support continues). Currently, the
       MySQL Connector/NET implementation excludes the following
       2.0 features:

          + Modeling: table splitting, owned types, model-level
            query filters, database scalar function mapping,
            self-contained type configuration for code first.

          + High performance: DbContext pooling and explicitly
            compiled queries.

          + Change tracking: attach can track a graph of new and
            existing entities.

          + Query: improved LINQ translation, group-join
            improvements, string interpolation in FromSql and
            ExecuteSqlCommand, new EF.Functions.Like().

          + Database management: pluralization hook for
            DbContext scaffolding.

          + Others: only one provider per model, consolidated
            logging and diagnostics.

     * X DevAPI: MySQL Connector/NET now supports setting and
       releasing named transaction savepoints, which can be
       assigned a name explicitly or by default using the
       savepoint_(uuid) format. In addition, a transaction can
       be rolled back to a named savepoint.
       New methods were added to the MySqlX.XDevAPI.BaseSession
       class to implement corresponding SQL statements using the
       X Protocol:

          + SetSavepoint() and SetSavepoint(name) correspond to
            the SAVEPOINT statement.

          + ReleaseSavepoint() corresponds to the RELEASE
            SAVEPOINT statement.

          + RollbackTo() corresponds to the ROLLBACK TO
            statement.
       All errors generated by MySQL when one of the new methods
       is called will be returned by MySQL Connector/NET.

     * X DevAPI: The MySqlX.XDevAPI.CRUD.ModifyStatement.Patch
       method was added to enable the inclusion of JSON-like
       objects within Collection.Modify() operations that
       describe the changes to apply to all documents matching
       the condition.

     * Support for the caching_sha2_password authentication
       plugin through the classic MySQL protocol was added.
       Support through the X Protocol is limited to secure
       connections only (sslmode=required). Caching SHA-2
       pluggable authentication offers faster authentication
       than basic SHA-256 authentication.
       A new and related connection option,
       AllowPublicKeyRetrieval, was also added.

     * X DevAPI: The MySqlX.XDevAPI.Collection.CreateIndex
       method implementation was modified to enable the
       inclusion of a JSON document that defines the index to be
       created. Index-definition details can include the fields
       affected, data types, and so on.

   Bugs Fixed

     * X DevAPI: When the PLAIN authentication option was used
       to make a secure connection, the database name was
       excluded from the authenticating data and the database
       value was not set. PLAIN authentication is the default
       option for connections made with TLS or Unix Sockets.
       (Bug #27098974, Bug #88427)

     * Boolean values within a JSON document were improperly
       stored as strings. (Bug #26837112)

     * Invoking the
       MySql.Web.Security.MySqlWebSecurity.CreateUserAndAccount
       method with valid arguments, including
       additionalUserAttributes as an object with key/value
       pairs, returned an out-of-range exception. Thanks to
       Stein Setvik for contributing to the fix. (Bug #25046364)

     * The default character set and encoding were not set
       properly when making a connection to MySQL 5.6 and 5.7
       servers configured to use the utf8 character set. (Bug
       #23257011)

     * SSL connections made to a single MySQL instance could not
       be disconnected and created repeatedly without restarting
       the client application to clear the half-open sockets.
       (Bug #20393654, Bug #75022)

Nuget packages are available at:

https://www.nuget.org/packages/MySql.Data/8.0.10-rc
https://www.nuget.org/packages/MySql.Web/8.0.10-rc
https://www.nuget.org/packages/MySql.Data.EntityFramework/8.0.10-rc
https://www.nuget.org/packages/MySql.Data.EntityFrameworkCore/8.0.10-rc
https://www.nuget.org/packages/MySql.Data.EntityFrameworkCore.Design/8.0.10-rc

Enjoy and thanks for the support!

On Behalf of the MySQL/ORACLE RE Team
Gipson Pulla