MySQL Connector/Node.js 8.0.15 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.15, 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.15 (2019-02-01, General Availability)

This release contains no functional changes and is published
to align version number with the MySQL Server 8.0.15 release.

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

MySQL Connector/Node.js 8.0.14 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.14, 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.14 (2019-01-21, General Availability)

Functionality Added or Changed

* Removed deprecation notices from the count() methods.

* Setting the default schema via the connection now sets
the default schema on the server; meaning, subsequent
queries executed using session.sql() do not need to
specify the schema.

Bugs Fixed

* Setting the default schema with the connection URI using
a schema name that contained special characters (that
would need to be percent-encoded) would result in the
percent-encoded name being used instead of the original
one (e.g. “%25%26%5E*%5E_” instead of “%&^*^_”). (Bug
#28990682)

* An error is once again thrown if sslOption’s ‘ca’ is
different than the certificate authority used to sign the
server certificate, or if the server certificate has been
revoked. (Bug #28977649)

* Attempting to use false-like values such as 0, false,
null, and undefined would emit errors when updating or
inserting documents in a collection or rows in a table.
Additionally, now boolean values become numeric values
(true=1, false=0) while null and undefined are converted
to MySQL’s NULL type. (Bug #28970727, Bug #93315)

* Collection.existsInDatabase() always returned true if any
other collection existed in the database. (Bug #28745240)

* Configuring a default schema from the connection string
would create the schema if it did not exist. Now, an
“Unknown database” error is thrown instead.

* An unexpected notice could result in an unexpected halt
of the client.

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

Working with result sets in Connector/Node.js

MySQL 8.0 and the Document Store highlight brand new client tools such as the Shell and Connector/Node.js, both providing a JavaScript implementation of the X DevAPI. Although, for most cases, the public interface tends to be similar on both (barring some small details), there is one notable exception.

The way you handle result sets in a Node.js app using Connector/Node.js is a bit different from the way you do it using an interactive session or a non-interactive JS script in the Shell.

Executing an operation in the MySQL server using the Shell is a purely synchronous task from the user standpoint since the underlying code is C++ (multi-threaded) whereas, due to the way Node.js works (single-threaded with event loop), an application that uses Connector/Node.js has to do the same by resorting to some asynchronous construct.

Continue reading

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/Node.js 8.0.12 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.12, 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.12 (2018-07-27, General availability)

X DevAPI Notes

* For compliance with the Core DevAPI, these
Connector/Node.js changes were made:

+ Collection: Deprecated: count(). Changed:
getSchema() now returns a Schema instance instead of
the schema name.

+ CollectionModify: Deprecated: limit(x, y)’s second
parameter, and arrayDelete().

+ CollectionFind: Deprecated: limit(x, y)’s second
parameter. Added: limit(x).offset(y).

+ CollectionRemove: Deprecated: limit(x, y)’s second
parameter.

+ Table: Deprecated: count() and insert(Document) API.
Updated: getSchema() now returns a Schema instance
instead of the Schema name. Removed: as().

+ TableSelect: Deprecated: limit(x, y)’s second
parameter. Added: limit(x).offset(y).

+ TableDelete: Deprecated: limit(x, y)’s second
parameter, and delete(x)’s parameter in favor of
using where(x) instead.

+ TableUpdate: Deprecated: limit(x, y)’s second
parameter, and update(x)’s parameter in favor of
using where(x) instead.

+ SqlExecute: Deprecated: sqlExecute() in favor of
sql(). Added: bind().

+ Column: Added isNumberSigned(), getCollationName(),
getCharacterSetName(), and isPadded()

Bugs Fixed

* The Promise returned by the session.sql().execute()
method resolved to a plain JavaScript object rather than
a proper Result instance. This meant it lacked access to
the API with methods such as getAffectedItemsCount() and
getWarnings(). (Bug #28146988)

* Retrieving rows with NULL fields would emit an unexpected
AssertionError. (Bug #27978594)

* The session.close() method is now asynchronous by
returning a JavaScript Promise, when before it returned
immediately. (Bug #27893001)

* The right-padding mechanism was improved. (Bug #27839295)

* While calling getSession() without arguments yields an
“Invalid parameter.” error, passing in ‘{}’ yielded a
“Cannot read property ‘length’ of undefined.” error. Now
‘{}’ is allowed, and getSession() defaults to using ” as
the user name. (Bug #27730748)

* Improved performance for expression parsing and protocol
message encoding.

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

Introducing Connector/Node.js for MySQL 8.0

As you may have heard, MySQL 8.0 is now officially GA, and it comes with a bunch of additional goodies. Among those is the brand new Connector/Node.js, which is the official MySQL driver for Node.js and, currently, the only one with support for the latest server versions and features (such as the MySQL document store).

Here’s a rundown of what’s available:

  • Out-of-the box support for MySQL 8.0
  • Document-store API as a first-class citizen
  • TLS/SSL and SHA256 authentication
  • Fluent API with support for flexible parameters
  • Semantic methods to encode common CRUD operations
  • Modern Node.js asynchronous interface based on Promises
  • Abstractions for common database development tasks
  • Transactions, savepoints and row locking

MySQL 8.0

Connector/Node.js is currently the only driver in the Node.js ecosystem that works out-of-the-box with the latest MySQL 8.0 series and implements the brand new X Protocol and X DevAPI, which unlocks exclusive server features such as the MySQL document store.

In a nutshell, the X Protocol is based on the Google Protocol Buffers serialization format, and provides a common interface for a different set of official connectors to bridge into the MySQL server via the X plugin, which contains the server-side implementation of the document store and a surrounding scaffolding ecosystem including things like common CRUD expression trees, bound parameters, or expectations and conditions for statement pipelining.

The X DevAPI is the common client-side API used by all connectors to abstract the details of the X Protocol. It specifies the common set of CRUD-style functions/methods used by all the official connectors to work with both document store collections and relational tables, a common expression language to establish query properties such as criteria, projections, aliases, and a standard set of additional database management features for handling things like transactions, indexes, etc.

The fact that most of these features share the same format and API between connectors, makes the X DevAPI a perfect fit for mordern polyglot development environments such as microservices, and the fact that they are based on a well-documented format allows advanced users to extend client-side implementations and build new middleware components or extensions tailor-made for their use case.

Although, there are (most of the times) matching client APIs to work with relational tables, this overview will focus mostly on document-store related features. Check the official Connector/Node.js documentation or the X DevAPI user guide to get the full picture.

Secure by default

With Connector/Node.js, SSL/TLS is enabled by default for server TCP connections and, additionally, the server identity can be validated against a given certificate authority (CA).

Of course you can explicitely override this behavior (at your own peril).

Local Unix sockets don’t use SSL/TLS since they don’t really benefit much from that level of security. At the same time, that removes the possibility of any additional performance overhead caused by the SSL/TLS handshake.

In the authentication realm, besides the traditional SHA1-based server authentication plugin, Connector/Node.js also supports the latest secure authentication plugins based on SHA-256. Of course you can always use your own custom server plugins, as long as the authentication data can be sent using one of the existing client-side authentication mechanisms (in the simplest form, via plain text).

Additional details about Connector/Node.js security can be found here.

Fluent API

The public API flows nicely from a single getSession()  method. Whereas, when it comes the point of creating and issuing database operations, you get a nice fluent query builder where those operations are encapsulated in specialized and specific methods, which, compared to using raw SQL statements, brings benefits such as:

  • more readable, maintainable (and even testable) code
  • better tooling integration
    • scaffolding for code refactoring
    • text-editor (or IDE) hints and auto-completion
  • smaller SQL injection surface area
  • common standard between different programming languages and environments

Most public API methods provide alternative input handling flavors:

  • multiple individual arguments
  • a single array of arguments
  • an object with named properties (where it applies)

Promise-based asynchronous tasks

Being a good Node.js citizen, Connector/Node.js encapsulates all blocking I/O operations with asynchronous methods. Each method that sends a message to the MySQL server is expected to return a JavaScript Promise , which resolves to the specific result or fails with an error. This pattern also unlocks other platform abstractions such as the async/await  syntax, making it even more flexible for the user than just using traditional error-first callbacks.

So, after building a query, it can be sent to the server via the execute()  method. In turn, the method receives an optional callback as argument, which runs for each element in the result set. When using relational tables, an additional callback function can be used to tap into the given column metadata.

Other methods, such as the ones that operate on a single instance of a connection, database object (be it a schema, table/collection, row, document, etc.) will return a Promise  by themselves (dropping the extra call to execute() ). Some examples:

  • mysqlx.getSession()
  • session.getSchemas()
  • session.createSchema()
  • schema.getCollections()
  • schema.createCollection()
  • collection.getOne()
  • collection.addOrReplaceOne()
  • collection.replaceOne()
  • collection.createIndex()

Data consistency

With MySQL 8.0, you get session-level consistency and document-level isolation via multiple database constructs, such as transactions, savepoints and row locking. This allows to encapsulate a set of operations (particularly DML) encompassing multiple documents or collections in a single atomic procedure within a given session.

Connector/Node.js provides APIs to create, commit or rollback a transaction as well as to create, release or rollback to an intermediate savepoint within that transaction.

In the presence of concurrent transactions, the isolation level of each operation within the transaction, operating on a given document, can be determined using row locks.

Raw SQL interface

If you are looking for a feature that is still not available on the X DevAPI, or simply something that does not fit the CRUD model, you can always resort to plain old SQL.

Getting Started

If you want to use Connector/Node.js in your own project or just want to play around with, download the latest version from npm:

New releases DO NOT follow semantic versioning, so, to avoid being affected by breaking changes, make sure you use --save-exact  when pulling the package, particularly if you don’t have npm-shrinkwrap.json  or package-lock.json  files locking down your project’s dependencies.

If you are an advanced user, being an open source project, the code is hosted on the official GitHub repository and contributions are welcome, either in the form of bugs ( Connector for Node.js  category) or pull requests.

Up and Running

Assuming you are running MySQL 8.0 with the default configuration and Node.js v8.0.0  or later (for async/await  support), using Connector/Node.js and the MySQL document store in your project is as simple as follows:

These are just some of the highlights. Make sure you check out the official Connector/Node.js documentation or the X DevAPI user guide for usage examples and even more details on how to get started.

Please give it a try! Your feedback is more than welcome.

MySQL Connector/Node.js 8.0.11 GA has been released

MySQL Connector/Node.js is a new Node.js driver for use with the X DevAPI. This release, v8.0.11, is the first general availability 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 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.

Changes in MySQL Connector/Node.js 8.0.11 (2018-04-19, General
Availability)

Functionality Added or Changed

  • The protobuf.js library was replaced with the official google-protobuf npm package.
  • Added NOWAIT and SKIP_LOCKED support to the lockShared() and lockExclusive() methods. Example usage: lockShared(mysqlx.LockContention.SKIP_LOCKED).
  • Added the X DevAPI SHA256_MEMORY authentication mechanism.
  • Auto-generated document _id values generated by the MySQL server, introduced in MySQL Server 8.0.11, are now supported.

Bugs Fixed

  • Running a select query against a table containing BIGINT values and using those values as filtering criteria could fail to function. This was because those values were converted to JavaScript numbers when encoding the protobuf message, and lost precision since the maximum safe integer in JavaScript is 2^53 – 1. (Bug #27570761)
  • Row values from columns using the FLOAT type were not rounded according to the maximum number of displayable decimal digits defined by the schema. For example, a column with type FLOAT(3,2) containing a value of 1.23456789 would display as 1.2300000190734863 instead of the expected 1.23. (Bug #27570541)
  • Row values from columns using the BIT (http://dev.mysql.com/doc/refman/5.7/en/bit-type.html) data type were decoded as their sign integer counterpart instead of unsigned values. For example, b’111′ was decoded as -4 instead of 7. (Bug #27570462)
  • Row values for columns of any type of UNSIGNED integer (TINYINT, SMALLINT, MEDIUMINT, INT or BIGINT) were being interpreted by the connector as their SIGNED integer value counterpart. (Bug #27570342)
  • The sort() method was added to the following operations: CollectionFind, CollectionRemove, and CollectionModify. (Bug #27429922)
  • While adding a document, the expression parser was rejecting valid escaped literally strings that constituted properties of the document, and it threw unexpected errors. (Bug #27429852)
  • Messages split into multiple fragments (either because they exceeded the MTU or the maximum size of V8 buffers) were improperly reconstructed and could not be decoded. This behavior would throw an error similar to “Uncaught SyntaxError: Unexpected token”. (Bug #27429429)
  • Several methods returned plain JavaScript objects that now return iterable arrays. Schema.getCollections() now returns an array of Collection instances, Schema.getTables() now returns an array of Table instances, and Session.getSchemas() now returns an array of Schema instances. (Bug #27294362, Bug #27221114)
  • The expression parser was executed every time a document was added but now requires mysqlx.expr() to be explicitly called. For example, before collection.add({ name: ‘foo’ }) would parse the “name” property. Now, to parse it, use collection.add({ name: mysqlx.expr(‘”foo”‘) }). (Bug #27177864)

Enjoy and thanks for the support!

MySQL Connector/Node.js 8.0.9 RC has been released

MySQL Connector/Node.js is a new Node.js driver for use with the X DevAPI. This release, v8.0.9, is the third development 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/.

Note

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.

Functionality Added or Changed

  • Improved the UUID generation algorithm to implement the design improvements suggested in RFC 4122. Before the chance of duplicated values during a small time frame was too high. (Bug #26120588)
  • 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 Connector/Node.js:
    • API components that support session configurations, such as the SessionConfig and SessionConfigManager classes.
    • The mysqlx.config namespace and all methods of the namespace, save(), get(), list(), delete(), and more.
    • The createTable(), foreignKey(), dropTable(), createView(), dropView(), and alterView() methods from the Schema class.
  • The following methods were added:
    • Session.setSavePoint: accepts a name or generates one of the form connector-nodejs-{uuid}, and returns a Promise.
    • Session.releaseSavePoint: releases a specific savepoint.
    • Session.rollbackTo: rollbacks to a specified savepoint.
  • The createIndex() method was added to the Collection API.

Bugs Fixed

  • The expression parser used by the CRUD API was replaced with a new implementation written in pure JavaScript. This fixes several grammar related bugs. (Bug #26729768, Bug #26636956, Bug #25036336, Bug #23148246)
  • The CollectionFind.fields() method was updated to support flexible parameters to follow standard X DevAPI conventions. (Bug #22084545)

Enjoy and thanks for the support!

MySQL Connector/Node.js 8.0.8-dmr has been released

MySQL Connector/Node.js is a new Node.js driver for use with the X
DevAPI. This release, v8.0.8, is the second development 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/.

Note

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.

Functionality Added or Changed

Bugs Fixed

  • Added support for the parentheses-based IN syntax, such as IN (x, y, z, …), as defined in the X DevAPI. (Bug #26666817)

On behalf of the MySQL/Oracle Release Engineering Team
Piotr Obrzut

MySQL Connector/NodeJS 8.0.7-dmr has been released

MySQL Connector/Node.js is a new Node.js driver for use with the X
DevAPI. This release, v8.0.7 , is the first development 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/.

Note

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.

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.

Connector/Node.js 8.0.7 is the first release to use the new
numbering. It is the successor to Connector/Node.js 1.0.6.

Functionality Added or Changed

  • It is no longer permitted to pass an empty search condition, such as the NULL value or an empty string, to the Collection.modify() and Collection.remove() methods.
  • A number of changes have been implemented for the “drop” methods:
    • The “drop” methods are now made available at the same level as the corresponding “create” methods. For example, the dropCollection() and dropTable() methods have been removed from the XSession class (which has now been consolidated into the Session class) and moved under the Schema class; under the same principle, the drop() method has been removed from the Collection and Table classes.
    • The “drop” methods now succeed even if the objects to be dropped do not exist.
    • dropView() is now asynchronous and behaves exactly like dropTable() and dropCollection() by implicitly executing the operation and returning a promise that will hold the result of the drop operation.
  • A configuration handler interface, mysqlx.config, has been created for managing persisted session configurations. See MySQL Connector/Node.js with X DevAPI
    (http://dev.mysql.com/doc/dev/connector-nodejs/) for details.
  • There are a few changes with regard to secure connections to MySQL servers:
    • Connections are now secure by default.
    • The connection option ssl-enable has been replaced by the ssl-mode option, which has DISABLED, REQUIRED (default), and VERIFY_CA as its permitted values
    • Using the ssl-crl option requires the use of the ssl-ca option and that ssl-mode=VERIFY_CA; this is due to an internal requirement of the Node.js core platform.
  • Consolidated the BaseSession, NodeSession, and XSession into a single Session class. The following related changes were also made:
    • The mysqlx.getNodeSession() method is renamed to getSession and returns a Session object.
    • The DatabaseObject.getSession() now returns a Session object.
  • A new client-side failover feature has been implemented: when creating a new connection, multiple hosts now can be specified in the connection string, and Connector/Node.js tries each host until a successful connection is established or until all hosts have been tried. See Tutorial: Getting Started
    (http://dev.mysql.com/doc/dev/connector-nodejs/tutorial-Getting_Started.html)
    for details
  • Connector/Node.js now supports connecting to a local server using Unix sockets. See Tutorial: Getting Started
    (http://dev.mysql.com/doc/dev/connector-nodejs/tutorial-Getting_Started.html)
    for details.
  • The format of the document ID value generated when adding a document to a collection has changed. It is still a string of 32 hexadecimal digits based on a UUID, but the order of digits has been changed to match the requirement of a stable ID prefix.

Bugs Fixed

    • It was not possible to create a new session for a user with a SHA256 password via the PLAIN authentication mechanism. (Bug #26117627)
    • The handling of large JSON arrays was problematic, and would cause an exception to be thrown. (Bug #26084604)
    • Attempting to use bind when removing a document from a collection would not succeed, and an exception would be thrown. (Bug #26029551)
    • The Table.update() implementation did not require a SearchConditionStr parameter, and not using this parameter could result in updating all the rows of a given table. A client-side exception is now thrown if the SearchConditionStr parameter is undefined or empty. (Bug #25993174)
    • The Table.delete() implementation did not require a SearchConditionStr parameter, and not using this parameter could result in deleting all the rows of a given table. A client-side exception is now thrown if the SearchConditionStr parameter is undefined or empty. (Bug #25992969)

On behalf of the MySQL/Oracle Release Engineering Team
Piotr Obrzut