node-mysql
Introduction
This is a node.js driver for mysql. It is written in JavaScript, does not
require compiling, and is 100% MIT licensed.
Here is an example on how to use it:
var mysql = require('mysql');
var connection = mysql.createConnection({
host : 'localhost',
user : 'me',
password : 'secret',
});
connection.connect();
connection.query('SELECT 1', function(err, rows, fields) {
if (err) throw err;
console.log('Query result: ', rows);
});
connection.end();
From this example, you can learn the following:
- Every method you invoke on a connection is queued and executed in sequence.
- Closing the connection is done using
end()
which makes sure all remaining
queries are executed before sending a quit packet to the mysql server.
Contributors
Thanks goes to the people who have contributed code to this module, see the
GitHub Contributors page.
Additionally I'd like to thank the following people:
- Andrey Hristov (Oracle) - for helping me with protocol questions.
- Ulf Wendel (Oracle) - for helping me with protocol questions.
The following companies have supported this project financially, allowing me to
spend more time on it (ordered by time of contribution):
If you are interested in sponsoring a day or more of my time, please
get in touch.
So far all community activity has happened via the GitHub Issue system, however
additionally I have just started a mailing list and IRC channel where people
can ask questions and discuss things:
Establishing connections
The recommended way to establish a connection is this:
var mysql = require('mysql');
var connection = mysql.createConnection({
host : String,
port : Number,
socketPath : String,
user : String,
password : String,
database : String,
charset : String,
typeCast : Boolean,
debug : Boolean,
});
connection.connect(function(err) {
});
However, a connection can also be implicitly established by invoking a query:
var mysql = require('mysql');
var connection = mysql.createConnection(...);
connection.query('SELECT 1', function(err, rows) {
});
Depending on how you like to handle your errors, either method may be
appropriate. Any type of connection error (handshake or network) is considered
a fatal error, see the Error Handling section for more
information.
Terminating connections
There are two ways to end a connection. Terminating a connection gracefully is
done by calling the end()
method:
connection.end(function(err) {
});
This will make sure all previously enqueued queries are still before sending a
COM_QUIT
packet to the MySQL server. If a fatal error occurs before the
COM_QUIT
packet can be sent, an err
argument will be provided to the
callback, but the connection will be terminated regardless of that.
An alternative way to end the connection is to call the destroy()
method.
This will cause an immediate termination of the underlaying socket.
Additionally destroy()
guarantees that no more events or callbacks will be
triggered for the connection.
connection.destroy();
Unlike end()
the destroy()
method does not take a callback argument.
Server disconnects
You may loose the connection to a MySQL server due to network problems, the
server timing you out, or the server crashing. All of these events are
considered fatal errors, and will have the err.code = 'PROTOCOL_CONNECTION_LOST'
. See the Error Handling section
for more information.
The best way to be notified about a connection termination is to listen for the
'close'
event:
connection.on('close', function(err) {
if (err) {
connection = mysql.createConnection(connection.config);
} else {
}
});
As you can see in the example above, re-connecting a connection is done by
establishing a new connection. Once terminated, an existing connection object
cannot be re-connected by design.
Please note that you will also receive a 'close'
event with an err
argument
when a connection attempt fails because of bad credentials. If you find this
cumbersome to work with, please post to the node-mysql mailing list to discuss
improvements.
Escaping query values
In order to avoid SQL Injection attacks, you should always escape any user
provided data before using it inside a SQL query. You can do so using the
connection.escape()
method:
var userId = 'some user provided value';
var sql = 'SELECT * FROM users WHERE id = ' + connection.escape(userId);
connection.query(sql, function(err, results) {
});
Alternatively, you can use ?
characters as placeholders for values you would
like to have escaped like this:
connection.query('SELECT * FROM users WHERE id = ?', [userId], function(err, results) {
});
This looks similar to prepared statements in MySQL, however it really just uses
the same connection.escape()
method internally.
Different value types are escaped differently, here is how:
- Numbers are left untouched
- Booleans are converted to
true
/ false
strings - Date objects are converted to
'YYYY-mm-dd HH:ii:ss'
strings - Buffers are converted to hex strings, e.g.
X'0fa5'
- Strings are safely escaped
- Arrays are turned into list, e.g. ['a', 'b'] turns into
'a', 'b'
- Objects are turned into
key = 'val'
pairs. Nested objects are cast to
strings. undefined
/ null
are converted to NULL
NaN
/ Infinity
are left as-is. MySQL does not support these, and trying
to insert them as values will trigger MySQL errors until they implement
support.
If you paid attention, you may have noticed that this escaping allows you
to do neat things like this:
var post = {id: 1, title: 'Hello MySQL'};
var query = connection.query('INSERT INTO posts SET ?', post, function(err, result) {
});
console.log(query.sql);
Getting the id of an inserted row
If you are inserting a row into a table with an auto increment primary key, you
can retrieve the insert id like this:
connection.query('INSERT INTO posts SET ?', {title: 'test'}, function(err, result) {
if (err) throw err;
console.log(result.insertId);
});
Executing queries in parallel
The MySQL protocol is sequential, this means that you need multiple connections
to execute queries in parallel. Future version of this module may ship with a
connection pool implementation, but for now you have to figure out how to
manage multiple connections yourself if you want to execute queries in
parallel.
One simple approach is to create one connection per incoming http request.
Streaming query rows
Sometimes you may want to select large quantities of rows and process each of
them as they are received. This can be done like this:
var query = connection.query('SELECT * FROM posts');
query
.on('error', function(err) {
})
.on('fields', function(fields) {
})
.on('result', function(row) {
connection.pause();
processRow(row, function() {
connection.resume();
});
})
.on('end', function() {
});
Please note a few things about the example above:
- Usually you will want to receive a certain amount of rows before starting to
throttle the connection using
pause()
. This number will depend on the
amount and size of your rows. pause()
/ resume()
operate on the underlaying socket and parser. You are
guaranteed that no more 'result'
events will fire after calling pause()
.- You MUST NOT provide a callback to the
query()
method when streaming rows. - The
'result'
event will fire for both rows as well as OK packets
confirming the success of a INSERT/UPDATE query.
Additionally you may be interested to know that it is currently not possible to
stream individual row columns, they will always be buffered up entirely. If you
have a good use case for streaming large fields to and from MySQL, I'd love to
get your thoughts and conributions on this.
Multiple statement queries
Support for multiple statements is disabled for security reasons (it allows for
SQL injection attacks if values are not properly escaped). To use this feature
you have to enable it for your connection:
var connection = mysql.createConnection({multipleStatements: true});
Once enabled, you can execute multiple statement queries like any other query:
connection.query('SELECT 1; SELECT 2', function(err, results) {
if (err) throw err;
console.log(results[0]);
console.log(results[1]);
});
Additionally you can also stream the results of multiple statement queries:
var query = connection.query('SELECT 1; SELECT 2');
query
.on('fields', function(fields, index) {
})
.on('result', function(row, index) {
});
If one of the statements in your query causes an error, the resulting Error
object contains a err.index
property which tells you which statement caused
it. MySQL will also stop executing any remaining statements when an error
occurs.
Please note that the interface for streaming multiple statement queries is
experimental and I am looking forward to feedback on it.
Stored procedures
You can call stored procedures from your queries as with any other mysql driver.
If the stored procedure produces several result sets, they are exposed to you
the same way as the results for multiple statement queries.
Joins with overlapping column names
When executing joins, you are likely to get result sets with overlapping column
names.
By default, node-mysql will overwrite colliding column names in the
order the columns are received from MySQL, causing some of the received values
to be unavailable.
However, you can also specify that you want your columns to be nested below
the table name like this:
var options = {sql: '...', nestTables: true};
connection.query(options, function(err, results) {
});
Error handling
This module comes with a consistent approach to error handling that you should
review carefully in order to write solid applications.
All errors created by this module are instances of the JavaScript Error
object. Additionally they come with two properties:
err.code
: Either a MySQL server error (e.g.
'ER_ACCESS_DENIED_ERROR'
), a node.js error (e.g. 'ECONNREFUSED'
) or an
internal error (e.g. 'PROTOCOL_PARSER_EXCEPTION'
).err.fatal
: Boolean, indicating if this error is terminal to the connection
object.
Fatal errors are propagated to all pending callbacks. In the example below, a
fatal error is triggered by trying to connect to an invalid port. Therefore the
error object is propagated to both pending callbacks:
var connection = require('mysql').createConnection({
port: 84943,
});
connection.connect(function(err) {
console.log(err.code);
console.log(err.fatal);
});
connection.query('SELECT 1', function(err) {
console.log(err.code);
console.log(err.fatal);
});
Normal errors however are only delegated to the callback they belong to. So in
the example below, only the first callback receives an error, the second query
works as expected:
connection.query('USE name_of_db_that_does_not_exist', function(err, rows) {
console.log(err.code);
});
connection.query('SELECT 1', function(err, rows) {
console.log(err);
console.log(rows.length);
});
Last but not least: If a fatal errors occurs and there are no pending
callbacks, or a normal error occurs which has no callback belonging to it, the
error is emitted as an 'error'
event on the connection object. This is
demonstrated in the example below:
connection.on('error', function(err) {
console.log(err.code);
});
connection.query('USE name_of_db_that_does_not_exist');
Note: 'error'
are special in node. If they occur without an attached
listener, a stack trace is printed and your process is killed.
tl;dr: This module does not want you to to deal with silent failures. You
should always provide callbacks to your method calls. If you want to ignore
this advice and suppress unhandled errors, you can do this:
connection.on('error', function() {});
Type casting
For your convenience, this driver will cast mysql types into native JavaScript
types by default. The following mappings exist:
Number
- TINYINT
- SMALLINT
- INT
- MEDIUMINT
- YEAR
- FLOAT
- DOUBLE
Date
Buffer
- TINYBLOB
- MEDIUMBLOB
- LONGBLOB
- BLOB
- BINARY
- VARBINARY
- BIT (last byte will be filled with 0 bits as neccessary)
String
- CHAR
- VARCHAR
- TINYTEXT
- MEDIUMTEXT
- LONGTEXT
- TEXT
- ENUM
- SET
- DECIMAL (may exceed float precision)
- BIGINT (may exceed float precision)
- TIME (could be mapped to Date, but what date would be set?)
- GEOMETRY (never used those, get in touch if you do)
It is not recommended (and may go away / change in the future) to disable type
casting, but you can currently do so on either the connection:
var connection = require('mysql').createConnection({typeCast: false});
Or on the query level:
var options = {sql: '...', typeCast: false};
var query = connection.query(options, function(err, results) {
}):
Debugging and reporting problems
If you are running into problems, one thing that may help is enabling the
debug
mode for the connection:
var connection = mysql.createConnection({debug: true});
This will print all incoming and outgoing packets on stdout.
If that does not help, feel free to open a GitHub issue. A good GitHub issue
will have:
- The minimal amount of code required to reproduce the problem (if possible)
- As much debugging output and information about your environment (mysql
version, node version, os, etc.) as you can gather.
FAQ
I have yet to write this, but it will include:
- What benefits does this driver have over compiled alternatives? (portability,
license, docs)
- How is the performance of this module compared to the alternatives? (great)
- Is there commercial support for this driver? (nodefirm?)
- What features are missing? (stored procedures, transactions, pause, etc.)
- How can I contribute? (explain)
- What are the goals of this project?
Todo
- Prepared statements
- setTimeout() for Connection / Query
- connection pooling
- Support for encodings other than UTF-8 / ASCII
- API support for transactions, similar to php