Initial commit
This commit is contained in:
569
node_modules/mysql/Changes.md
generated
vendored
Normal file
569
node_modules/mysql/Changes.md
generated
vendored
Normal file
@ -0,0 +1,569 @@
|
||||
# Changes
|
||||
|
||||
This file is a manually maintained list of changes for each release. Feel free
|
||||
to add your changes here when sending pull requests. Also send corrections if
|
||||
you spot any mistakes.
|
||||
|
||||
## v2.18.1 (2020-01-23)
|
||||
|
||||
* Fix Amazon RDS profile for yaSSL MySQL servers with 2019 CA #2292
|
||||
|
||||
## v2.18.0 (2020-01-21)
|
||||
|
||||
* Add `localInfile` option to control `LOAD DATA LOCAL INFILE`
|
||||
* Add new Amazon RDS Root 2019 CA to Amazon RDS SSL profile #2280
|
||||
* Add new error codes up to MySQL 5.7.29
|
||||
* Fix early detection of bad callback to `connection.query`
|
||||
* Support Node.js 12.x #2211
|
||||
* Support Node.js 13.x
|
||||
* Support non-enumerable properties in object argument to `connection.query` #2253
|
||||
* Update `bignumber.js` to 9.0.0
|
||||
* Update `readable-stream` to 2.3.7
|
||||
|
||||
## v2.17.1 (2019-04-18)
|
||||
|
||||
* Update `bignumber.js` to 7.2.1 #2206
|
||||
- Fix npm deprecation warning
|
||||
|
||||
## v2.17.0 (2019-04-17)
|
||||
|
||||
* Add reverse type lookup for small performance gain #2170
|
||||
* Fix `connection.threadId` missing on handshake failure
|
||||
* Fix duplicate packet name in debug output
|
||||
* Fix no password support for old password protocol
|
||||
* Remove special case for handshake in determine packet code
|
||||
* Small performance improvement starting command sequence
|
||||
* Support auth switch in change user flow #1776
|
||||
* Support Node.js 11.x
|
||||
* Update `bignumber.js` to 6.0.0
|
||||
|
||||
## v2.16.0 (2018-07-17)
|
||||
|
||||
* Add Amazon RDS GovCloud SSL certificates #1876
|
||||
* Add new error codes up to MySQL 5.7.21
|
||||
* Include connection ID in debug output
|
||||
* Support Node.js 9.x
|
||||
* Support Node.js 10.x #2003 #2024 #2026 #2034
|
||||
* Update Amazon RDS SSL certificates
|
||||
* Update `bignumber.js` to 4.1.0
|
||||
* Update `readable-stream` to 2.3.6
|
||||
* Update `sqlstring` to 2.3.1
|
||||
- Fix incorrectly replacing non-placeholders in SQL
|
||||
|
||||
## v2.15.0 (2017-10-05)
|
||||
|
||||
* Add new Amazon RDS ca-central-1 certificate CA to Amazon RDS SSL profile #1809
|
||||
* Add new error codes up to MySQL 5.7.19
|
||||
* Add `mysql.raw()` to generate pre-escaped values #877 #1821
|
||||
* Fix "changedRows" to work on non-English servers #1819
|
||||
* Fix error when server sends RST on `QUIT` #1811
|
||||
* Fix typo in insecure auth error message
|
||||
* Support `mysql_native_password` auth switch request for Azure #1396 #1729 #1730
|
||||
* Update `sqlstring` to 2.3.0
|
||||
- Add `.toSqlString()` escape overriding
|
||||
- Small performance improvement on `escapeId`
|
||||
* Update `bignumber.js` to 4.0.4
|
||||
|
||||
## v2.14.1 (2017-08-01)
|
||||
|
||||
* Fix holding first closure for lifetime of connection #1785
|
||||
|
||||
## v2.14.0 (2017-07-25)
|
||||
|
||||
* Add new Amazon RDS ap-south-1 certificate CA to Amazon RDS SSL profile #1780
|
||||
* Add new Amazon RDS eu-west-2 certificate CA to Amazon RDS SSL profile #1770
|
||||
* Add `sql` property to query `Error` objects #1462 #1628 #1629
|
||||
* Add `sqlMessage` property to `Error` objects #1714
|
||||
* Fix the MySQL 5.7.17 error codes
|
||||
* Support Node.js 8.x
|
||||
* Update `bignumber.js` to 4.0.2
|
||||
* Update `readable-stream` to 2.3.3
|
||||
* Use `safe-buffer` for improved Buffer API
|
||||
|
||||
## v2.13.0 (2017-01-24)
|
||||
|
||||
* Accept regular expression as pool cluster pattern #1572
|
||||
* Accept wildcard anywhere in pool cluster pattern #1570
|
||||
* Add `acquire` and `release` events to `Pool` for tracking #1366 #1449 #1528 #1625
|
||||
* Add new error codes up to MySQL 5.7.17
|
||||
* Fix edge cases when determing Query result packets #1547
|
||||
* Fix memory leak when using long-running domains #1619 #1620
|
||||
* Remove unnecessary buffer copies when receiving large packets
|
||||
* Update `bignumber.js` to 3.1.2
|
||||
* Use a simple buffer list to improve performance #566 #1590
|
||||
|
||||
## v2.12.0 (2016-11-02)
|
||||
|
||||
* Accept array of type names to `dateStrings` option #605 #1481
|
||||
* Add `query` method to `PoolNamespace` #1256 #1505 #1506
|
||||
- Used as `cluster.of(...).query(...)`
|
||||
* Add new error codes up to MySQL 5.7.16
|
||||
* Fix edge cases writing certain length coded values
|
||||
* Fix typo in `HANDSHAKE_NO_SSL_SUPPORT` error message #1534
|
||||
* Support Node.js 7.x
|
||||
* Update `bignumber.js` to 2.4.0
|
||||
* Update `sqlstring` to 2.2.0
|
||||
- Accept numbers and other value types in `escapeId`
|
||||
- Escape invalid `Date` objects as `NULL`
|
||||
- Run `buffer.toString()` through escaping
|
||||
|
||||
## v2.11.1 (2016-06-07)
|
||||
|
||||
* Fix writing truncated packets starting with large string/buffer #1438
|
||||
|
||||
## v2.11.0 (2016-06-06)
|
||||
|
||||
* Add `POOL_CLOSED` code to "Pool is closed." error
|
||||
* Add `POOL_CONNLIMIT` code to "No connections available." error #1332
|
||||
* Bind underlying connections in pool to same domain as pool #1242
|
||||
* Bind underlying socket to same domain as connection #1243
|
||||
* Fix allocation errors receiving many result rows #918 #1265 #1324 #1415
|
||||
* Fix edge cases constructing long stack traces #1387
|
||||
* Fix handshake inactivity timeout on Node.js v4.2.0 #1223 #1236 #1239 #1240 #1241 #1252
|
||||
* Fix Query stream to emit close after ending #1349 #1350
|
||||
* Fix type cast for BIGINT columns when number is negative #1376
|
||||
* Performance improvements for array/object escaping in SqlString #1331
|
||||
* Performance improvements for formatting in SqlString #1431
|
||||
* Performance improvements for string escaping in SqlString #1390
|
||||
* Performance improvements for writing packets to network
|
||||
* Support Node.js 6.x
|
||||
* Update `bignumber.js` to 2.3.0
|
||||
* Update `readable-stream` to 1.1.14
|
||||
* Use the `sqlstring` module for SQL escaping and formatting
|
||||
|
||||
## v2.10.2 (2016-01-12)
|
||||
|
||||
* Fix exception/hang from certain SSL connection errors #1153
|
||||
* Update `bignumber.js` to 2.1.4
|
||||
|
||||
## v2.10.1 (2016-01-11)
|
||||
|
||||
* Add new Amazon RDS ap-northeast-2 certificate CA to Amazon RDS SSL profile #1329
|
||||
|
||||
## v2.10.0 (2015-12-15)
|
||||
|
||||
* Add new error codes up to MySQL 5.7.9 #1294
|
||||
* Add new JSON type constant #1295
|
||||
* Add types for fractional seconds support
|
||||
* Fix `connection.destroy()` on pool connection creating sequences #1291
|
||||
* Fix error code 139 `HA_ERR_TO_BIG_ROW` to be `HA_ERR_TOO_BIG_ROW`
|
||||
* Fix error when call site error is missing stack #1179
|
||||
* Fix reading password from MySQL URL that has bare colon #1278
|
||||
* Handle MySQL servers not closing TCP connection after QUIT -> OK exchange #1277
|
||||
* Minor SqlString Date to string performance improvement #1233
|
||||
* Support Node.js 4.x
|
||||
* Support Node.js 5.x
|
||||
* Update `bignumber.js` to 2.1.2
|
||||
|
||||
## v2.9.0 (2015-08-19)
|
||||
|
||||
* Accept the `ciphers` property in connection `ssl` option #1185
|
||||
* Fix bad timezone conversion from `Date` to string for certain times #1045 #1155
|
||||
|
||||
## v2.8.0 (2015-07-13)
|
||||
|
||||
* Add `connect` event to `Connection` #1129
|
||||
* Default `timeout` for `connection.end` to 30 seconds #1057
|
||||
* Fix a sync callback when sequence enqueue fails #1147
|
||||
* Provide static require analysis
|
||||
* Re-use connection from pool after `conn.changeUser` is used #837 #1088
|
||||
|
||||
## v2.7.0 (2015-05-27)
|
||||
|
||||
* Destroy/end connections removed from the pool on error
|
||||
* Delay implied connect until after `.query` argument validation
|
||||
* Do not remove connections with non-fatal errors from the pool
|
||||
* Error early if `callback` argument to `.query` is not a function #1060
|
||||
* Lazy-load modules from many entry point; reduced memory use
|
||||
|
||||
## v2.6.2 (2015-04-14)
|
||||
|
||||
* Fix `Connection.createQuery` for no SQL #1058
|
||||
* Update `bignumber.js` to 2.0.7
|
||||
|
||||
## v2.6.1 (2015-03-26)
|
||||
|
||||
* Update `bignumber.js` to 2.0.5 #1037 #1038
|
||||
|
||||
## v2.6.0 (2015-03-24)
|
||||
|
||||
* Add `poolCluster.remove` to remove pools from the cluster #1006 #1007
|
||||
* Add optional callback to `poolCluster.end`
|
||||
* Add `restoreNodeTimeout` option to `PoolCluster` #880 #906
|
||||
* Fix LOAD DATA INFILE handling in multiple statements #1036
|
||||
* Fix `poolCluster.add` to throw if `PoolCluster` has been closed
|
||||
* Fix `poolCluster.add` to throw if `id` already defined
|
||||
* Fix un-catchable error from `PoolCluster` when MySQL server offline #1033
|
||||
* Improve speed formatting SQL #1019
|
||||
* Support io.js
|
||||
|
||||
## v2.5.5 (2015-02-23)
|
||||
|
||||
* Store SSL presets in JS instead of JSON #959
|
||||
* Support Node.js 0.12
|
||||
* Update Amazon RDS SSL certificates #1001
|
||||
|
||||
## v2.5.4 (2014-12-16)
|
||||
|
||||
* Fix error if falsy error thrown in callback handler #960
|
||||
* Fix various error code strings #954
|
||||
|
||||
## v2.5.3 (2014-11-06)
|
||||
|
||||
* Fix `pool.query` streaming interface not emitting connection errors #941
|
||||
|
||||
## v2.5.2 (2014-10-10)
|
||||
|
||||
* Fix receiving large text fields #922
|
||||
|
||||
## v2.5.1 (2014-09-22)
|
||||
|
||||
* Fix `pool.end` race conditions #915
|
||||
* Fix `pool.getConnection` race conditions
|
||||
|
||||
## v2.5.0 (2014-09-07)
|
||||
|
||||
* Add code `POOL_ENQUEUELIMIT` to error reaching `queueLimit`
|
||||
* Add `enqueue` event to pool #716
|
||||
* Add `enqueue` event to protocol and connection #381
|
||||
* Blacklist unsupported connection flags #881
|
||||
* Make only column names enumerable in `RowDataPacket` #549 #895
|
||||
* Support Node.js 0.6 #718
|
||||
|
||||
## v2.4.3 (2014-08-25)
|
||||
|
||||
* Fix `pool.query` to use `typeCast` configuration
|
||||
|
||||
## v2.4.2 (2014-08-03)
|
||||
|
||||
* Fix incorrect sequence packet errors to be catchable #867
|
||||
* Fix stray protocol packet errors to be catchable #867
|
||||
* Fix timing of fatal protocol errors bubbling to user #879
|
||||
|
||||
## v2.4.1 (2014-07-17)
|
||||
|
||||
* Fix `pool.query` not invoking callback on connection error #872
|
||||
|
||||
## v2.4.0 (2014-07-13)
|
||||
|
||||
* Add code `POOL_NOEXIST` in PoolCluster error #846
|
||||
* Add `acquireTimeout` pool option to specify a timeout for acquiring a connection #821 #854
|
||||
* Add `connection.escapeId`
|
||||
* Add `pool.escapeId`
|
||||
* Add `timeout` option to all sequences #855 #863
|
||||
* Default `connectTimeout` to 10 seconds
|
||||
* Fix domain binding with `conn.connect`
|
||||
* Fix `packet.default` to actually be a string
|
||||
* Fix `PARSER_*` errors to be catchable
|
||||
* Fix `PROTOCOL_PACKETS_OUT_OF_ORDER` error to be catchable #844
|
||||
* Include packets that failed parsing under `debug`
|
||||
* Return `Query` object from `pool.query` like `conn.query` #830
|
||||
* Use `EventEmitter.listenerCount` when possible for faster counting
|
||||
|
||||
## v2.3.2 (2014-05-29)
|
||||
|
||||
* Fix pool leaking connections after `conn.changeUser` #833
|
||||
|
||||
## v2.3.1 (2014-05-26)
|
||||
|
||||
* Add database errors to error constants
|
||||
* Add global errors to error constants
|
||||
* Throw when calling `conn.release` multiple times #824 #827
|
||||
* Update known error codes
|
||||
|
||||
## v2.3.0 (2014-05-16)
|
||||
|
||||
* Accept MySQL charset (like `UTF8` or `UTF8MB4`) in `charset` option #808
|
||||
* Accept pool options in connection string to `mysql.createPool` #811
|
||||
* Clone connection config for new pool connections
|
||||
* Default `connectTimeout` to 2 minutes
|
||||
* Reject unauthorized SSL connections (use `ssl.rejectUnauthorized` to override) #816
|
||||
* Return last error when PoolCluster exhausts connection retries #818
|
||||
* Remove connection from pool after `conn.changeUser` is released #806
|
||||
* Throw on unknown SSL profile name #817
|
||||
* User newer TLS functions when available #809
|
||||
|
||||
## v2.2.0 (2014-04-27)
|
||||
|
||||
* Use indexOf instead of for loops removing conn from pool #611
|
||||
* Make callback to `pool.query` optional like `conn.query` #585
|
||||
* Prevent enqueuing sequences after fatal error #400
|
||||
* Fix geometry parser for empty fields #742
|
||||
* Accept lower-case charset option
|
||||
* Throw on unknown charset option #789
|
||||
* Update known charsets
|
||||
* Remove console.warn from PoolCluster #744
|
||||
* Fix `pool.end` to handle queued connections #797
|
||||
* Fix `pool.releaseConnection` to keep connection queue flowing #797
|
||||
* Fix SSL handshake error to be catchable #800
|
||||
* Add `connection.threadId` to get MySQL connection ID #602
|
||||
* Ensure `pool.getConnection` retrieves good connections #434 #557 #778
|
||||
* Fix pool cluster wildcard matching #627
|
||||
* Pass query values through to `SqlString.format` #590
|
||||
|
||||
## v2.1.1 (2014-03-13)
|
||||
|
||||
* fix authentication w/password failure for node.js 0.10.5 #746 #752
|
||||
* fix authentication w/password TypeError exception for node.js 0.10.0-0.10.4 #747
|
||||
* fix specifying `values` in `conn.query({...}).on(...)` pattern #755
|
||||
* fix long stack trace to include the `pool.query(...)` call #715
|
||||
|
||||
## v2.1.0 (2014-02-20)
|
||||
|
||||
* crypto.createHash fix for node.js < 11 #735
|
||||
* Add `connectTimeout` option to specify a timeout for establishing a connection #726
|
||||
* SSL support #481
|
||||
|
||||
## v2.0.1
|
||||
|
||||
* internal parser speed improvement #702
|
||||
* domains support
|
||||
* 'trace' connection option to control if long stack traces are generated #713 #710 #439
|
||||
|
||||
## v2.0.0 (2014-01-09)
|
||||
|
||||
* stream improvements:
|
||||
- node 0.8 support #692
|
||||
- Emit 'close' events from query streams #688
|
||||
* encoding fix in streaming LOAD DATA LOCAL INFILE #670
|
||||
* Doc improvements
|
||||
|
||||
## v2.0.0-rc2 (2013-12-07)
|
||||
|
||||
* Streaming LOAD DATA LOCAL INFILE #668
|
||||
* Doc improvements
|
||||
|
||||
## v2.0.0-rc1 (2013-11-30)
|
||||
|
||||
* Transaction support
|
||||
* Expose SqlString.format as mysql.format()
|
||||
* Many bug fixes
|
||||
* Better support for dates in local time zone
|
||||
* Doc improvements
|
||||
|
||||
## v2.0.0-alpha9 (2013-08-27)
|
||||
|
||||
* Add query to pool to execute queries directly using the pool
|
||||
* Add `sqlState` property to `Error` objects #556
|
||||
* Pool option to set queue limit
|
||||
* Pool sends 'connection' event when it opens a new connection
|
||||
* Added stringifyObjects option to treat input as strings rather than objects (#501)
|
||||
* Support for poolClusters
|
||||
* Datetime improvements
|
||||
* Bug fixes
|
||||
|
||||
## v2.0.0-alpha8 (2013-04-30)
|
||||
|
||||
* Switch to old mode for Streams 2 (Node.js v 0.10.x)
|
||||
* Add stream method to Query Wraps events from the query object into a node v0.10.x Readable stream
|
||||
* DECIMAL should also be treated as big number
|
||||
* Removed slow unnecessary stack access
|
||||
* Added charsets
|
||||
* Added bigNumberStrings option for forcing BIGINT columns as strings
|
||||
* Changes date parsing to return String if not a valid JS Date
|
||||
* Adds support for ?? escape sequence to escape identifiers
|
||||
* Changes Auth.token() to force password to be in binary, not utf8 (#378)
|
||||
* Restrict debugging by packet types
|
||||
* Add 'multipleStatements' option tracking to ConnectionConfig. Fixes GH-408
|
||||
* Changes Pool to handle 'error' events and dispose connection
|
||||
* Allows db.query({ sql: "..." }, [ val1, ... ], cb); (#390)
|
||||
* Improved documentation
|
||||
* Bug fixes
|
||||
|
||||
## v2.0.0-alpha7 (2013-02-03)
|
||||
|
||||
* Add connection pooling (#351)
|
||||
|
||||
## v2.0.0-alpha6 (2013-01-31)
|
||||
|
||||
* Add supportBigNumbers option (#381, #382)
|
||||
* Accept prebuilt Query object in connection.query
|
||||
* Bug fixes
|
||||
|
||||
## v2.0.0-alpha5 (2012-12-03)
|
||||
|
||||
* Add mysql.escapeId to escape identifiers (closes #342)
|
||||
* Allow custom escaping mode (config.queryFormat)
|
||||
* Convert DATE columns to configured timezone instead of UTC (#332)
|
||||
* Convert LONGLONG and NEWDECIMAL to numbers (#333)
|
||||
* Fix Connection.escape() (fixes #330)
|
||||
* Changed Readme ambiguity about custom type cast fallback
|
||||
* Change typeCast to receive Connection instead of Connection.config.timezone
|
||||
* Fix drain event having useless err parameter
|
||||
* Add Connection.statistics() back from v0.9
|
||||
* Add Connection.ping() back from v0.9
|
||||
|
||||
## v2.0.0-alpha4 (2012-10-03)
|
||||
|
||||
* Fix some OOB errors on resume()
|
||||
* Fix quick pause() / resume() usage
|
||||
* Properly parse host denied / similar errors
|
||||
* Add Connection.ChangeUser functionality
|
||||
* Make sure changeUser errors are fatal
|
||||
* Enable formatting nested arrays for bulk inserts
|
||||
* Add Connection.escape functionality
|
||||
* Renamed 'close' to 'end' event
|
||||
* Return parsed object instead of Buffer for GEOMETRY types
|
||||
* Allow nestTables inline (using a string instead of a boolean)
|
||||
* Check for ZEROFILL_FLAG and format number accordingly
|
||||
* Add timezone support (default: local)
|
||||
* Add custom typeCast functionality
|
||||
* Export mysql column types
|
||||
* Add connection flags functionality (#237)
|
||||
* Exports drain event when queue finishes processing (#272, #271, #306)
|
||||
|
||||
## v2.0.0-alpha3 (2012-06-12)
|
||||
|
||||
* Implement support for `LOAD DATA LOCAL INFILE` queries (#182).
|
||||
* Support OLD\_PASSWORD() accounts like 0.9.x did. You should still upgrade any
|
||||
user accounts in your your MySQL user table that has short (16 byte) Password
|
||||
values. Connecting to those accounts is not secure. (#204)
|
||||
* Ignore function values when escaping objects, allows to use RowDataPacket
|
||||
objects as query arguments. (Alex Gorbatchev, #213)
|
||||
* Handle initial error packets from server such as `ER_HOST_NOT_PRIVILEGED`.
|
||||
* Treat `utf8\_bin` as a String, not Buffer. (#214)
|
||||
* Handle empty strings in first row column value. (#222)
|
||||
* Honor Connection#nestTables setting for queries. (#221)
|
||||
* Remove `CLIENT_INTERACTIVE` flag from config. Improves #225.
|
||||
* Improve docs for connections settings.
|
||||
* Implement url string support for Connection configs.
|
||||
|
||||
## v2.0.0-alpha2 (2012-05-31)
|
||||
|
||||
* Specify escaping before for NaN / Infinity (they are as unquoted constants).
|
||||
* Support for unix domain socket connections (use: {socketPath: '...'}).
|
||||
* Fix type casting for NULL values for Date/Number fields
|
||||
* Add `fields` argument to `query()` as well as `'fields'` event. This is
|
||||
similar to what was available in 0.9.x.
|
||||
* Support connecting to the sphinx searchd daemon as well as MariaDB (#199).
|
||||
* Implement long stack trace support, will be removed / disabled if the node
|
||||
core ever supports it natively.
|
||||
* Implement `nestTables` option for queries, allows fetching JOIN result sets
|
||||
with overlapping column names.
|
||||
* Fix ? placeholder mechanism for values containing '?' characters (#205).
|
||||
* Detect when `connect()` is called more than once on a connection and provide
|
||||
the user with a good error message for it (#204).
|
||||
* Switch to `UTF8_GENERAL_CI` (previously `UTF8_UNICODE_CI`) as the default
|
||||
charset for all connections to avoid strange MySQL performance issues (#200),
|
||||
and also make the charset user configurable.
|
||||
* Fix BLOB type casting for `TINY_BLOB`, `MEDIUM_BLOB` and `LONG_BLOB`.
|
||||
* Add support for sending and receiving large (> 16 MB) packets.
|
||||
|
||||
## v2.0.0-alpha (2012-05-15)
|
||||
|
||||
This release is a rewrite. You should carefully test your application after
|
||||
upgrading to avoid problems. This release features many improvements, most
|
||||
importantly:
|
||||
|
||||
* ~5x faster than v0.9.x for parsing query results
|
||||
* Support for pause() / resume() (for streaming rows)
|
||||
* Support for multiple statement queries
|
||||
* Support for stored procedures
|
||||
* Support for transactions
|
||||
* Support for binary columns (as blobs)
|
||||
* Consistent & well documented error handling
|
||||
* A new Connection class that has well defined semantics (unlike the old Client class).
|
||||
* Convenient escaping of objects / arrays that allows for simpler query construction
|
||||
* A significantly simpler code base
|
||||
* Many bug fixes & other small improvements (Closed 62 out of 66 GitHub issues)
|
||||
|
||||
Below are a few notes on the upgrade process itself:
|
||||
|
||||
The first thing you will run into is that the old `Client` class is gone and
|
||||
has been replaced with a less ambitious `Connection` class. So instead of
|
||||
`mysql.createClient()`, you now have to:
|
||||
|
||||
```js
|
||||
var mysql = require('mysql');
|
||||
var connection = mysql.createConnection({
|
||||
host : 'localhost',
|
||||
user : 'me',
|
||||
password : 'secret',
|
||||
});
|
||||
|
||||
connection.query('SELECT 1', function(err, rows) {
|
||||
if (err) throw err;
|
||||
|
||||
console.log('Query result: ', rows);
|
||||
});
|
||||
|
||||
connection.end();
|
||||
```
|
||||
|
||||
The new `Connection` class does not try to handle re-connects, please study the
|
||||
`Server disconnects` section in the new Readme.
|
||||
|
||||
Other than that, the interface has stayed very similar. Here are a few things
|
||||
to check out so:
|
||||
|
||||
* BIGINT's are now cast into strings
|
||||
* Binary data is now cast to buffers
|
||||
* The `'row'` event on the `Query` object is now called `'result'` and will
|
||||
also be emitted for queries that produce an OK/Error response.
|
||||
* Error handling is consistently defined now, check the Readme
|
||||
* Escaping has become more powerful which may break your code if you are
|
||||
currently using objects to fill query placeholders.
|
||||
* Connections can now be established explicitly again, so you may wish to do so
|
||||
if you want to handle connection errors specifically.
|
||||
|
||||
That should be most of it, if you run into anything else, please send a patch
|
||||
or open an issue to improve this document.
|
||||
|
||||
## v0.9.6 (2012-03-12)
|
||||
|
||||
* Escape array values so they produce sql arrays (Roger Castells, Colin Smith)
|
||||
* docs: mention mysql transaction stop gap solution (Blake Miner)
|
||||
* docs: Mention affectedRows in FAQ (Michael Baldwin)
|
||||
|
||||
## v0.9.5 (2011-11-26)
|
||||
|
||||
* Fix #142 Driver stalls upon reconnect attempt that's immediately closed
|
||||
* Add travis build
|
||||
* Switch to urun as a test runner
|
||||
* Switch to utest for unit tests
|
||||
* Remove fast-or-slow dependency for tests
|
||||
* Split integration tests into individual files again
|
||||
|
||||
## v0.9.4 (2011-08-31)
|
||||
|
||||
* Expose package.json as `mysql.PACKAGE` (#104)
|
||||
|
||||
## v0.9.3 (2011-08-22)
|
||||
|
||||
* Set default `client.user` to root
|
||||
* Fix #91: Client#format should not mutate params array
|
||||
* Fix #94: TypeError in client.js
|
||||
* Parse decimals as string (vadimg)
|
||||
|
||||
## v0.9.2 (2011-08-07)
|
||||
|
||||
* The underlaying socket connection is now managed implicitly rather than explicitly.
|
||||
* Check the [upgrading guide][] for a full list of changes.
|
||||
|
||||
## v0.9.1 (2011-02-20)
|
||||
|
||||
* Fix issue #49 / `client.escape()` throwing exceptions on objects. (Nick Payne)
|
||||
* Drop < v0.4.x compatibility. From now on you need node v0.4.x to use this module.
|
||||
|
||||
## Older releases
|
||||
|
||||
These releases were done before maintaining this file:
|
||||
|
||||
* [v0.9.0](https://github.com/mysqljs/mysql/compare/v0.8.0...v0.9.0)
|
||||
(2011-01-04)
|
||||
* [v0.8.0](https://github.com/mysqljs/mysql/compare/v0.7.0...v0.8.0)
|
||||
(2010-10-30)
|
||||
* [v0.7.0](https://github.com/mysqljs/mysql/compare/v0.6.0...v0.7.0)
|
||||
(2010-10-14)
|
||||
* [v0.6.0](https://github.com/mysqljs/mysql/compare/v0.5.0...v0.6.0)
|
||||
(2010-09-28)
|
||||
* [v0.5.0](https://github.com/mysqljs/mysql/compare/v0.4.0...v0.5.0)
|
||||
(2010-09-17)
|
||||
* [v0.4.0](https://github.com/mysqljs/mysql/compare/v0.3.0...v0.4.0)
|
||||
(2010-09-02)
|
||||
* [v0.3.0](https://github.com/mysqljs/mysql/compare/v0.2.0...v0.3.0)
|
||||
(2010-08-25)
|
||||
* [v0.2.0](https://github.com/mysqljs/mysql/compare/v0.1.0...v0.2.0)
|
||||
(2010-08-22)
|
||||
* [v0.1.0](https://github.com/mysqljs/mysql/commits/v0.1.0)
|
||||
(2010-08-22)
|
||||
19
node_modules/mysql/License
generated
vendored
Normal file
19
node_modules/mysql/License
generated
vendored
Normal file
@ -0,0 +1,19 @@
|
||||
Copyright (c) 2012 Felix Geisendörfer (felix@debuggable.com) and contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
1548
node_modules/mysql/Readme.md
generated
vendored
Normal file
1548
node_modules/mysql/Readme.md
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
161
node_modules/mysql/index.js
generated
vendored
Normal file
161
node_modules/mysql/index.js
generated
vendored
Normal file
@ -0,0 +1,161 @@
|
||||
var Classes = Object.create(null);
|
||||
|
||||
/**
|
||||
* Create a new Connection instance.
|
||||
* @param {object|string} config Configuration or connection string for new MySQL connection
|
||||
* @return {Connection} A new MySQL connection
|
||||
* @public
|
||||
*/
|
||||
exports.createConnection = function createConnection(config) {
|
||||
var Connection = loadClass('Connection');
|
||||
var ConnectionConfig = loadClass('ConnectionConfig');
|
||||
|
||||
return new Connection({config: new ConnectionConfig(config)});
|
||||
};
|
||||
|
||||
/**
|
||||
* Create a new Pool instance.
|
||||
* @param {object|string} config Configuration or connection string for new MySQL connections
|
||||
* @return {Pool} A new MySQL pool
|
||||
* @public
|
||||
*/
|
||||
exports.createPool = function createPool(config) {
|
||||
var Pool = loadClass('Pool');
|
||||
var PoolConfig = loadClass('PoolConfig');
|
||||
|
||||
return new Pool({config: new PoolConfig(config)});
|
||||
};
|
||||
|
||||
/**
|
||||
* Create a new PoolCluster instance.
|
||||
* @param {object} [config] Configuration for pool cluster
|
||||
* @return {PoolCluster} New MySQL pool cluster
|
||||
* @public
|
||||
*/
|
||||
exports.createPoolCluster = function createPoolCluster(config) {
|
||||
var PoolCluster = loadClass('PoolCluster');
|
||||
|
||||
return new PoolCluster(config);
|
||||
};
|
||||
|
||||
/**
|
||||
* Create a new Query instance.
|
||||
* @param {string} sql The SQL for the query
|
||||
* @param {array} [values] Any values to insert into placeholders in sql
|
||||
* @param {function} [callback] The callback to use when query is complete
|
||||
* @return {Query} New query object
|
||||
* @public
|
||||
*/
|
||||
exports.createQuery = function createQuery(sql, values, callback) {
|
||||
var Connection = loadClass('Connection');
|
||||
|
||||
return Connection.createQuery(sql, values, callback);
|
||||
};
|
||||
|
||||
/**
|
||||
* Escape a value for SQL.
|
||||
* @param {*} value The value to escape
|
||||
* @param {boolean} [stringifyObjects=false] Setting if objects should be stringified
|
||||
* @param {string} [timeZone=local] Setting for time zone to use for Date conversion
|
||||
* @return {string} Escaped string value
|
||||
* @public
|
||||
*/
|
||||
exports.escape = function escape(value, stringifyObjects, timeZone) {
|
||||
var SqlString = loadClass('SqlString');
|
||||
|
||||
return SqlString.escape(value, stringifyObjects, timeZone);
|
||||
};
|
||||
|
||||
/**
|
||||
* Escape an identifier for SQL.
|
||||
* @param {*} value The value to escape
|
||||
* @param {boolean} [forbidQualified=false] Setting to treat '.' as part of identifier
|
||||
* @return {string} Escaped string value
|
||||
* @public
|
||||
*/
|
||||
exports.escapeId = function escapeId(value, forbidQualified) {
|
||||
var SqlString = loadClass('SqlString');
|
||||
|
||||
return SqlString.escapeId(value, forbidQualified);
|
||||
};
|
||||
|
||||
/**
|
||||
* Format SQL and replacement values into a SQL string.
|
||||
* @param {string} sql The SQL for the query
|
||||
* @param {array} [values] Any values to insert into placeholders in sql
|
||||
* @param {boolean} [stringifyObjects=false] Setting if objects should be stringified
|
||||
* @param {string} [timeZone=local] Setting for time zone to use for Date conversion
|
||||
* @return {string} Formatted SQL string
|
||||
* @public
|
||||
*/
|
||||
exports.format = function format(sql, values, stringifyObjects, timeZone) {
|
||||
var SqlString = loadClass('SqlString');
|
||||
|
||||
return SqlString.format(sql, values, stringifyObjects, timeZone);
|
||||
};
|
||||
|
||||
/**
|
||||
* Wrap raw SQL strings from escape overriding.
|
||||
* @param {string} sql The raw SQL
|
||||
* @return {object} Wrapped object
|
||||
* @public
|
||||
*/
|
||||
exports.raw = function raw(sql) {
|
||||
var SqlString = loadClass('SqlString');
|
||||
|
||||
return SqlString.raw(sql);
|
||||
};
|
||||
|
||||
/**
|
||||
* The type constants.
|
||||
* @public
|
||||
*/
|
||||
Object.defineProperty(exports, 'Types', {
|
||||
get: loadClass.bind(null, 'Types')
|
||||
});
|
||||
|
||||
/**
|
||||
* Load the given class.
|
||||
* @param {string} className Name of class to default
|
||||
* @return {function|object} Class constructor or exports
|
||||
* @private
|
||||
*/
|
||||
function loadClass(className) {
|
||||
var Class = Classes[className];
|
||||
|
||||
if (Class !== undefined) {
|
||||
return Class;
|
||||
}
|
||||
|
||||
// This uses a switch for static require analysis
|
||||
switch (className) {
|
||||
case 'Connection':
|
||||
Class = require('./lib/Connection');
|
||||
break;
|
||||
case 'ConnectionConfig':
|
||||
Class = require('./lib/ConnectionConfig');
|
||||
break;
|
||||
case 'Pool':
|
||||
Class = require('./lib/Pool');
|
||||
break;
|
||||
case 'PoolCluster':
|
||||
Class = require('./lib/PoolCluster');
|
||||
break;
|
||||
case 'PoolConfig':
|
||||
Class = require('./lib/PoolConfig');
|
||||
break;
|
||||
case 'SqlString':
|
||||
Class = require('./lib/protocol/SqlString');
|
||||
break;
|
||||
case 'Types':
|
||||
Class = require('./lib/protocol/constants/types');
|
||||
break;
|
||||
default:
|
||||
throw new Error('Cannot find class \'' + className + '\'');
|
||||
}
|
||||
|
||||
// Store to prevent invoking require()
|
||||
Classes[className] = Class;
|
||||
|
||||
return Class;
|
||||
}
|
||||
529
node_modules/mysql/lib/Connection.js
generated
vendored
Normal file
529
node_modules/mysql/lib/Connection.js
generated
vendored
Normal file
@ -0,0 +1,529 @@
|
||||
var Crypto = require('crypto');
|
||||
var Events = require('events');
|
||||
var Net = require('net');
|
||||
var tls = require('tls');
|
||||
var ConnectionConfig = require('./ConnectionConfig');
|
||||
var Protocol = require('./protocol/Protocol');
|
||||
var SqlString = require('./protocol/SqlString');
|
||||
var Query = require('./protocol/sequences/Query');
|
||||
var Util = require('util');
|
||||
|
||||
module.exports = Connection;
|
||||
Util.inherits(Connection, Events.EventEmitter);
|
||||
function Connection(options) {
|
||||
Events.EventEmitter.call(this);
|
||||
|
||||
this.config = options.config;
|
||||
|
||||
this._socket = options.socket;
|
||||
this._protocol = new Protocol({config: this.config, connection: this});
|
||||
this._connectCalled = false;
|
||||
this.state = 'disconnected';
|
||||
this.threadId = null;
|
||||
}
|
||||
|
||||
Connection.createQuery = function createQuery(sql, values, callback) {
|
||||
if (sql instanceof Query) {
|
||||
return sql;
|
||||
}
|
||||
|
||||
var cb = callback;
|
||||
var options = {};
|
||||
|
||||
if (typeof sql === 'function') {
|
||||
cb = sql;
|
||||
} else if (typeof sql === 'object') {
|
||||
options = Object.create(sql);
|
||||
|
||||
if (typeof values === 'function') {
|
||||
cb = values;
|
||||
} else if (values !== undefined) {
|
||||
Object.defineProperty(options, 'values', { value: values });
|
||||
}
|
||||
} else {
|
||||
options.sql = sql;
|
||||
|
||||
if (typeof values === 'function') {
|
||||
cb = values;
|
||||
} else if (values !== undefined) {
|
||||
options.values = values;
|
||||
}
|
||||
}
|
||||
|
||||
if (cb !== undefined) {
|
||||
cb = wrapCallbackInDomain(null, cb);
|
||||
|
||||
if (cb === undefined) {
|
||||
throw new TypeError('argument callback must be a function when provided');
|
||||
}
|
||||
}
|
||||
|
||||
return new Query(options, cb);
|
||||
};
|
||||
|
||||
Connection.prototype.connect = function connect(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
if (!this._connectCalled) {
|
||||
this._connectCalled = true;
|
||||
|
||||
// Connect either via a UNIX domain socket or a TCP socket.
|
||||
this._socket = (this.config.socketPath)
|
||||
? Net.createConnection(this.config.socketPath)
|
||||
: Net.createConnection(this.config.port, this.config.host);
|
||||
|
||||
// Connect socket to connection domain
|
||||
if (Events.usingDomains) {
|
||||
this._socket.domain = this.domain;
|
||||
}
|
||||
|
||||
var connection = this;
|
||||
this._protocol.on('data', function(data) {
|
||||
connection._socket.write(data);
|
||||
});
|
||||
this._socket.on('data', wrapToDomain(connection, function (data) {
|
||||
connection._protocol.write(data);
|
||||
}));
|
||||
this._protocol.on('end', function() {
|
||||
connection._socket.end();
|
||||
});
|
||||
this._socket.on('end', wrapToDomain(connection, function () {
|
||||
connection._protocol.end();
|
||||
}));
|
||||
|
||||
this._socket.on('error', this._handleNetworkError.bind(this));
|
||||
this._socket.on('connect', this._handleProtocolConnect.bind(this));
|
||||
this._protocol.on('handshake', this._handleProtocolHandshake.bind(this));
|
||||
this._protocol.on('initialize', this._handleProtocolInitialize.bind(this));
|
||||
this._protocol.on('unhandledError', this._handleProtocolError.bind(this));
|
||||
this._protocol.on('drain', this._handleProtocolDrain.bind(this));
|
||||
this._protocol.on('end', this._handleProtocolEnd.bind(this));
|
||||
this._protocol.on('enqueue', this._handleProtocolEnqueue.bind(this));
|
||||
|
||||
if (this.config.connectTimeout) {
|
||||
var handleConnectTimeout = this._handleConnectTimeout.bind(this);
|
||||
|
||||
this._socket.setTimeout(this.config.connectTimeout, handleConnectTimeout);
|
||||
this._socket.once('connect', function() {
|
||||
this.setTimeout(0, handleConnectTimeout);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
this._protocol.handshake(options, wrapCallbackInDomain(this, callback));
|
||||
};
|
||||
|
||||
Connection.prototype.changeUser = function changeUser(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
this._implyConnect();
|
||||
|
||||
var charsetNumber = (options.charset)
|
||||
? ConnectionConfig.getCharsetNumber(options.charset)
|
||||
: this.config.charsetNumber;
|
||||
|
||||
return this._protocol.changeUser({
|
||||
user : options.user || this.config.user,
|
||||
password : options.password || this.config.password,
|
||||
database : options.database || this.config.database,
|
||||
timeout : options.timeout,
|
||||
charsetNumber : charsetNumber,
|
||||
currentConfig : this.config
|
||||
}, wrapCallbackInDomain(this, callback));
|
||||
};
|
||||
|
||||
Connection.prototype.beginTransaction = function beginTransaction(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
options = options || {};
|
||||
options.sql = 'START TRANSACTION';
|
||||
options.values = null;
|
||||
|
||||
return this.query(options, callback);
|
||||
};
|
||||
|
||||
Connection.prototype.commit = function commit(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
options = options || {};
|
||||
options.sql = 'COMMIT';
|
||||
options.values = null;
|
||||
|
||||
return this.query(options, callback);
|
||||
};
|
||||
|
||||
Connection.prototype.rollback = function rollback(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
options = options || {};
|
||||
options.sql = 'ROLLBACK';
|
||||
options.values = null;
|
||||
|
||||
return this.query(options, callback);
|
||||
};
|
||||
|
||||
Connection.prototype.query = function query(sql, values, cb) {
|
||||
var query = Connection.createQuery(sql, values, cb);
|
||||
query._connection = this;
|
||||
|
||||
if (!(typeof sql === 'object' && 'typeCast' in sql)) {
|
||||
query.typeCast = this.config.typeCast;
|
||||
}
|
||||
|
||||
if (query.sql) {
|
||||
query.sql = this.format(query.sql, query.values);
|
||||
}
|
||||
|
||||
if (query._callback) {
|
||||
query._callback = wrapCallbackInDomain(this, query._callback);
|
||||
}
|
||||
|
||||
this._implyConnect();
|
||||
|
||||
return this._protocol._enqueue(query);
|
||||
};
|
||||
|
||||
Connection.prototype.ping = function ping(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
this._implyConnect();
|
||||
this._protocol.ping(options, wrapCallbackInDomain(this, callback));
|
||||
};
|
||||
|
||||
Connection.prototype.statistics = function statistics(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
this._implyConnect();
|
||||
this._protocol.stats(options, wrapCallbackInDomain(this, callback));
|
||||
};
|
||||
|
||||
Connection.prototype.end = function end(options, callback) {
|
||||
var cb = callback;
|
||||
var opts = options;
|
||||
|
||||
if (!callback && typeof options === 'function') {
|
||||
cb = options;
|
||||
opts = null;
|
||||
}
|
||||
|
||||
// create custom options reference
|
||||
opts = Object.create(opts || null);
|
||||
|
||||
if (opts.timeout === undefined) {
|
||||
// default timeout of 30 seconds
|
||||
opts.timeout = 30000;
|
||||
}
|
||||
|
||||
this._implyConnect();
|
||||
this._protocol.quit(opts, wrapCallbackInDomain(this, cb));
|
||||
};
|
||||
|
||||
Connection.prototype.destroy = function() {
|
||||
this.state = 'disconnected';
|
||||
this._implyConnect();
|
||||
this._socket.destroy();
|
||||
this._protocol.destroy();
|
||||
};
|
||||
|
||||
Connection.prototype.pause = function() {
|
||||
this._socket.pause();
|
||||
this._protocol.pause();
|
||||
};
|
||||
|
||||
Connection.prototype.resume = function() {
|
||||
this._socket.resume();
|
||||
this._protocol.resume();
|
||||
};
|
||||
|
||||
Connection.prototype.escape = function(value) {
|
||||
return SqlString.escape(value, false, this.config.timezone);
|
||||
};
|
||||
|
||||
Connection.prototype.escapeId = function escapeId(value) {
|
||||
return SqlString.escapeId(value, false);
|
||||
};
|
||||
|
||||
Connection.prototype.format = function(sql, values) {
|
||||
if (typeof this.config.queryFormat === 'function') {
|
||||
return this.config.queryFormat.call(this, sql, values, this.config.timezone);
|
||||
}
|
||||
return SqlString.format(sql, values, this.config.stringifyObjects, this.config.timezone);
|
||||
};
|
||||
|
||||
if (tls.TLSSocket) {
|
||||
// 0.11+ environment
|
||||
Connection.prototype._startTLS = function _startTLS(onSecure) {
|
||||
var connection = this;
|
||||
|
||||
createSecureContext(this.config, function (err, secureContext) {
|
||||
if (err) {
|
||||
onSecure(err);
|
||||
return;
|
||||
}
|
||||
|
||||
// "unpipe"
|
||||
connection._socket.removeAllListeners('data');
|
||||
connection._protocol.removeAllListeners('data');
|
||||
|
||||
// socket <-> encrypted
|
||||
var rejectUnauthorized = connection.config.ssl.rejectUnauthorized;
|
||||
var secureEstablished = false;
|
||||
var secureSocket = new tls.TLSSocket(connection._socket, {
|
||||
rejectUnauthorized : rejectUnauthorized,
|
||||
requestCert : true,
|
||||
secureContext : secureContext,
|
||||
isServer : false
|
||||
});
|
||||
|
||||
// error handler for secure socket
|
||||
secureSocket.on('_tlsError', function(err) {
|
||||
if (secureEstablished) {
|
||||
connection._handleNetworkError(err);
|
||||
} else {
|
||||
onSecure(err);
|
||||
}
|
||||
});
|
||||
|
||||
// cleartext <-> protocol
|
||||
secureSocket.pipe(connection._protocol);
|
||||
connection._protocol.on('data', function(data) {
|
||||
secureSocket.write(data);
|
||||
});
|
||||
|
||||
secureSocket.on('secure', function() {
|
||||
secureEstablished = true;
|
||||
|
||||
onSecure(rejectUnauthorized ? this.ssl.verifyError() : null);
|
||||
});
|
||||
|
||||
// start TLS communications
|
||||
secureSocket._start();
|
||||
});
|
||||
};
|
||||
} else {
|
||||
// pre-0.11 environment
|
||||
Connection.prototype._startTLS = function _startTLS(onSecure) {
|
||||
// before TLS:
|
||||
// _socket <-> _protocol
|
||||
// after:
|
||||
// _socket <-> securePair.encrypted <-> securePair.cleartext <-> _protocol
|
||||
|
||||
var connection = this;
|
||||
var credentials = Crypto.createCredentials({
|
||||
ca : this.config.ssl.ca,
|
||||
cert : this.config.ssl.cert,
|
||||
ciphers : this.config.ssl.ciphers,
|
||||
key : this.config.ssl.key,
|
||||
passphrase : this.config.ssl.passphrase
|
||||
});
|
||||
|
||||
var rejectUnauthorized = this.config.ssl.rejectUnauthorized;
|
||||
var secureEstablished = false;
|
||||
var securePair = tls.createSecurePair(credentials, false, true, rejectUnauthorized);
|
||||
|
||||
// error handler for secure pair
|
||||
securePair.on('error', function(err) {
|
||||
if (secureEstablished) {
|
||||
connection._handleNetworkError(err);
|
||||
} else {
|
||||
onSecure(err);
|
||||
}
|
||||
});
|
||||
|
||||
// "unpipe"
|
||||
this._socket.removeAllListeners('data');
|
||||
this._protocol.removeAllListeners('data');
|
||||
|
||||
// socket <-> encrypted
|
||||
securePair.encrypted.pipe(this._socket);
|
||||
this._socket.on('data', function(data) {
|
||||
securePair.encrypted.write(data);
|
||||
});
|
||||
|
||||
// cleartext <-> protocol
|
||||
securePair.cleartext.pipe(this._protocol);
|
||||
this._protocol.on('data', function(data) {
|
||||
securePair.cleartext.write(data);
|
||||
});
|
||||
|
||||
// secure established
|
||||
securePair.on('secure', function() {
|
||||
secureEstablished = true;
|
||||
|
||||
if (!rejectUnauthorized) {
|
||||
onSecure();
|
||||
return;
|
||||
}
|
||||
|
||||
var verifyError = this.ssl.verifyError();
|
||||
var err = verifyError;
|
||||
|
||||
// node.js 0.6 support
|
||||
if (typeof err === 'string') {
|
||||
err = new Error(verifyError);
|
||||
err.code = verifyError;
|
||||
}
|
||||
|
||||
onSecure(err);
|
||||
});
|
||||
|
||||
// node.js 0.8 bug
|
||||
securePair._cycle = securePair.cycle;
|
||||
securePair.cycle = function cycle() {
|
||||
if (this.ssl && this.ssl.error) {
|
||||
this.error();
|
||||
}
|
||||
|
||||
return this._cycle.apply(this, arguments);
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
Connection.prototype._handleConnectTimeout = function() {
|
||||
if (this._socket) {
|
||||
this._socket.setTimeout(0);
|
||||
this._socket.destroy();
|
||||
}
|
||||
|
||||
var err = new Error('connect ETIMEDOUT');
|
||||
err.errorno = 'ETIMEDOUT';
|
||||
err.code = 'ETIMEDOUT';
|
||||
err.syscall = 'connect';
|
||||
|
||||
this._handleNetworkError(err);
|
||||
};
|
||||
|
||||
Connection.prototype._handleNetworkError = function(err) {
|
||||
this._protocol.handleNetworkError(err);
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolError = function(err) {
|
||||
this.state = 'protocol_error';
|
||||
this.emit('error', err);
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolDrain = function() {
|
||||
this.emit('drain');
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolConnect = function() {
|
||||
this.state = 'connected';
|
||||
this.emit('connect');
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolHandshake = function _handleProtocolHandshake() {
|
||||
this.state = 'authenticated';
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolInitialize = function _handleProtocolInitialize(packet) {
|
||||
this.threadId = packet.threadId;
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolEnd = function(err) {
|
||||
this.state = 'disconnected';
|
||||
this.emit('end', err);
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolEnqueue = function _handleProtocolEnqueue(sequence) {
|
||||
this.emit('enqueue', sequence);
|
||||
};
|
||||
|
||||
Connection.prototype._implyConnect = function() {
|
||||
if (!this._connectCalled) {
|
||||
this.connect();
|
||||
}
|
||||
};
|
||||
|
||||
function createSecureContext (config, cb) {
|
||||
var context = null;
|
||||
var error = null;
|
||||
|
||||
try {
|
||||
context = tls.createSecureContext({
|
||||
ca : config.ssl.ca,
|
||||
cert : config.ssl.cert,
|
||||
ciphers : config.ssl.ciphers,
|
||||
key : config.ssl.key,
|
||||
passphrase : config.ssl.passphrase
|
||||
});
|
||||
} catch (err) {
|
||||
error = err;
|
||||
}
|
||||
|
||||
cb(error, context);
|
||||
}
|
||||
|
||||
function unwrapFromDomain(fn) {
|
||||
return function () {
|
||||
var domains = [];
|
||||
var ret;
|
||||
|
||||
while (process.domain) {
|
||||
domains.shift(process.domain);
|
||||
process.domain.exit();
|
||||
}
|
||||
|
||||
try {
|
||||
ret = fn.apply(this, arguments);
|
||||
} finally {
|
||||
for (var i = 0; i < domains.length; i++) {
|
||||
domains[i].enter();
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
};
|
||||
}
|
||||
|
||||
function wrapCallbackInDomain(ee, fn) {
|
||||
if (typeof fn !== 'function') {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (fn.domain) {
|
||||
return fn;
|
||||
}
|
||||
|
||||
var domain = process.domain;
|
||||
|
||||
if (domain) {
|
||||
return domain.bind(fn);
|
||||
} else if (ee) {
|
||||
return unwrapFromDomain(wrapToDomain(ee, fn));
|
||||
} else {
|
||||
return fn;
|
||||
}
|
||||
}
|
||||
|
||||
function wrapToDomain(ee, fn) {
|
||||
return function () {
|
||||
if (Events.usingDomains && ee.domain) {
|
||||
ee.domain.enter();
|
||||
fn.apply(this, arguments);
|
||||
ee.domain.exit();
|
||||
} else {
|
||||
fn.apply(this, arguments);
|
||||
}
|
||||
};
|
||||
}
|
||||
209
node_modules/mysql/lib/ConnectionConfig.js
generated
vendored
Normal file
209
node_modules/mysql/lib/ConnectionConfig.js
generated
vendored
Normal file
@ -0,0 +1,209 @@
|
||||
var urlParse = require('url').parse;
|
||||
var ClientConstants = require('./protocol/constants/client');
|
||||
var Charsets = require('./protocol/constants/charsets');
|
||||
var SSLProfiles = null;
|
||||
|
||||
module.exports = ConnectionConfig;
|
||||
function ConnectionConfig(options) {
|
||||
if (typeof options === 'string') {
|
||||
options = ConnectionConfig.parseUrl(options);
|
||||
}
|
||||
|
||||
this.host = options.host || 'localhost';
|
||||
this.port = options.port || 3306;
|
||||
this.localAddress = options.localAddress;
|
||||
this.socketPath = options.socketPath;
|
||||
this.user = options.user || undefined;
|
||||
this.password = options.password || undefined;
|
||||
this.database = options.database;
|
||||
this.connectTimeout = (options.connectTimeout === undefined)
|
||||
? (10 * 1000)
|
||||
: options.connectTimeout;
|
||||
this.insecureAuth = options.insecureAuth || false;
|
||||
this.supportBigNumbers = options.supportBigNumbers || false;
|
||||
this.bigNumberStrings = options.bigNumberStrings || false;
|
||||
this.dateStrings = options.dateStrings || false;
|
||||
this.debug = options.debug;
|
||||
this.trace = options.trace !== false;
|
||||
this.stringifyObjects = options.stringifyObjects || false;
|
||||
this.timezone = options.timezone || 'local';
|
||||
this.flags = options.flags || '';
|
||||
this.queryFormat = options.queryFormat;
|
||||
this.pool = options.pool || undefined;
|
||||
this.ssl = (typeof options.ssl === 'string')
|
||||
? ConnectionConfig.getSSLProfile(options.ssl)
|
||||
: (options.ssl || false);
|
||||
this.localInfile = (options.localInfile === undefined)
|
||||
? true
|
||||
: options.localInfile;
|
||||
this.multipleStatements = options.multipleStatements || false;
|
||||
this.typeCast = (options.typeCast === undefined)
|
||||
? true
|
||||
: options.typeCast;
|
||||
|
||||
if (this.timezone[0] === ' ') {
|
||||
// "+" is a url encoded char for space so it
|
||||
// gets translated to space when giving a
|
||||
// connection string..
|
||||
this.timezone = '+' + this.timezone.substr(1);
|
||||
}
|
||||
|
||||
if (this.ssl) {
|
||||
// Default rejectUnauthorized to true
|
||||
this.ssl.rejectUnauthorized = this.ssl.rejectUnauthorized !== false;
|
||||
}
|
||||
|
||||
this.maxPacketSize = 0;
|
||||
this.charsetNumber = (options.charset)
|
||||
? ConnectionConfig.getCharsetNumber(options.charset)
|
||||
: options.charsetNumber || Charsets.UTF8_GENERAL_CI;
|
||||
|
||||
// Set the client flags
|
||||
var defaultFlags = ConnectionConfig.getDefaultFlags(options);
|
||||
this.clientFlags = ConnectionConfig.mergeFlags(defaultFlags, options.flags);
|
||||
}
|
||||
|
||||
ConnectionConfig.mergeFlags = function mergeFlags(defaultFlags, userFlags) {
|
||||
var allFlags = ConnectionConfig.parseFlagList(defaultFlags);
|
||||
var newFlags = ConnectionConfig.parseFlagList(userFlags);
|
||||
|
||||
// Merge the new flags
|
||||
for (var flag in newFlags) {
|
||||
if (allFlags[flag] !== false) {
|
||||
allFlags[flag] = newFlags[flag];
|
||||
}
|
||||
}
|
||||
|
||||
// Build flags
|
||||
var flags = 0x0;
|
||||
for (var flag in allFlags) {
|
||||
if (allFlags[flag]) {
|
||||
// TODO: Throw here on some future release
|
||||
flags |= ClientConstants['CLIENT_' + flag] || 0x0;
|
||||
}
|
||||
}
|
||||
|
||||
return flags;
|
||||
};
|
||||
|
||||
ConnectionConfig.getCharsetNumber = function getCharsetNumber(charset) {
|
||||
var num = Charsets[charset.toUpperCase()];
|
||||
|
||||
if (num === undefined) {
|
||||
throw new TypeError('Unknown charset \'' + charset + '\'');
|
||||
}
|
||||
|
||||
return num;
|
||||
};
|
||||
|
||||
ConnectionConfig.getDefaultFlags = function getDefaultFlags(options) {
|
||||
var defaultFlags = [
|
||||
'-COMPRESS', // Compression protocol *NOT* supported
|
||||
'-CONNECT_ATTRS', // Does *NOT* send connection attributes in Protocol::HandshakeResponse41
|
||||
'+CONNECT_WITH_DB', // One can specify db on connect in Handshake Response Packet
|
||||
'+FOUND_ROWS', // Send found rows instead of affected rows
|
||||
'+IGNORE_SIGPIPE', // Don't issue SIGPIPE if network failures
|
||||
'+IGNORE_SPACE', // Let the parser ignore spaces before '('
|
||||
'+LOCAL_FILES', // Can use LOAD DATA LOCAL
|
||||
'+LONG_FLAG', // Longer flags in Protocol::ColumnDefinition320
|
||||
'+LONG_PASSWORD', // Use the improved version of Old Password Authentication
|
||||
'+MULTI_RESULTS', // Can handle multiple resultsets for COM_QUERY
|
||||
'+ODBC', // Special handling of ODBC behaviour
|
||||
'-PLUGIN_AUTH', // Does *NOT* support auth plugins
|
||||
'+PROTOCOL_41', // Uses the 4.1 protocol
|
||||
'+PS_MULTI_RESULTS', // Can handle multiple resultsets for COM_STMT_EXECUTE
|
||||
'+RESERVED', // Unused
|
||||
'+SECURE_CONNECTION', // Supports Authentication::Native41
|
||||
'+TRANSACTIONS' // Expects status flags
|
||||
];
|
||||
|
||||
if (options && options.localInfile !== undefined && !options.localInfile) {
|
||||
// Disable LOCAL modifier for LOAD DATA INFILE
|
||||
defaultFlags.push('-LOCAL_FILES');
|
||||
}
|
||||
|
||||
if (options && options.multipleStatements) {
|
||||
// May send multiple statements per COM_QUERY and COM_STMT_PREPARE
|
||||
defaultFlags.push('+MULTI_STATEMENTS');
|
||||
}
|
||||
|
||||
return defaultFlags;
|
||||
};
|
||||
|
||||
ConnectionConfig.getSSLProfile = function getSSLProfile(name) {
|
||||
if (!SSLProfiles) {
|
||||
SSLProfiles = require('./protocol/constants/ssl_profiles');
|
||||
}
|
||||
|
||||
var ssl = SSLProfiles[name];
|
||||
|
||||
if (ssl === undefined) {
|
||||
throw new TypeError('Unknown SSL profile \'' + name + '\'');
|
||||
}
|
||||
|
||||
return ssl;
|
||||
};
|
||||
|
||||
ConnectionConfig.parseFlagList = function parseFlagList(flagList) {
|
||||
var allFlags = Object.create(null);
|
||||
|
||||
if (!flagList) {
|
||||
return allFlags;
|
||||
}
|
||||
|
||||
var flags = !Array.isArray(flagList)
|
||||
? String(flagList || '').toUpperCase().split(/\s*,+\s*/)
|
||||
: flagList;
|
||||
|
||||
for (var i = 0; i < flags.length; i++) {
|
||||
var flag = flags[i];
|
||||
var offset = 1;
|
||||
var state = flag[0];
|
||||
|
||||
if (state === undefined) {
|
||||
// TODO: throw here on some future release
|
||||
continue;
|
||||
}
|
||||
|
||||
if (state !== '-' && state !== '+') {
|
||||
offset = 0;
|
||||
state = '+';
|
||||
}
|
||||
|
||||
allFlags[flag.substr(offset)] = state === '+';
|
||||
}
|
||||
|
||||
return allFlags;
|
||||
};
|
||||
|
||||
ConnectionConfig.parseUrl = function(url) {
|
||||
url = urlParse(url, true);
|
||||
|
||||
var options = {
|
||||
host : url.hostname,
|
||||
port : url.port,
|
||||
database : url.pathname.substr(1)
|
||||
};
|
||||
|
||||
if (url.auth) {
|
||||
var auth = url.auth.split(':');
|
||||
options.user = auth.shift();
|
||||
options.password = auth.join(':');
|
||||
}
|
||||
|
||||
if (url.query) {
|
||||
for (var key in url.query) {
|
||||
var value = url.query[key];
|
||||
|
||||
try {
|
||||
// Try to parse this as a JSON expression first
|
||||
options[key] = JSON.parse(value);
|
||||
} catch (err) {
|
||||
// Otherwise assume it is a plain string
|
||||
options[key] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return options;
|
||||
};
|
||||
294
node_modules/mysql/lib/Pool.js
generated
vendored
Normal file
294
node_modules/mysql/lib/Pool.js
generated
vendored
Normal file
@ -0,0 +1,294 @@
|
||||
var mysql = require('../');
|
||||
var Connection = require('./Connection');
|
||||
var EventEmitter = require('events').EventEmitter;
|
||||
var Util = require('util');
|
||||
var PoolConnection = require('./PoolConnection');
|
||||
|
||||
module.exports = Pool;
|
||||
|
||||
Util.inherits(Pool, EventEmitter);
|
||||
function Pool(options) {
|
||||
EventEmitter.call(this);
|
||||
this.config = options.config;
|
||||
this.config.connectionConfig.pool = this;
|
||||
|
||||
this._acquiringConnections = [];
|
||||
this._allConnections = [];
|
||||
this._freeConnections = [];
|
||||
this._connectionQueue = [];
|
||||
this._closed = false;
|
||||
}
|
||||
|
||||
Pool.prototype.getConnection = function (cb) {
|
||||
|
||||
if (this._closed) {
|
||||
var err = new Error('Pool is closed.');
|
||||
err.code = 'POOL_CLOSED';
|
||||
process.nextTick(function () {
|
||||
cb(err);
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
var connection;
|
||||
var pool = this;
|
||||
|
||||
if (this._freeConnections.length > 0) {
|
||||
connection = this._freeConnections.shift();
|
||||
this.acquireConnection(connection, cb);
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.config.connectionLimit === 0 || this._allConnections.length < this.config.connectionLimit) {
|
||||
connection = new PoolConnection(this, { config: this.config.newConnectionConfig() });
|
||||
|
||||
this._acquiringConnections.push(connection);
|
||||
this._allConnections.push(connection);
|
||||
|
||||
connection.connect({timeout: this.config.acquireTimeout}, function onConnect(err) {
|
||||
spliceConnection(pool._acquiringConnections, connection);
|
||||
|
||||
if (pool._closed) {
|
||||
err = new Error('Pool is closed.');
|
||||
err.code = 'POOL_CLOSED';
|
||||
}
|
||||
|
||||
if (err) {
|
||||
pool._purgeConnection(connection);
|
||||
cb(err);
|
||||
return;
|
||||
}
|
||||
|
||||
pool.emit('connection', connection);
|
||||
pool.emit('acquire', connection);
|
||||
cb(null, connection);
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
if (!this.config.waitForConnections) {
|
||||
process.nextTick(function(){
|
||||
var err = new Error('No connections available.');
|
||||
err.code = 'POOL_CONNLIMIT';
|
||||
cb(err);
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
this._enqueueCallback(cb);
|
||||
};
|
||||
|
||||
Pool.prototype.acquireConnection = function acquireConnection(connection, cb) {
|
||||
if (connection._pool !== this) {
|
||||
throw new Error('Connection acquired from wrong pool.');
|
||||
}
|
||||
|
||||
var changeUser = this._needsChangeUser(connection);
|
||||
var pool = this;
|
||||
|
||||
this._acquiringConnections.push(connection);
|
||||
|
||||
function onOperationComplete(err) {
|
||||
spliceConnection(pool._acquiringConnections, connection);
|
||||
|
||||
if (pool._closed) {
|
||||
err = new Error('Pool is closed.');
|
||||
err.code = 'POOL_CLOSED';
|
||||
}
|
||||
|
||||
if (err) {
|
||||
pool._connectionQueue.unshift(cb);
|
||||
pool._purgeConnection(connection);
|
||||
return;
|
||||
}
|
||||
|
||||
if (changeUser) {
|
||||
pool.emit('connection', connection);
|
||||
}
|
||||
|
||||
pool.emit('acquire', connection);
|
||||
cb(null, connection);
|
||||
}
|
||||
|
||||
if (changeUser) {
|
||||
// restore user back to pool configuration
|
||||
connection.config = this.config.newConnectionConfig();
|
||||
connection.changeUser({timeout: this.config.acquireTimeout}, onOperationComplete);
|
||||
} else {
|
||||
// ping connection
|
||||
connection.ping({timeout: this.config.acquireTimeout}, onOperationComplete);
|
||||
}
|
||||
};
|
||||
|
||||
Pool.prototype.releaseConnection = function releaseConnection(connection) {
|
||||
|
||||
if (this._acquiringConnections.indexOf(connection) !== -1) {
|
||||
// connection is being acquired
|
||||
return;
|
||||
}
|
||||
|
||||
if (connection._pool) {
|
||||
if (connection._pool !== this) {
|
||||
throw new Error('Connection released to wrong pool');
|
||||
}
|
||||
|
||||
if (this._freeConnections.indexOf(connection) !== -1) {
|
||||
// connection already in free connection pool
|
||||
// this won't catch all double-release cases
|
||||
throw new Error('Connection already released');
|
||||
} else {
|
||||
// add connection to end of free queue
|
||||
this._freeConnections.push(connection);
|
||||
this.emit('release', connection);
|
||||
}
|
||||
}
|
||||
|
||||
if (this._closed) {
|
||||
// empty the connection queue
|
||||
this._connectionQueue.splice(0).forEach(function (cb) {
|
||||
var err = new Error('Pool is closed.');
|
||||
err.code = 'POOL_CLOSED';
|
||||
process.nextTick(function () {
|
||||
cb(err);
|
||||
});
|
||||
});
|
||||
} else if (this._connectionQueue.length) {
|
||||
// get connection with next waiting callback
|
||||
this.getConnection(this._connectionQueue.shift());
|
||||
}
|
||||
};
|
||||
|
||||
Pool.prototype.end = function (cb) {
|
||||
this._closed = true;
|
||||
|
||||
if (typeof cb !== 'function') {
|
||||
cb = function (err) {
|
||||
if (err) throw err;
|
||||
};
|
||||
}
|
||||
|
||||
var calledBack = false;
|
||||
var waitingClose = 0;
|
||||
|
||||
function onEnd(err) {
|
||||
if (!calledBack && (err || --waitingClose <= 0)) {
|
||||
calledBack = true;
|
||||
cb(err);
|
||||
}
|
||||
}
|
||||
|
||||
while (this._allConnections.length !== 0) {
|
||||
waitingClose++;
|
||||
this._purgeConnection(this._allConnections[0], onEnd);
|
||||
}
|
||||
|
||||
if (waitingClose === 0) {
|
||||
process.nextTick(onEnd);
|
||||
}
|
||||
};
|
||||
|
||||
Pool.prototype.query = function (sql, values, cb) {
|
||||
var query = Connection.createQuery(sql, values, cb);
|
||||
|
||||
if (!(typeof sql === 'object' && 'typeCast' in sql)) {
|
||||
query.typeCast = this.config.connectionConfig.typeCast;
|
||||
}
|
||||
|
||||
if (this.config.connectionConfig.trace) {
|
||||
// Long stack trace support
|
||||
query._callSite = new Error();
|
||||
}
|
||||
|
||||
this.getConnection(function (err, conn) {
|
||||
if (err) {
|
||||
query.on('error', function () {});
|
||||
query.end(err);
|
||||
return;
|
||||
}
|
||||
|
||||
// Release connection based off event
|
||||
query.once('end', function() {
|
||||
conn.release();
|
||||
});
|
||||
|
||||
conn.query(query);
|
||||
});
|
||||
|
||||
return query;
|
||||
};
|
||||
|
||||
Pool.prototype._enqueueCallback = function _enqueueCallback(callback) {
|
||||
|
||||
if (this.config.queueLimit && this._connectionQueue.length >= this.config.queueLimit) {
|
||||
process.nextTick(function () {
|
||||
var err = new Error('Queue limit reached.');
|
||||
err.code = 'POOL_ENQUEUELIMIT';
|
||||
callback(err);
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
// Bind to domain, as dequeue will likely occur in a different domain
|
||||
var cb = process.domain
|
||||
? process.domain.bind(callback)
|
||||
: callback;
|
||||
|
||||
this._connectionQueue.push(cb);
|
||||
this.emit('enqueue');
|
||||
};
|
||||
|
||||
Pool.prototype._needsChangeUser = function _needsChangeUser(connection) {
|
||||
var connConfig = connection.config;
|
||||
var poolConfig = this.config.connectionConfig;
|
||||
|
||||
// check if changeUser values are different
|
||||
return connConfig.user !== poolConfig.user
|
||||
|| connConfig.database !== poolConfig.database
|
||||
|| connConfig.password !== poolConfig.password
|
||||
|| connConfig.charsetNumber !== poolConfig.charsetNumber;
|
||||
};
|
||||
|
||||
Pool.prototype._purgeConnection = function _purgeConnection(connection, callback) {
|
||||
var cb = callback || function () {};
|
||||
|
||||
if (connection.state === 'disconnected') {
|
||||
connection.destroy();
|
||||
}
|
||||
|
||||
this._removeConnection(connection);
|
||||
|
||||
if (connection.state !== 'disconnected' && !connection._protocol._quitSequence) {
|
||||
connection._realEnd(cb);
|
||||
return;
|
||||
}
|
||||
|
||||
process.nextTick(cb);
|
||||
};
|
||||
|
||||
Pool.prototype._removeConnection = function(connection) {
|
||||
connection._pool = null;
|
||||
|
||||
// Remove connection from all connections
|
||||
spliceConnection(this._allConnections, connection);
|
||||
|
||||
// Remove connection from free connections
|
||||
spliceConnection(this._freeConnections, connection);
|
||||
|
||||
this.releaseConnection(connection);
|
||||
};
|
||||
|
||||
Pool.prototype.escape = function(value) {
|
||||
return mysql.escape(value, this.config.connectionConfig.stringifyObjects, this.config.connectionConfig.timezone);
|
||||
};
|
||||
|
||||
Pool.prototype.escapeId = function escapeId(value) {
|
||||
return mysql.escapeId(value, false);
|
||||
};
|
||||
|
||||
function spliceConnection(array, connection) {
|
||||
var index;
|
||||
if ((index = array.indexOf(connection)) !== -1) {
|
||||
// Remove connection from all connections
|
||||
array.splice(index, 1);
|
||||
}
|
||||
}
|
||||
288
node_modules/mysql/lib/PoolCluster.js
generated
vendored
Normal file
288
node_modules/mysql/lib/PoolCluster.js
generated
vendored
Normal file
@ -0,0 +1,288 @@
|
||||
var Pool = require('./Pool');
|
||||
var PoolConfig = require('./PoolConfig');
|
||||
var PoolNamespace = require('./PoolNamespace');
|
||||
var PoolSelector = require('./PoolSelector');
|
||||
var Util = require('util');
|
||||
var EventEmitter = require('events').EventEmitter;
|
||||
|
||||
module.exports = PoolCluster;
|
||||
|
||||
/**
|
||||
* PoolCluster
|
||||
* @constructor
|
||||
* @param {object} [config] The pool cluster configuration
|
||||
* @public
|
||||
*/
|
||||
function PoolCluster(config) {
|
||||
EventEmitter.call(this);
|
||||
|
||||
config = config || {};
|
||||
this._canRetry = typeof config.canRetry === 'undefined' ? true : config.canRetry;
|
||||
this._defaultSelector = config.defaultSelector || 'RR';
|
||||
this._removeNodeErrorCount = config.removeNodeErrorCount || 5;
|
||||
this._restoreNodeTimeout = config.restoreNodeTimeout || 0;
|
||||
|
||||
this._closed = false;
|
||||
this._findCaches = Object.create(null);
|
||||
this._lastId = 0;
|
||||
this._namespaces = Object.create(null);
|
||||
this._nodes = Object.create(null);
|
||||
}
|
||||
|
||||
Util.inherits(PoolCluster, EventEmitter);
|
||||
|
||||
PoolCluster.prototype.add = function add(id, config) {
|
||||
if (this._closed) {
|
||||
throw new Error('PoolCluster is closed.');
|
||||
}
|
||||
|
||||
var nodeId = typeof id === 'object'
|
||||
? 'CLUSTER::' + (++this._lastId)
|
||||
: String(id);
|
||||
|
||||
if (this._nodes[nodeId] !== undefined) {
|
||||
throw new Error('Node ID "' + nodeId + '" is already defined in PoolCluster.');
|
||||
}
|
||||
|
||||
var poolConfig = typeof id !== 'object'
|
||||
? new PoolConfig(config)
|
||||
: new PoolConfig(id);
|
||||
|
||||
this._nodes[nodeId] = {
|
||||
id : nodeId,
|
||||
errorCount : 0,
|
||||
pool : new Pool({config: poolConfig}),
|
||||
_offlineUntil : 0
|
||||
};
|
||||
|
||||
this._clearFindCaches();
|
||||
};
|
||||
|
||||
PoolCluster.prototype.end = function end(callback) {
|
||||
var cb = callback !== undefined
|
||||
? callback
|
||||
: _cb;
|
||||
|
||||
if (typeof cb !== 'function') {
|
||||
throw TypeError('callback argument must be a function');
|
||||
}
|
||||
|
||||
if (this._closed) {
|
||||
process.nextTick(cb);
|
||||
return;
|
||||
}
|
||||
|
||||
this._closed = true;
|
||||
|
||||
var calledBack = false;
|
||||
var nodeIds = Object.keys(this._nodes);
|
||||
var waitingClose = 0;
|
||||
|
||||
function onEnd(err) {
|
||||
if (!calledBack && (err || --waitingClose <= 0)) {
|
||||
calledBack = true;
|
||||
cb(err);
|
||||
}
|
||||
}
|
||||
|
||||
for (var i = 0; i < nodeIds.length; i++) {
|
||||
var nodeId = nodeIds[i];
|
||||
var node = this._nodes[nodeId];
|
||||
|
||||
waitingClose++;
|
||||
node.pool.end(onEnd);
|
||||
}
|
||||
|
||||
if (waitingClose === 0) {
|
||||
process.nextTick(onEnd);
|
||||
}
|
||||
};
|
||||
|
||||
PoolCluster.prototype.of = function(pattern, selector) {
|
||||
pattern = pattern || '*';
|
||||
|
||||
selector = selector || this._defaultSelector;
|
||||
selector = selector.toUpperCase();
|
||||
if (typeof PoolSelector[selector] === 'undefined') {
|
||||
selector = this._defaultSelector;
|
||||
}
|
||||
|
||||
var key = pattern + selector;
|
||||
|
||||
if (typeof this._namespaces[key] === 'undefined') {
|
||||
this._namespaces[key] = new PoolNamespace(this, pattern, selector);
|
||||
}
|
||||
|
||||
return this._namespaces[key];
|
||||
};
|
||||
|
||||
PoolCluster.prototype.remove = function remove(pattern) {
|
||||
var foundNodeIds = this._findNodeIds(pattern, true);
|
||||
|
||||
for (var i = 0; i < foundNodeIds.length; i++) {
|
||||
var node = this._getNode(foundNodeIds[i]);
|
||||
|
||||
if (node) {
|
||||
this._removeNode(node);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
PoolCluster.prototype.getConnection = function(pattern, selector, cb) {
|
||||
var namespace;
|
||||
if (typeof pattern === 'function') {
|
||||
cb = pattern;
|
||||
namespace = this.of();
|
||||
} else {
|
||||
if (typeof selector === 'function') {
|
||||
cb = selector;
|
||||
selector = this._defaultSelector;
|
||||
}
|
||||
|
||||
namespace = this.of(pattern, selector);
|
||||
}
|
||||
|
||||
namespace.getConnection(cb);
|
||||
};
|
||||
|
||||
PoolCluster.prototype._clearFindCaches = function _clearFindCaches() {
|
||||
this._findCaches = Object.create(null);
|
||||
};
|
||||
|
||||
PoolCluster.prototype._decreaseErrorCount = function _decreaseErrorCount(node) {
|
||||
var errorCount = node.errorCount;
|
||||
|
||||
if (errorCount > this._removeNodeErrorCount) {
|
||||
errorCount = this._removeNodeErrorCount;
|
||||
}
|
||||
|
||||
if (errorCount < 1) {
|
||||
errorCount = 1;
|
||||
}
|
||||
|
||||
node.errorCount = errorCount - 1;
|
||||
|
||||
if (node._offlineUntil) {
|
||||
node._offlineUntil = 0;
|
||||
this.emit('online', node.id);
|
||||
}
|
||||
};
|
||||
|
||||
PoolCluster.prototype._findNodeIds = function _findNodeIds(pattern, includeOffline) {
|
||||
var currentTime = 0;
|
||||
var foundNodeIds = this._findCaches[pattern];
|
||||
|
||||
if (foundNodeIds === undefined) {
|
||||
var expression = patternRegExp(pattern);
|
||||
var nodeIds = Object.keys(this._nodes);
|
||||
|
||||
foundNodeIds = nodeIds.filter(function (id) {
|
||||
return id.match(expression);
|
||||
});
|
||||
|
||||
this._findCaches[pattern] = foundNodeIds;
|
||||
}
|
||||
|
||||
if (includeOffline) {
|
||||
return foundNodeIds;
|
||||
}
|
||||
|
||||
return foundNodeIds.filter(function (nodeId) {
|
||||
var node = this._getNode(nodeId);
|
||||
|
||||
if (!node._offlineUntil) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!currentTime) {
|
||||
currentTime = getMonotonicMilliseconds();
|
||||
}
|
||||
|
||||
return node._offlineUntil <= currentTime;
|
||||
}, this);
|
||||
};
|
||||
|
||||
PoolCluster.prototype._getNode = function _getNode(id) {
|
||||
return this._nodes[id] || null;
|
||||
};
|
||||
|
||||
PoolCluster.prototype._increaseErrorCount = function _increaseErrorCount(node) {
|
||||
var errorCount = ++node.errorCount;
|
||||
|
||||
if (this._removeNodeErrorCount > errorCount) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (this._restoreNodeTimeout > 0) {
|
||||
node._offlineUntil = getMonotonicMilliseconds() + this._restoreNodeTimeout;
|
||||
this.emit('offline', node.id);
|
||||
return;
|
||||
}
|
||||
|
||||
this._removeNode(node);
|
||||
this.emit('remove', node.id);
|
||||
};
|
||||
|
||||
PoolCluster.prototype._getConnection = function(node, cb) {
|
||||
var self = this;
|
||||
|
||||
node.pool.getConnection(function (err, connection) {
|
||||
if (err) {
|
||||
self._increaseErrorCount(node);
|
||||
cb(err);
|
||||
return;
|
||||
} else {
|
||||
self._decreaseErrorCount(node);
|
||||
}
|
||||
|
||||
connection._clusterId = node.id;
|
||||
|
||||
cb(null, connection);
|
||||
});
|
||||
};
|
||||
|
||||
PoolCluster.prototype._removeNode = function _removeNode(node) {
|
||||
delete this._nodes[node.id];
|
||||
|
||||
this._clearFindCaches();
|
||||
|
||||
node.pool.end(_noop);
|
||||
};
|
||||
|
||||
function getMonotonicMilliseconds() {
|
||||
var ms;
|
||||
|
||||
if (typeof process.hrtime === 'function') {
|
||||
ms = process.hrtime();
|
||||
ms = ms[0] * 1e3 + ms[1] * 1e-6;
|
||||
} else {
|
||||
ms = process.uptime() * 1000;
|
||||
}
|
||||
|
||||
return Math.floor(ms);
|
||||
}
|
||||
|
||||
function isRegExp(val) {
|
||||
return typeof val === 'object'
|
||||
&& Object.prototype.toString.call(val) === '[object RegExp]';
|
||||
}
|
||||
|
||||
function patternRegExp(pattern) {
|
||||
if (isRegExp(pattern)) {
|
||||
return pattern;
|
||||
}
|
||||
|
||||
var source = pattern
|
||||
.replace(/([.+?^=!:${}()|\[\]\/\\])/g, '\\$1')
|
||||
.replace(/\*/g, '.*');
|
||||
|
||||
return new RegExp('^' + source + '$');
|
||||
}
|
||||
|
||||
function _cb(err) {
|
||||
if (err) {
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
function _noop() {}
|
||||
32
node_modules/mysql/lib/PoolConfig.js
generated
vendored
Normal file
32
node_modules/mysql/lib/PoolConfig.js
generated
vendored
Normal file
@ -0,0 +1,32 @@
|
||||
|
||||
var ConnectionConfig = require('./ConnectionConfig');
|
||||
|
||||
module.exports = PoolConfig;
|
||||
function PoolConfig(options) {
|
||||
if (typeof options === 'string') {
|
||||
options = ConnectionConfig.parseUrl(options);
|
||||
}
|
||||
|
||||
this.acquireTimeout = (options.acquireTimeout === undefined)
|
||||
? 10 * 1000
|
||||
: Number(options.acquireTimeout);
|
||||
this.connectionConfig = new ConnectionConfig(options);
|
||||
this.waitForConnections = (options.waitForConnections === undefined)
|
||||
? true
|
||||
: Boolean(options.waitForConnections);
|
||||
this.connectionLimit = (options.connectionLimit === undefined)
|
||||
? 10
|
||||
: Number(options.connectionLimit);
|
||||
this.queueLimit = (options.queueLimit === undefined)
|
||||
? 0
|
||||
: Number(options.queueLimit);
|
||||
}
|
||||
|
||||
PoolConfig.prototype.newConnectionConfig = function newConnectionConfig() {
|
||||
var connectionConfig = new ConnectionConfig(this.connectionConfig);
|
||||
|
||||
connectionConfig.clientFlags = this.connectionConfig.clientFlags;
|
||||
connectionConfig.maxPacketSize = this.connectionConfig.maxPacketSize;
|
||||
|
||||
return connectionConfig;
|
||||
};
|
||||
65
node_modules/mysql/lib/PoolConnection.js
generated
vendored
Normal file
65
node_modules/mysql/lib/PoolConnection.js
generated
vendored
Normal file
@ -0,0 +1,65 @@
|
||||
var inherits = require('util').inherits;
|
||||
var Connection = require('./Connection');
|
||||
var Events = require('events');
|
||||
|
||||
module.exports = PoolConnection;
|
||||
inherits(PoolConnection, Connection);
|
||||
|
||||
function PoolConnection(pool, options) {
|
||||
Connection.call(this, options);
|
||||
this._pool = pool;
|
||||
|
||||
// Bind connection to pool domain
|
||||
if (Events.usingDomains) {
|
||||
this.domain = pool.domain;
|
||||
}
|
||||
|
||||
// When a fatal error occurs the connection's protocol ends, which will cause
|
||||
// the connection to end as well, thus we only need to watch for the end event
|
||||
// and we will be notified of disconnects.
|
||||
this.on('end', this._removeFromPool);
|
||||
this.on('error', function (err) {
|
||||
if (err.fatal) {
|
||||
this._removeFromPool();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
PoolConnection.prototype.release = function release() {
|
||||
var pool = this._pool;
|
||||
|
||||
if (!pool || pool._closed) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return pool.releaseConnection(this);
|
||||
};
|
||||
|
||||
// TODO: Remove this when we are removing PoolConnection#end
|
||||
PoolConnection.prototype._realEnd = Connection.prototype.end;
|
||||
|
||||
PoolConnection.prototype.end = function () {
|
||||
console.warn(
|
||||
'Calling conn.end() to release a pooled connection is ' +
|
||||
'deprecated. In next version calling conn.end() will be ' +
|
||||
'restored to default conn.end() behavior. Use ' +
|
||||
'conn.release() instead.'
|
||||
);
|
||||
this.release();
|
||||
};
|
||||
|
||||
PoolConnection.prototype.destroy = function () {
|
||||
Connection.prototype.destroy.apply(this, arguments);
|
||||
this._removeFromPool(this);
|
||||
};
|
||||
|
||||
PoolConnection.prototype._removeFromPool = function _removeFromPool() {
|
||||
if (!this._pool || this._pool._closed) {
|
||||
return;
|
||||
}
|
||||
|
||||
var pool = this._pool;
|
||||
this._pool = null;
|
||||
|
||||
pool._purgeConnection(this);
|
||||
};
|
||||
136
node_modules/mysql/lib/PoolNamespace.js
generated
vendored
Normal file
136
node_modules/mysql/lib/PoolNamespace.js
generated
vendored
Normal file
@ -0,0 +1,136 @@
|
||||
var Connection = require('./Connection');
|
||||
var PoolSelector = require('./PoolSelector');
|
||||
|
||||
module.exports = PoolNamespace;
|
||||
|
||||
/**
|
||||
* PoolNamespace
|
||||
* @constructor
|
||||
* @param {PoolCluster} cluster The parent cluster for the namespace
|
||||
* @param {string} pattern The selection pattern to use
|
||||
* @param {string} selector The selector name to use
|
||||
* @public
|
||||
*/
|
||||
function PoolNamespace(cluster, pattern, selector) {
|
||||
this._cluster = cluster;
|
||||
this._pattern = pattern;
|
||||
this._selector = new PoolSelector[selector]();
|
||||
}
|
||||
|
||||
PoolNamespace.prototype.getConnection = function(cb) {
|
||||
var clusterNode = this._getClusterNode();
|
||||
var cluster = this._cluster;
|
||||
var namespace = this;
|
||||
|
||||
if (clusterNode === null) {
|
||||
var err = null;
|
||||
|
||||
if (this._cluster._findNodeIds(this._pattern, true).length !== 0) {
|
||||
err = new Error('Pool does not have online node.');
|
||||
err.code = 'POOL_NONEONLINE';
|
||||
} else {
|
||||
err = new Error('Pool does not exist.');
|
||||
err.code = 'POOL_NOEXIST';
|
||||
}
|
||||
|
||||
cb(err);
|
||||
return;
|
||||
}
|
||||
|
||||
cluster._getConnection(clusterNode, function(err, connection) {
|
||||
var retry = err && cluster._canRetry
|
||||
&& cluster._findNodeIds(namespace._pattern).length !== 0;
|
||||
|
||||
if (retry) {
|
||||
namespace.getConnection(cb);
|
||||
return;
|
||||
}
|
||||
|
||||
if (err) {
|
||||
cb(err);
|
||||
return;
|
||||
}
|
||||
|
||||
cb(null, connection);
|
||||
});
|
||||
};
|
||||
|
||||
PoolNamespace.prototype.query = function (sql, values, cb) {
|
||||
var cluster = this._cluster;
|
||||
var clusterNode = this._getClusterNode();
|
||||
var query = Connection.createQuery(sql, values, cb);
|
||||
var namespace = this;
|
||||
|
||||
if (clusterNode === null) {
|
||||
var err = null;
|
||||
|
||||
if (this._cluster._findNodeIds(this._pattern, true).length !== 0) {
|
||||
err = new Error('Pool does not have online node.');
|
||||
err.code = 'POOL_NONEONLINE';
|
||||
} else {
|
||||
err = new Error('Pool does not exist.');
|
||||
err.code = 'POOL_NOEXIST';
|
||||
}
|
||||
|
||||
process.nextTick(function () {
|
||||
query.on('error', function () {});
|
||||
query.end(err);
|
||||
});
|
||||
return query;
|
||||
}
|
||||
|
||||
if (!(typeof sql === 'object' && 'typeCast' in sql)) {
|
||||
query.typeCast = clusterNode.pool.config.connectionConfig.typeCast;
|
||||
}
|
||||
|
||||
if (clusterNode.pool.config.connectionConfig.trace) {
|
||||
// Long stack trace support
|
||||
query._callSite = new Error();
|
||||
}
|
||||
|
||||
cluster._getConnection(clusterNode, function (err, conn) {
|
||||
var retry = err && cluster._canRetry
|
||||
&& cluster._findNodeIds(namespace._pattern).length !== 0;
|
||||
|
||||
if (retry) {
|
||||
namespace.query(query);
|
||||
return;
|
||||
}
|
||||
|
||||
if (err) {
|
||||
query.on('error', function () {});
|
||||
query.end(err);
|
||||
return;
|
||||
}
|
||||
|
||||
// Release connection based off event
|
||||
query.once('end', function() {
|
||||
conn.release();
|
||||
});
|
||||
|
||||
conn.query(query);
|
||||
});
|
||||
|
||||
return query;
|
||||
};
|
||||
|
||||
PoolNamespace.prototype._getClusterNode = function _getClusterNode() {
|
||||
var foundNodeIds = this._cluster._findNodeIds(this._pattern);
|
||||
var nodeId;
|
||||
|
||||
switch (foundNodeIds.length) {
|
||||
case 0:
|
||||
nodeId = null;
|
||||
break;
|
||||
case 1:
|
||||
nodeId = foundNodeIds[0];
|
||||
break;
|
||||
default:
|
||||
nodeId = this._selector(foundNodeIds);
|
||||
break;
|
||||
}
|
||||
|
||||
return nodeId !== null
|
||||
? this._cluster._getNode(nodeId)
|
||||
: null;
|
||||
};
|
||||
31
node_modules/mysql/lib/PoolSelector.js
generated
vendored
Normal file
31
node_modules/mysql/lib/PoolSelector.js
generated
vendored
Normal file
@ -0,0 +1,31 @@
|
||||
|
||||
/**
|
||||
* PoolSelector
|
||||
*/
|
||||
var PoolSelector = module.exports = {};
|
||||
|
||||
PoolSelector.RR = function PoolSelectorRoundRobin() {
|
||||
var index = 0;
|
||||
|
||||
return function(clusterIds) {
|
||||
if (index >= clusterIds.length) {
|
||||
index = 0;
|
||||
}
|
||||
|
||||
var clusterId = clusterIds[index++];
|
||||
|
||||
return clusterId;
|
||||
};
|
||||
};
|
||||
|
||||
PoolSelector.RANDOM = function PoolSelectorRandom() {
|
||||
return function(clusterIds) {
|
||||
return clusterIds[Math.floor(Math.random() * clusterIds.length)];
|
||||
};
|
||||
};
|
||||
|
||||
PoolSelector.ORDER = function PoolSelectorOrder() {
|
||||
return function(clusterIds) {
|
||||
return clusterIds[0];
|
||||
};
|
||||
};
|
||||
168
node_modules/mysql/lib/protocol/Auth.js
generated
vendored
Normal file
168
node_modules/mysql/lib/protocol/Auth.js
generated
vendored
Normal file
@ -0,0 +1,168 @@
|
||||
var Buffer = require('safe-buffer').Buffer;
|
||||
var Crypto = require('crypto');
|
||||
var Auth = exports;
|
||||
|
||||
function auth(name, data, options) {
|
||||
options = options || {};
|
||||
|
||||
switch (name) {
|
||||
case 'mysql_native_password':
|
||||
return Auth.token(options.password, data.slice(0, 20));
|
||||
default:
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
Auth.auth = auth;
|
||||
|
||||
function sha1(msg) {
|
||||
var hash = Crypto.createHash('sha1');
|
||||
hash.update(msg, 'binary');
|
||||
return hash.digest('binary');
|
||||
}
|
||||
Auth.sha1 = sha1;
|
||||
|
||||
function xor(a, b) {
|
||||
a = Buffer.from(a, 'binary');
|
||||
b = Buffer.from(b, 'binary');
|
||||
var result = Buffer.allocUnsafe(a.length);
|
||||
for (var i = 0; i < a.length; i++) {
|
||||
result[i] = (a[i] ^ b[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
Auth.xor = xor;
|
||||
|
||||
Auth.token = function(password, scramble) {
|
||||
if (!password) {
|
||||
return Buffer.alloc(0);
|
||||
}
|
||||
|
||||
// password must be in binary format, not utf8
|
||||
var stage1 = sha1((Buffer.from(password, 'utf8')).toString('binary'));
|
||||
var stage2 = sha1(stage1);
|
||||
var stage3 = sha1(scramble.toString('binary') + stage2);
|
||||
return xor(stage3, stage1);
|
||||
};
|
||||
|
||||
// This is a port of sql/password.c:hash_password which needs to be used for
|
||||
// pre-4.1 passwords.
|
||||
Auth.hashPassword = function(password) {
|
||||
var nr = [0x5030, 0x5735];
|
||||
var add = 7;
|
||||
var nr2 = [0x1234, 0x5671];
|
||||
var result = Buffer.alloc(8);
|
||||
|
||||
if (typeof password === 'string'){
|
||||
password = Buffer.from(password);
|
||||
}
|
||||
|
||||
for (var i = 0; i < password.length; i++) {
|
||||
var c = password[i];
|
||||
if (c === 32 || c === 9) {
|
||||
// skip space in password
|
||||
continue;
|
||||
}
|
||||
|
||||
// nr^= (((nr & 63)+add)*c)+ (nr << 8);
|
||||
// nr = xor(nr, add(mul(add(and(nr, 63), add), c), shl(nr, 8)))
|
||||
nr = this.xor32(nr, this.add32(this.mul32(this.add32(this.and32(nr, [0, 63]), [0, add]), [0, c]), this.shl32(nr, 8)));
|
||||
|
||||
// nr2+=(nr2 << 8) ^ nr;
|
||||
// nr2 = add(nr2, xor(shl(nr2, 8), nr))
|
||||
nr2 = this.add32(nr2, this.xor32(this.shl32(nr2, 8), nr));
|
||||
|
||||
// add+=tmp;
|
||||
add += c;
|
||||
}
|
||||
|
||||
this.int31Write(result, nr, 0);
|
||||
this.int31Write(result, nr2, 4);
|
||||
|
||||
return result;
|
||||
};
|
||||
|
||||
Auth.randomInit = function(seed1, seed2) {
|
||||
return {
|
||||
max_value : 0x3FFFFFFF,
|
||||
max_value_dbl : 0x3FFFFFFF,
|
||||
seed1 : seed1 % 0x3FFFFFFF,
|
||||
seed2 : seed2 % 0x3FFFFFFF
|
||||
};
|
||||
};
|
||||
|
||||
Auth.myRnd = function(r){
|
||||
r.seed1 = (r.seed1 * 3 + r.seed2) % r.max_value;
|
||||
r.seed2 = (r.seed1 + r.seed2 + 33) % r.max_value;
|
||||
|
||||
return r.seed1 / r.max_value_dbl;
|
||||
};
|
||||
|
||||
Auth.scramble323 = function(message, password) {
|
||||
if (!password) {
|
||||
return Buffer.alloc(0);
|
||||
}
|
||||
|
||||
var to = Buffer.allocUnsafe(8);
|
||||
var hashPass = this.hashPassword(password);
|
||||
var hashMessage = this.hashPassword(message.slice(0, 8));
|
||||
var seed1 = this.int32Read(hashPass, 0) ^ this.int32Read(hashMessage, 0);
|
||||
var seed2 = this.int32Read(hashPass, 4) ^ this.int32Read(hashMessage, 4);
|
||||
var r = this.randomInit(seed1, seed2);
|
||||
|
||||
for (var i = 0; i < 8; i++){
|
||||
to[i] = Math.floor(this.myRnd(r) * 31) + 64;
|
||||
}
|
||||
var extra = (Math.floor(this.myRnd(r) * 31));
|
||||
|
||||
for (var i = 0; i < 8; i++){
|
||||
to[i] ^= extra;
|
||||
}
|
||||
|
||||
return to;
|
||||
};
|
||||
|
||||
Auth.xor32 = function(a, b){
|
||||
return [a[0] ^ b[0], a[1] ^ b[1]];
|
||||
};
|
||||
|
||||
Auth.add32 = function(a, b){
|
||||
var w1 = a[1] + b[1];
|
||||
var w2 = a[0] + b[0] + ((w1 & 0xFFFF0000) >> 16);
|
||||
|
||||
return [w2 & 0xFFFF, w1 & 0xFFFF];
|
||||
};
|
||||
|
||||
Auth.mul32 = function(a, b){
|
||||
// based on this example of multiplying 32b ints using 16b
|
||||
// http://www.dsprelated.com/showmessage/89790/1.php
|
||||
var w1 = a[1] * b[1];
|
||||
var w2 = (((a[1] * b[1]) >> 16) & 0xFFFF) + ((a[0] * b[1]) & 0xFFFF) + (a[1] * b[0] & 0xFFFF);
|
||||
|
||||
return [w2 & 0xFFFF, w1 & 0xFFFF];
|
||||
};
|
||||
|
||||
Auth.and32 = function(a, b){
|
||||
return [a[0] & b[0], a[1] & b[1]];
|
||||
};
|
||||
|
||||
Auth.shl32 = function(a, b){
|
||||
// assume b is 16 or less
|
||||
var w1 = a[1] << b;
|
||||
var w2 = (a[0] << b) | ((w1 & 0xFFFF0000) >> 16);
|
||||
|
||||
return [w2 & 0xFFFF, w1 & 0xFFFF];
|
||||
};
|
||||
|
||||
Auth.int31Write = function(buffer, number, offset) {
|
||||
buffer[offset] = (number[0] >> 8) & 0x7F;
|
||||
buffer[offset + 1] = (number[0]) & 0xFF;
|
||||
buffer[offset + 2] = (number[1] >> 8) & 0xFF;
|
||||
buffer[offset + 3] = (number[1]) & 0xFF;
|
||||
};
|
||||
|
||||
Auth.int32Read = function(buffer, offset){
|
||||
return (buffer[offset] << 24)
|
||||
+ (buffer[offset + 1] << 16)
|
||||
+ (buffer[offset + 2] << 8)
|
||||
+ (buffer[offset + 3]);
|
||||
};
|
||||
25
node_modules/mysql/lib/protocol/BufferList.js
generated
vendored
Normal file
25
node_modules/mysql/lib/protocol/BufferList.js
generated
vendored
Normal file
@ -0,0 +1,25 @@
|
||||
|
||||
module.exports = BufferList;
|
||||
function BufferList() {
|
||||
this.bufs = [];
|
||||
this.size = 0;
|
||||
}
|
||||
|
||||
BufferList.prototype.shift = function shift() {
|
||||
var buf = this.bufs.shift();
|
||||
|
||||
if (buf) {
|
||||
this.size -= buf.length;
|
||||
}
|
||||
|
||||
return buf;
|
||||
};
|
||||
|
||||
BufferList.prototype.push = function push(buf) {
|
||||
if (!buf || !buf.length) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.bufs.push(buf);
|
||||
this.size += buf.length;
|
||||
};
|
||||
5
node_modules/mysql/lib/protocol/PacketHeader.js
generated
vendored
Normal file
5
node_modules/mysql/lib/protocol/PacketHeader.js
generated
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
module.exports = PacketHeader;
|
||||
function PacketHeader(length, number) {
|
||||
this.length = length;
|
||||
this.number = number;
|
||||
}
|
||||
211
node_modules/mysql/lib/protocol/PacketWriter.js
generated
vendored
Normal file
211
node_modules/mysql/lib/protocol/PacketWriter.js
generated
vendored
Normal file
@ -0,0 +1,211 @@
|
||||
var BIT_16 = Math.pow(2, 16);
|
||||
var BIT_24 = Math.pow(2, 24);
|
||||
var BUFFER_ALLOC_SIZE = Math.pow(2, 8);
|
||||
// The maximum precision JS Numbers can hold precisely
|
||||
// Don't panic: Good enough to represent byte values up to 8192 TB
|
||||
var IEEE_754_BINARY_64_PRECISION = Math.pow(2, 53);
|
||||
var MAX_PACKET_LENGTH = Math.pow(2, 24) - 1;
|
||||
var Buffer = require('safe-buffer').Buffer;
|
||||
|
||||
module.exports = PacketWriter;
|
||||
function PacketWriter() {
|
||||
this._buffer = null;
|
||||
this._offset = 0;
|
||||
}
|
||||
|
||||
PacketWriter.prototype.toBuffer = function toBuffer(parser) {
|
||||
if (!this._buffer) {
|
||||
this._buffer = Buffer.alloc(0);
|
||||
this._offset = 0;
|
||||
}
|
||||
|
||||
var buffer = this._buffer;
|
||||
var length = this._offset;
|
||||
var packets = Math.floor(length / MAX_PACKET_LENGTH) + 1;
|
||||
|
||||
this._buffer = Buffer.allocUnsafe(length + packets * 4);
|
||||
this._offset = 0;
|
||||
|
||||
for (var packet = 0; packet < packets; packet++) {
|
||||
var isLast = (packet + 1 === packets);
|
||||
var packetLength = (isLast)
|
||||
? length % MAX_PACKET_LENGTH
|
||||
: MAX_PACKET_LENGTH;
|
||||
|
||||
var packetNumber = parser.incrementPacketNumber();
|
||||
|
||||
this.writeUnsignedNumber(3, packetLength);
|
||||
this.writeUnsignedNumber(1, packetNumber);
|
||||
|
||||
var start = packet * MAX_PACKET_LENGTH;
|
||||
var end = start + packetLength;
|
||||
|
||||
this.writeBuffer(buffer.slice(start, end));
|
||||
}
|
||||
|
||||
return this._buffer;
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeUnsignedNumber = function(bytes, value) {
|
||||
this._allocate(bytes);
|
||||
|
||||
for (var i = 0; i < bytes; i++) {
|
||||
this._buffer[this._offset++] = (value >> (i * 8)) & 0xff;
|
||||
}
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeFiller = function(bytes) {
|
||||
this._allocate(bytes);
|
||||
|
||||
for (var i = 0; i < bytes; i++) {
|
||||
this._buffer[this._offset++] = 0x00;
|
||||
}
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeNullTerminatedString = function(value, encoding) {
|
||||
// Typecast undefined into '' and numbers into strings
|
||||
value = value || '';
|
||||
value = value + '';
|
||||
|
||||
var bytes = Buffer.byteLength(value, encoding || 'utf-8') + 1;
|
||||
this._allocate(bytes);
|
||||
|
||||
this._buffer.write(value, this._offset, encoding);
|
||||
this._buffer[this._offset + bytes - 1] = 0x00;
|
||||
|
||||
this._offset += bytes;
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeString = function(value) {
|
||||
// Typecast undefined into '' and numbers into strings
|
||||
value = value || '';
|
||||
value = value + '';
|
||||
|
||||
var bytes = Buffer.byteLength(value, 'utf-8');
|
||||
this._allocate(bytes);
|
||||
|
||||
this._buffer.write(value, this._offset, 'utf-8');
|
||||
|
||||
this._offset += bytes;
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeBuffer = function(value) {
|
||||
var bytes = value.length;
|
||||
|
||||
this._allocate(bytes);
|
||||
value.copy(this._buffer, this._offset);
|
||||
this._offset += bytes;
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeLengthCodedNumber = function(value) {
|
||||
if (value === null) {
|
||||
this._allocate(1);
|
||||
this._buffer[this._offset++] = 251;
|
||||
return;
|
||||
}
|
||||
|
||||
if (value <= 250) {
|
||||
this._allocate(1);
|
||||
this._buffer[this._offset++] = value;
|
||||
return;
|
||||
}
|
||||
|
||||
if (value > IEEE_754_BINARY_64_PRECISION) {
|
||||
throw new Error(
|
||||
'writeLengthCodedNumber: JS precision range exceeded, your ' +
|
||||
'number is > 53 bit: "' + value + '"'
|
||||
);
|
||||
}
|
||||
|
||||
if (value < BIT_16) {
|
||||
this._allocate(3);
|
||||
this._buffer[this._offset++] = 252;
|
||||
} else if (value < BIT_24) {
|
||||
this._allocate(4);
|
||||
this._buffer[this._offset++] = 253;
|
||||
} else {
|
||||
this._allocate(9);
|
||||
this._buffer[this._offset++] = 254;
|
||||
}
|
||||
|
||||
// 16 Bit
|
||||
this._buffer[this._offset++] = value & 0xff;
|
||||
this._buffer[this._offset++] = (value >> 8) & 0xff;
|
||||
|
||||
if (value < BIT_16) {
|
||||
return;
|
||||
}
|
||||
|
||||
// 24 Bit
|
||||
this._buffer[this._offset++] = (value >> 16) & 0xff;
|
||||
|
||||
if (value < BIT_24) {
|
||||
return;
|
||||
}
|
||||
|
||||
this._buffer[this._offset++] = (value >> 24) & 0xff;
|
||||
|
||||
// Hack: Get the most significant 32 bit (JS bitwise operators are 32 bit)
|
||||
value = value.toString(2);
|
||||
value = value.substr(0, value.length - 32);
|
||||
value = parseInt(value, 2);
|
||||
|
||||
this._buffer[this._offset++] = value & 0xff;
|
||||
this._buffer[this._offset++] = (value >> 8) & 0xff;
|
||||
this._buffer[this._offset++] = (value >> 16) & 0xff;
|
||||
|
||||
// Set last byte to 0, as we can only support 53 bits in JS (see above)
|
||||
this._buffer[this._offset++] = 0;
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeLengthCodedBuffer = function(value) {
|
||||
var bytes = value.length;
|
||||
this.writeLengthCodedNumber(bytes);
|
||||
this.writeBuffer(value);
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeNullTerminatedBuffer = function(value) {
|
||||
this.writeBuffer(value);
|
||||
this.writeFiller(1); // 0x00 terminator
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeLengthCodedString = function(value) {
|
||||
if (value === null) {
|
||||
this.writeLengthCodedNumber(null);
|
||||
return;
|
||||
}
|
||||
|
||||
value = (value === undefined)
|
||||
? ''
|
||||
: String(value);
|
||||
|
||||
var bytes = Buffer.byteLength(value, 'utf-8');
|
||||
this.writeLengthCodedNumber(bytes);
|
||||
|
||||
if (!bytes) {
|
||||
return;
|
||||
}
|
||||
|
||||
this._allocate(bytes);
|
||||
this._buffer.write(value, this._offset, 'utf-8');
|
||||
this._offset += bytes;
|
||||
};
|
||||
|
||||
PacketWriter.prototype._allocate = function _allocate(bytes) {
|
||||
if (!this._buffer) {
|
||||
this._buffer = Buffer.alloc(Math.max(BUFFER_ALLOC_SIZE, bytes));
|
||||
this._offset = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
var bytesRemaining = this._buffer.length - this._offset;
|
||||
if (bytesRemaining >= bytes) {
|
||||
return;
|
||||
}
|
||||
|
||||
var newSize = this._buffer.length + Math.max(BUFFER_ALLOC_SIZE, bytes);
|
||||
var oldBuffer = this._buffer;
|
||||
|
||||
this._buffer = Buffer.alloc(newSize);
|
||||
oldBuffer.copy(this._buffer);
|
||||
};
|
||||
491
node_modules/mysql/lib/protocol/Parser.js
generated
vendored
Normal file
491
node_modules/mysql/lib/protocol/Parser.js
generated
vendored
Normal file
@ -0,0 +1,491 @@
|
||||
var PacketHeader = require('./PacketHeader');
|
||||
var BigNumber = require('bignumber.js');
|
||||
var Buffer = require('safe-buffer').Buffer;
|
||||
var BufferList = require('./BufferList');
|
||||
|
||||
var MAX_PACKET_LENGTH = Math.pow(2, 24) - 1;
|
||||
var MUL_32BIT = Math.pow(2, 32);
|
||||
var PACKET_HEADER_LENGTH = 4;
|
||||
|
||||
module.exports = Parser;
|
||||
function Parser(options) {
|
||||
options = options || {};
|
||||
|
||||
this._supportBigNumbers = options.config && options.config.supportBigNumbers;
|
||||
this._buffer = Buffer.alloc(0);
|
||||
this._nextBuffers = new BufferList();
|
||||
this._longPacketBuffers = new BufferList();
|
||||
this._offset = 0;
|
||||
this._packetEnd = null;
|
||||
this._packetHeader = null;
|
||||
this._packetOffset = null;
|
||||
this._onError = options.onError || function(err) { throw err; };
|
||||
this._onPacket = options.onPacket || function() {};
|
||||
this._nextPacketNumber = 0;
|
||||
this._encoding = 'utf-8';
|
||||
this._paused = false;
|
||||
}
|
||||
|
||||
Parser.prototype.write = function write(chunk) {
|
||||
this._nextBuffers.push(chunk);
|
||||
|
||||
while (!this._paused) {
|
||||
var packetHeader = this._tryReadPacketHeader();
|
||||
|
||||
if (!packetHeader) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (!this._combineNextBuffers(packetHeader.length)) {
|
||||
break;
|
||||
}
|
||||
|
||||
this._parsePacket(packetHeader);
|
||||
}
|
||||
};
|
||||
|
||||
Parser.prototype.append = function append(chunk) {
|
||||
if (!chunk || chunk.length === 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Calculate slice ranges
|
||||
var sliceEnd = this._buffer.length;
|
||||
var sliceStart = this._packetOffset === null
|
||||
? this._offset
|
||||
: this._packetOffset;
|
||||
var sliceLength = sliceEnd - sliceStart;
|
||||
|
||||
// Get chunk data
|
||||
var buffer = null;
|
||||
var chunks = !(chunk instanceof Array || Array.isArray(chunk)) ? [chunk] : chunk;
|
||||
var length = 0;
|
||||
var offset = 0;
|
||||
|
||||
for (var i = 0; i < chunks.length; i++) {
|
||||
length += chunks[i].length;
|
||||
}
|
||||
|
||||
if (sliceLength !== 0) {
|
||||
// Create a new Buffer
|
||||
buffer = Buffer.allocUnsafe(sliceLength + length);
|
||||
offset = 0;
|
||||
|
||||
// Copy data slice
|
||||
offset += this._buffer.copy(buffer, 0, sliceStart, sliceEnd);
|
||||
|
||||
// Copy chunks
|
||||
for (var i = 0; i < chunks.length; i++) {
|
||||
offset += chunks[i].copy(buffer, offset);
|
||||
}
|
||||
} else if (chunks.length > 1) {
|
||||
// Create a new Buffer
|
||||
buffer = Buffer.allocUnsafe(length);
|
||||
offset = 0;
|
||||
|
||||
// Copy chunks
|
||||
for (var i = 0; i < chunks.length; i++) {
|
||||
offset += chunks[i].copy(buffer, offset);
|
||||
}
|
||||
} else {
|
||||
// Buffer is the only chunk
|
||||
buffer = chunks[0];
|
||||
}
|
||||
|
||||
// Adjust data-tracking pointers
|
||||
this._buffer = buffer;
|
||||
this._offset = this._offset - sliceStart;
|
||||
this._packetEnd = this._packetEnd !== null
|
||||
? this._packetEnd - sliceStart
|
||||
: null;
|
||||
this._packetOffset = this._packetOffset !== null
|
||||
? this._packetOffset - sliceStart
|
||||
: null;
|
||||
};
|
||||
|
||||
Parser.prototype.pause = function() {
|
||||
this._paused = true;
|
||||
};
|
||||
|
||||
Parser.prototype.resume = function() {
|
||||
this._paused = false;
|
||||
|
||||
// nextTick() to avoid entering write() multiple times within the same stack
|
||||
// which would cause problems as write manipulates the state of the object.
|
||||
process.nextTick(this.write.bind(this));
|
||||
};
|
||||
|
||||
Parser.prototype.peak = function peak(offset) {
|
||||
return this._buffer[this._offset + (offset >>> 0)];
|
||||
};
|
||||
|
||||
Parser.prototype.parseUnsignedNumber = function parseUnsignedNumber(bytes) {
|
||||
if (bytes === 1) {
|
||||
return this._buffer[this._offset++];
|
||||
}
|
||||
|
||||
var buffer = this._buffer;
|
||||
var offset = this._offset + bytes - 1;
|
||||
var value = 0;
|
||||
|
||||
if (bytes > 4) {
|
||||
var err = new Error('parseUnsignedNumber: Supports only up to 4 bytes');
|
||||
err.offset = (this._offset - this._packetOffset - 1);
|
||||
err.code = 'PARSER_UNSIGNED_TOO_LONG';
|
||||
throw err;
|
||||
}
|
||||
|
||||
while (offset >= this._offset) {
|
||||
value = ((value << 8) | buffer[offset]) >>> 0;
|
||||
offset--;
|
||||
}
|
||||
|
||||
this._offset += bytes;
|
||||
|
||||
return value;
|
||||
};
|
||||
|
||||
Parser.prototype.parseLengthCodedString = function() {
|
||||
var length = this.parseLengthCodedNumber();
|
||||
|
||||
if (length === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return this.parseString(length);
|
||||
};
|
||||
|
||||
Parser.prototype.parseLengthCodedBuffer = function() {
|
||||
var length = this.parseLengthCodedNumber();
|
||||
|
||||
if (length === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return this.parseBuffer(length);
|
||||
};
|
||||
|
||||
Parser.prototype.parseLengthCodedNumber = function parseLengthCodedNumber() {
|
||||
if (this._offset >= this._buffer.length) {
|
||||
var err = new Error('Parser: read past end');
|
||||
err.offset = (this._offset - this._packetOffset);
|
||||
err.code = 'PARSER_READ_PAST_END';
|
||||
throw err;
|
||||
}
|
||||
|
||||
var bits = this._buffer[this._offset++];
|
||||
|
||||
if (bits <= 250) {
|
||||
return bits;
|
||||
}
|
||||
|
||||
switch (bits) {
|
||||
case 251:
|
||||
return null;
|
||||
case 252:
|
||||
return this.parseUnsignedNumber(2);
|
||||
case 253:
|
||||
return this.parseUnsignedNumber(3);
|
||||
case 254:
|
||||
break;
|
||||
default:
|
||||
var err = new Error('Unexpected first byte' + (bits ? ': 0x' + bits.toString(16) : ''));
|
||||
err.offset = (this._offset - this._packetOffset - 1);
|
||||
err.code = 'PARSER_BAD_LENGTH_BYTE';
|
||||
throw err;
|
||||
}
|
||||
|
||||
var low = this.parseUnsignedNumber(4);
|
||||
var high = this.parseUnsignedNumber(4);
|
||||
var value;
|
||||
|
||||
if (high >>> 21) {
|
||||
value = BigNumber(MUL_32BIT).times(high).plus(low).toString();
|
||||
|
||||
if (this._supportBigNumbers) {
|
||||
return value;
|
||||
}
|
||||
|
||||
var err = new Error(
|
||||
'parseLengthCodedNumber: JS precision range exceeded, ' +
|
||||
'number is >= 53 bit: "' + value + '"'
|
||||
);
|
||||
err.offset = (this._offset - this._packetOffset - 8);
|
||||
err.code = 'PARSER_JS_PRECISION_RANGE_EXCEEDED';
|
||||
throw err;
|
||||
}
|
||||
|
||||
value = low + (MUL_32BIT * high);
|
||||
|
||||
return value;
|
||||
};
|
||||
|
||||
Parser.prototype.parseFiller = function(length) {
|
||||
return this.parseBuffer(length);
|
||||
};
|
||||
|
||||
Parser.prototype.parseNullTerminatedBuffer = function() {
|
||||
var end = this._nullByteOffset();
|
||||
var value = this._buffer.slice(this._offset, end);
|
||||
this._offset = end + 1;
|
||||
|
||||
return value;
|
||||
};
|
||||
|
||||
Parser.prototype.parseNullTerminatedString = function() {
|
||||
var end = this._nullByteOffset();
|
||||
var value = this._buffer.toString(this._encoding, this._offset, end);
|
||||
this._offset = end + 1;
|
||||
|
||||
return value;
|
||||
};
|
||||
|
||||
Parser.prototype._nullByteOffset = function() {
|
||||
var offset = this._offset;
|
||||
|
||||
while (this._buffer[offset] !== 0x00) {
|
||||
offset++;
|
||||
|
||||
if (offset >= this._buffer.length) {
|
||||
var err = new Error('Offset of null terminated string not found.');
|
||||
err.offset = (this._offset - this._packetOffset);
|
||||
err.code = 'PARSER_MISSING_NULL_BYTE';
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
return offset;
|
||||
};
|
||||
|
||||
Parser.prototype.parsePacketTerminatedBuffer = function parsePacketTerminatedBuffer() {
|
||||
var length = this._packetEnd - this._offset;
|
||||
return this.parseBuffer(length);
|
||||
};
|
||||
|
||||
Parser.prototype.parsePacketTerminatedString = function() {
|
||||
var length = this._packetEnd - this._offset;
|
||||
return this.parseString(length);
|
||||
};
|
||||
|
||||
Parser.prototype.parseBuffer = function(length) {
|
||||
var response = Buffer.alloc(length);
|
||||
this._buffer.copy(response, 0, this._offset, this._offset + length);
|
||||
|
||||
this._offset += length;
|
||||
return response;
|
||||
};
|
||||
|
||||
Parser.prototype.parseString = function(length) {
|
||||
var offset = this._offset;
|
||||
var end = offset + length;
|
||||
var value = this._buffer.toString(this._encoding, offset, end);
|
||||
|
||||
this._offset = end;
|
||||
return value;
|
||||
};
|
||||
|
||||
Parser.prototype.parseGeometryValue = function() {
|
||||
var buffer = this.parseLengthCodedBuffer();
|
||||
var offset = 4;
|
||||
|
||||
if (buffer === null || !buffer.length) {
|
||||
return null;
|
||||
}
|
||||
|
||||
function parseGeometry() {
|
||||
var result = null;
|
||||
var byteOrder = buffer.readUInt8(offset); offset += 1;
|
||||
var wkbType = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); offset += 4;
|
||||
switch (wkbType) {
|
||||
case 1: // WKBPoint
|
||||
var x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
var y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
result = {x: x, y: y};
|
||||
break;
|
||||
case 2: // WKBLineString
|
||||
var numPoints = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); offset += 4;
|
||||
result = [];
|
||||
for (var i = numPoints; i > 0; i--) {
|
||||
var x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
var y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
result.push({x: x, y: y});
|
||||
}
|
||||
break;
|
||||
case 3: // WKBPolygon
|
||||
var numRings = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); offset += 4;
|
||||
result = [];
|
||||
for (var i = numRings; i > 0; i--) {
|
||||
var numPoints = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); offset += 4;
|
||||
var line = [];
|
||||
for (var j = numPoints; j > 0; j--) {
|
||||
var x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
var y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
line.push({x: x, y: y});
|
||||
}
|
||||
result.push(line);
|
||||
}
|
||||
break;
|
||||
case 4: // WKBMultiPoint
|
||||
case 5: // WKBMultiLineString
|
||||
case 6: // WKBMultiPolygon
|
||||
case 7: // WKBGeometryCollection
|
||||
var num = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); offset += 4;
|
||||
var result = [];
|
||||
for (var i = num; i > 0; i--) {
|
||||
result.push(parseGeometry());
|
||||
}
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
return parseGeometry();
|
||||
};
|
||||
|
||||
Parser.prototype.reachedPacketEnd = function() {
|
||||
return this._offset === this._packetEnd;
|
||||
};
|
||||
|
||||
Parser.prototype.incrementPacketNumber = function() {
|
||||
var currentPacketNumber = this._nextPacketNumber;
|
||||
this._nextPacketNumber = (this._nextPacketNumber + 1) % 256;
|
||||
|
||||
return currentPacketNumber;
|
||||
};
|
||||
|
||||
Parser.prototype.resetPacketNumber = function() {
|
||||
this._nextPacketNumber = 0;
|
||||
};
|
||||
|
||||
Parser.prototype.packetLength = function packetLength() {
|
||||
if (!this._packetHeader) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return this._packetHeader.length + this._longPacketBuffers.size;
|
||||
};
|
||||
|
||||
Parser.prototype._combineNextBuffers = function _combineNextBuffers(bytes) {
|
||||
var length = this._buffer.length - this._offset;
|
||||
|
||||
if (length >= bytes) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if ((length + this._nextBuffers.size) < bytes) {
|
||||
return false;
|
||||
}
|
||||
|
||||
var buffers = [];
|
||||
var bytesNeeded = bytes - length;
|
||||
|
||||
while (bytesNeeded > 0) {
|
||||
var buffer = this._nextBuffers.shift();
|
||||
buffers.push(buffer);
|
||||
bytesNeeded -= buffer.length;
|
||||
}
|
||||
|
||||
this.append(buffers);
|
||||
return true;
|
||||
};
|
||||
|
||||
Parser.prototype._combineLongPacketBuffers = function _combineLongPacketBuffers() {
|
||||
if (!this._longPacketBuffers.size) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Calculate bytes
|
||||
var remainingBytes = this._buffer.length - this._offset;
|
||||
var trailingPacketBytes = this._buffer.length - this._packetEnd;
|
||||
|
||||
// Create buffer
|
||||
var buf = null;
|
||||
var buffer = Buffer.allocUnsafe(remainingBytes + this._longPacketBuffers.size);
|
||||
var offset = 0;
|
||||
|
||||
// Copy long buffers
|
||||
while ((buf = this._longPacketBuffers.shift())) {
|
||||
offset += buf.copy(buffer, offset);
|
||||
}
|
||||
|
||||
// Copy remaining bytes
|
||||
this._buffer.copy(buffer, offset, this._offset);
|
||||
|
||||
this._buffer = buffer;
|
||||
this._offset = 0;
|
||||
this._packetEnd = this._buffer.length - trailingPacketBytes;
|
||||
this._packetOffset = 0;
|
||||
};
|
||||
|
||||
Parser.prototype._parsePacket = function _parsePacket(packetHeader) {
|
||||
this._packetEnd = this._offset + packetHeader.length;
|
||||
this._packetOffset = this._offset;
|
||||
|
||||
if (packetHeader.length === MAX_PACKET_LENGTH) {
|
||||
this._longPacketBuffers.push(this._buffer.slice(this._packetOffset, this._packetEnd));
|
||||
this._advanceToNextPacket();
|
||||
return;
|
||||
}
|
||||
|
||||
this._combineLongPacketBuffers();
|
||||
|
||||
var hadException = true;
|
||||
try {
|
||||
this._onPacket(packetHeader);
|
||||
hadException = false;
|
||||
} catch (err) {
|
||||
if (!err || typeof err.code !== 'string' || err.code.substr(0, 7) !== 'PARSER_') {
|
||||
throw err; // Rethrow non-MySQL errors
|
||||
}
|
||||
|
||||
// Pass down parser errors
|
||||
this._onError(err);
|
||||
hadException = false;
|
||||
} finally {
|
||||
this._advanceToNextPacket();
|
||||
|
||||
// If there was an exception, the parser while loop will be broken out
|
||||
// of after the finally block. So schedule a blank write to re-enter it
|
||||
// to continue parsing any bytes that may already have been received.
|
||||
if (hadException) {
|
||||
process.nextTick(this.write.bind(this));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Parser.prototype._tryReadPacketHeader = function _tryReadPacketHeader() {
|
||||
if (this._packetHeader) {
|
||||
return this._packetHeader;
|
||||
}
|
||||
|
||||
if (!this._combineNextBuffers(PACKET_HEADER_LENGTH)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
this._packetHeader = new PacketHeader(
|
||||
this.parseUnsignedNumber(3),
|
||||
this.parseUnsignedNumber(1)
|
||||
);
|
||||
|
||||
if (this._packetHeader.number !== this._nextPacketNumber) {
|
||||
var err = new Error(
|
||||
'Packets out of order. Got: ' + this._packetHeader.number + ' ' +
|
||||
'Expected: ' + this._nextPacketNumber
|
||||
);
|
||||
|
||||
err.code = 'PROTOCOL_PACKETS_OUT_OF_ORDER';
|
||||
err.fatal = true;
|
||||
|
||||
this._onError(err);
|
||||
}
|
||||
|
||||
this.incrementPacketNumber();
|
||||
|
||||
return this._packetHeader;
|
||||
};
|
||||
|
||||
Parser.prototype._advanceToNextPacket = function() {
|
||||
this._offset = this._packetEnd;
|
||||
this._packetHeader = null;
|
||||
this._packetEnd = null;
|
||||
this._packetOffset = null;
|
||||
};
|
||||
463
node_modules/mysql/lib/protocol/Protocol.js
generated
vendored
Normal file
463
node_modules/mysql/lib/protocol/Protocol.js
generated
vendored
Normal file
@ -0,0 +1,463 @@
|
||||
var Parser = require('./Parser');
|
||||
var Sequences = require('./sequences');
|
||||
var Packets = require('./packets');
|
||||
var Stream = require('stream').Stream;
|
||||
var Util = require('util');
|
||||
var PacketWriter = require('./PacketWriter');
|
||||
|
||||
module.exports = Protocol;
|
||||
Util.inherits(Protocol, Stream);
|
||||
function Protocol(options) {
|
||||
Stream.call(this);
|
||||
|
||||
options = options || {};
|
||||
|
||||
this.readable = true;
|
||||
this.writable = true;
|
||||
|
||||
this._config = options.config || {};
|
||||
this._connection = options.connection;
|
||||
this._callback = null;
|
||||
this._fatalError = null;
|
||||
this._quitSequence = null;
|
||||
this._handshake = false;
|
||||
this._handshaked = false;
|
||||
this._ended = false;
|
||||
this._destroyed = false;
|
||||
this._queue = [];
|
||||
this._handshakeInitializationPacket = null;
|
||||
|
||||
this._parser = new Parser({
|
||||
onError : this.handleParserError.bind(this),
|
||||
onPacket : this._parsePacket.bind(this),
|
||||
config : this._config
|
||||
});
|
||||
}
|
||||
|
||||
Protocol.prototype.write = function(buffer) {
|
||||
this._parser.write(buffer);
|
||||
return true;
|
||||
};
|
||||
|
||||
Protocol.prototype.handshake = function handshake(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
options = options || {};
|
||||
options.config = this._config;
|
||||
|
||||
var sequence = this._enqueue(new Sequences.Handshake(options, callback));
|
||||
|
||||
this._handshake = true;
|
||||
|
||||
return sequence;
|
||||
};
|
||||
|
||||
Protocol.prototype.query = function query(options, callback) {
|
||||
return this._enqueue(new Sequences.Query(options, callback));
|
||||
};
|
||||
|
||||
Protocol.prototype.changeUser = function changeUser(options, callback) {
|
||||
return this._enqueue(new Sequences.ChangeUser(options, callback));
|
||||
};
|
||||
|
||||
Protocol.prototype.ping = function ping(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
return this._enqueue(new Sequences.Ping(options, callback));
|
||||
};
|
||||
|
||||
Protocol.prototype.stats = function stats(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
return this._enqueue(new Sequences.Statistics(options, callback));
|
||||
};
|
||||
|
||||
Protocol.prototype.quit = function quit(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
var self = this;
|
||||
var sequence = this._enqueue(new Sequences.Quit(options, callback));
|
||||
|
||||
sequence.on('end', function () {
|
||||
self.end();
|
||||
});
|
||||
|
||||
return this._quitSequence = sequence;
|
||||
};
|
||||
|
||||
Protocol.prototype.end = function() {
|
||||
if (this._ended) {
|
||||
return;
|
||||
}
|
||||
this._ended = true;
|
||||
|
||||
if (this._quitSequence && (this._quitSequence._ended || this._queue[0] === this._quitSequence)) {
|
||||
this._quitSequence.end();
|
||||
this.emit('end');
|
||||
return;
|
||||
}
|
||||
|
||||
var err = new Error('Connection lost: The server closed the connection.');
|
||||
err.fatal = true;
|
||||
err.code = 'PROTOCOL_CONNECTION_LOST';
|
||||
|
||||
this._delegateError(err);
|
||||
};
|
||||
|
||||
Protocol.prototype.pause = function() {
|
||||
this._parser.pause();
|
||||
// Since there is a file stream in query, we must transmit pause/resume event to current sequence.
|
||||
var seq = this._queue[0];
|
||||
if (seq && seq.emit) {
|
||||
seq.emit('pause');
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype.resume = function() {
|
||||
this._parser.resume();
|
||||
// Since there is a file stream in query, we must transmit pause/resume event to current sequence.
|
||||
var seq = this._queue[0];
|
||||
if (seq && seq.emit) {
|
||||
seq.emit('resume');
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._enqueue = function(sequence) {
|
||||
if (!this._validateEnqueue(sequence)) {
|
||||
return sequence;
|
||||
}
|
||||
|
||||
if (this._config.trace) {
|
||||
// Long stack trace support
|
||||
sequence._callSite = sequence._callSite || new Error();
|
||||
}
|
||||
|
||||
this._queue.push(sequence);
|
||||
this.emit('enqueue', sequence);
|
||||
|
||||
var self = this;
|
||||
sequence
|
||||
.on('error', function(err) {
|
||||
self._delegateError(err, sequence);
|
||||
})
|
||||
.on('packet', function(packet) {
|
||||
sequence._timer.active();
|
||||
self._emitPacket(packet);
|
||||
})
|
||||
.on('timeout', function() {
|
||||
var err = new Error(sequence.constructor.name + ' inactivity timeout');
|
||||
|
||||
err.code = 'PROTOCOL_SEQUENCE_TIMEOUT';
|
||||
err.fatal = true;
|
||||
err.timeout = sequence._timeout;
|
||||
|
||||
self._delegateError(err, sequence);
|
||||
});
|
||||
|
||||
if (sequence.constructor === Sequences.Handshake) {
|
||||
sequence.on('start-tls', function () {
|
||||
sequence._timer.active();
|
||||
self._connection._startTLS(function(err) {
|
||||
if (err) {
|
||||
// SSL negotiation error are fatal
|
||||
err.code = 'HANDSHAKE_SSL_ERROR';
|
||||
err.fatal = true;
|
||||
sequence.end(err);
|
||||
return;
|
||||
}
|
||||
|
||||
sequence._timer.active();
|
||||
sequence._tlsUpgradeCompleteHandler();
|
||||
});
|
||||
});
|
||||
|
||||
sequence.on('end', function () {
|
||||
self._handshaked = true;
|
||||
|
||||
if (!self._fatalError) {
|
||||
self.emit('handshake', self._handshakeInitializationPacket);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
sequence.on('end', function () {
|
||||
self._dequeue(sequence);
|
||||
});
|
||||
|
||||
if (this._queue.length === 1) {
|
||||
this._parser.resetPacketNumber();
|
||||
this._startSequence(sequence);
|
||||
}
|
||||
|
||||
return sequence;
|
||||
};
|
||||
|
||||
Protocol.prototype._validateEnqueue = function _validateEnqueue(sequence) {
|
||||
var err;
|
||||
var prefix = 'Cannot enqueue ' + sequence.constructor.name;
|
||||
|
||||
if (this._fatalError) {
|
||||
err = new Error(prefix + ' after fatal error.');
|
||||
err.code = 'PROTOCOL_ENQUEUE_AFTER_FATAL_ERROR';
|
||||
} else if (this._quitSequence) {
|
||||
err = new Error(prefix + ' after invoking quit.');
|
||||
err.code = 'PROTOCOL_ENQUEUE_AFTER_QUIT';
|
||||
} else if (this._destroyed) {
|
||||
err = new Error(prefix + ' after being destroyed.');
|
||||
err.code = 'PROTOCOL_ENQUEUE_AFTER_DESTROY';
|
||||
} else if ((this._handshake || this._handshaked) && sequence.constructor === Sequences.Handshake) {
|
||||
err = new Error(prefix + ' after already enqueuing a Handshake.');
|
||||
err.code = 'PROTOCOL_ENQUEUE_HANDSHAKE_TWICE';
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
|
||||
var self = this;
|
||||
err.fatal = false;
|
||||
|
||||
// add error handler
|
||||
sequence.on('error', function (err) {
|
||||
self._delegateError(err, sequence);
|
||||
});
|
||||
|
||||
process.nextTick(function () {
|
||||
sequence.end(err);
|
||||
});
|
||||
|
||||
return false;
|
||||
};
|
||||
|
||||
Protocol.prototype._parsePacket = function() {
|
||||
var sequence = this._queue[0];
|
||||
|
||||
if (!sequence) {
|
||||
var err = new Error('Received packet with no active sequence.');
|
||||
err.code = 'PROTOCOL_STRAY_PACKET';
|
||||
err.fatal = true;
|
||||
|
||||
this._delegateError(err);
|
||||
return;
|
||||
}
|
||||
|
||||
var Packet = this._determinePacket(sequence);
|
||||
var packet = new Packet({protocol41: this._config.protocol41});
|
||||
var packetName = Packet.name;
|
||||
|
||||
// Special case: Faster dispatch, and parsing done inside sequence
|
||||
if (Packet === Packets.RowDataPacket) {
|
||||
sequence.RowDataPacket(packet, this._parser, this._connection);
|
||||
|
||||
if (this._config.debug) {
|
||||
this._debugPacket(true, packet);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (this._config.debug) {
|
||||
this._parsePacketDebug(packet);
|
||||
} else {
|
||||
packet.parse(this._parser);
|
||||
}
|
||||
|
||||
if (Packet === Packets.HandshakeInitializationPacket) {
|
||||
this._handshakeInitializationPacket = packet;
|
||||
this.emit('initialize', packet);
|
||||
}
|
||||
|
||||
sequence._timer.active();
|
||||
|
||||
if (!sequence[packetName]) {
|
||||
var err = new Error('Received packet in the wrong sequence.');
|
||||
err.code = 'PROTOCOL_INCORRECT_PACKET_SEQUENCE';
|
||||
err.fatal = true;
|
||||
|
||||
this._delegateError(err);
|
||||
return;
|
||||
}
|
||||
|
||||
sequence[packetName](packet);
|
||||
};
|
||||
|
||||
Protocol.prototype._parsePacketDebug = function _parsePacketDebug(packet) {
|
||||
try {
|
||||
packet.parse(this._parser);
|
||||
} finally {
|
||||
this._debugPacket(true, packet);
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._emitPacket = function(packet) {
|
||||
var packetWriter = new PacketWriter();
|
||||
packet.write(packetWriter);
|
||||
this.emit('data', packetWriter.toBuffer(this._parser));
|
||||
|
||||
if (this._config.debug) {
|
||||
this._debugPacket(false, packet);
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._determinePacket = function(sequence) {
|
||||
var firstByte = this._parser.peak();
|
||||
|
||||
if (sequence.determinePacket) {
|
||||
var Packet = sequence.determinePacket(firstByte, this._parser);
|
||||
if (Packet) {
|
||||
return Packet;
|
||||
}
|
||||
}
|
||||
|
||||
switch (firstByte) {
|
||||
case 0x00: return Packets.OkPacket;
|
||||
case 0xfe: return Packets.EofPacket;
|
||||
case 0xff: return Packets.ErrorPacket;
|
||||
}
|
||||
|
||||
throw new Error('Could not determine packet, firstByte = ' + firstByte);
|
||||
};
|
||||
|
||||
Protocol.prototype._dequeue = function(sequence) {
|
||||
sequence._timer.stop();
|
||||
|
||||
// No point in advancing the queue, we are dead
|
||||
if (this._fatalError) {
|
||||
return;
|
||||
}
|
||||
|
||||
this._queue.shift();
|
||||
|
||||
var sequence = this._queue[0];
|
||||
if (!sequence) {
|
||||
this.emit('drain');
|
||||
return;
|
||||
}
|
||||
|
||||
this._parser.resetPacketNumber();
|
||||
|
||||
this._startSequence(sequence);
|
||||
};
|
||||
|
||||
Protocol.prototype._startSequence = function(sequence) {
|
||||
if (sequence._timeout > 0 && isFinite(sequence._timeout)) {
|
||||
sequence._timer.start(sequence._timeout);
|
||||
}
|
||||
|
||||
if (sequence.constructor === Sequences.ChangeUser) {
|
||||
sequence.start(this._handshakeInitializationPacket);
|
||||
} else {
|
||||
sequence.start();
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype.handleNetworkError = function(err) {
|
||||
err.fatal = true;
|
||||
|
||||
var sequence = this._queue[0];
|
||||
if (sequence) {
|
||||
sequence.end(err);
|
||||
} else {
|
||||
this._delegateError(err);
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype.handleParserError = function handleParserError(err) {
|
||||
var sequence = this._queue[0];
|
||||
if (sequence) {
|
||||
sequence.end(err);
|
||||
} else {
|
||||
this._delegateError(err);
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._delegateError = function(err, sequence) {
|
||||
// Stop delegating errors after the first fatal error
|
||||
if (this._fatalError) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (err.fatal) {
|
||||
this._fatalError = err;
|
||||
}
|
||||
|
||||
if (this._shouldErrorBubbleUp(err, sequence)) {
|
||||
// Can't use regular 'error' event here as that always destroys the pipe
|
||||
// between socket and protocol which is not what we want (unless the
|
||||
// exception was fatal).
|
||||
this.emit('unhandledError', err);
|
||||
} else if (err.fatal) {
|
||||
// Send fatal error to all sequences in the queue
|
||||
var queue = this._queue;
|
||||
process.nextTick(function () {
|
||||
queue.forEach(function (sequence) {
|
||||
sequence.end(err);
|
||||
});
|
||||
queue.length = 0;
|
||||
});
|
||||
}
|
||||
|
||||
// Make sure the stream we are piping to is getting closed
|
||||
if (err.fatal) {
|
||||
this.emit('end', err);
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._shouldErrorBubbleUp = function(err, sequence) {
|
||||
if (sequence) {
|
||||
if (sequence.hasErrorHandler()) {
|
||||
return false;
|
||||
} else if (!err.fatal) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return (err.fatal && !this._hasPendingErrorHandlers());
|
||||
};
|
||||
|
||||
Protocol.prototype._hasPendingErrorHandlers = function() {
|
||||
return this._queue.some(function(sequence) {
|
||||
return sequence.hasErrorHandler();
|
||||
});
|
||||
};
|
||||
|
||||
Protocol.prototype.destroy = function() {
|
||||
this._destroyed = true;
|
||||
this._parser.pause();
|
||||
|
||||
if (this._connection.state !== 'disconnected') {
|
||||
if (!this._ended) {
|
||||
this.end();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._debugPacket = function(incoming, packet) {
|
||||
var connection = this._connection;
|
||||
var direction = incoming
|
||||
? '<--'
|
||||
: '-->';
|
||||
var packetName = packet.constructor.name;
|
||||
var threadId = connection && connection.threadId !== null
|
||||
? ' (' + connection.threadId + ')'
|
||||
: '';
|
||||
|
||||
// check for debug packet restriction
|
||||
if (Array.isArray(this._config.debug) && this._config.debug.indexOf(packetName) === -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
var packetPayload = Util.inspect(packet).replace(/^[^{]+/, '');
|
||||
|
||||
console.log('%s%s %s %s\n', direction, threadId, packetName, packetPayload);
|
||||
};
|
||||
7
node_modules/mysql/lib/protocol/ResultSet.js
generated
vendored
Normal file
7
node_modules/mysql/lib/protocol/ResultSet.js
generated
vendored
Normal file
@ -0,0 +1,7 @@
|
||||
module.exports = ResultSet;
|
||||
function ResultSet(resultSetHeaderPacket) {
|
||||
this.resultSetHeaderPacket = resultSetHeaderPacket;
|
||||
this.fieldPackets = [];
|
||||
this.eofPackets = [];
|
||||
this.rows = [];
|
||||
}
|
||||
1
node_modules/mysql/lib/protocol/SqlString.js
generated
vendored
Normal file
1
node_modules/mysql/lib/protocol/SqlString.js
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
module.exports = require('sqlstring');
|
||||
33
node_modules/mysql/lib/protocol/Timer.js
generated
vendored
Normal file
33
node_modules/mysql/lib/protocol/Timer.js
generated
vendored
Normal file
@ -0,0 +1,33 @@
|
||||
var Timers = require('timers');
|
||||
|
||||
module.exports = Timer;
|
||||
function Timer(object) {
|
||||
this._object = object;
|
||||
this._timeout = null;
|
||||
}
|
||||
|
||||
Timer.prototype.active = function active() {
|
||||
if (this._timeout) {
|
||||
if (this._timeout.refresh) {
|
||||
this._timeout.refresh();
|
||||
} else {
|
||||
Timers.active(this._timeout);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Timer.prototype.start = function start(msecs) {
|
||||
this.stop();
|
||||
this._timeout = Timers.setTimeout(this._onTimeout.bind(this), msecs);
|
||||
};
|
||||
|
||||
Timer.prototype.stop = function stop() {
|
||||
if (this._timeout) {
|
||||
Timers.clearTimeout(this._timeout);
|
||||
this._timeout = null;
|
||||
}
|
||||
};
|
||||
|
||||
Timer.prototype._onTimeout = function _onTimeout() {
|
||||
return this._object._onTimeout();
|
||||
};
|
||||
262
node_modules/mysql/lib/protocol/constants/charsets.js
generated
vendored
Normal file
262
node_modules/mysql/lib/protocol/constants/charsets.js
generated
vendored
Normal file
@ -0,0 +1,262 @@
|
||||
exports.BIG5_CHINESE_CI = 1;
|
||||
exports.LATIN2_CZECH_CS = 2;
|
||||
exports.DEC8_SWEDISH_CI = 3;
|
||||
exports.CP850_GENERAL_CI = 4;
|
||||
exports.LATIN1_GERMAN1_CI = 5;
|
||||
exports.HP8_ENGLISH_CI = 6;
|
||||
exports.KOI8R_GENERAL_CI = 7;
|
||||
exports.LATIN1_SWEDISH_CI = 8;
|
||||
exports.LATIN2_GENERAL_CI = 9;
|
||||
exports.SWE7_SWEDISH_CI = 10;
|
||||
exports.ASCII_GENERAL_CI = 11;
|
||||
exports.UJIS_JAPANESE_CI = 12;
|
||||
exports.SJIS_JAPANESE_CI = 13;
|
||||
exports.CP1251_BULGARIAN_CI = 14;
|
||||
exports.LATIN1_DANISH_CI = 15;
|
||||
exports.HEBREW_GENERAL_CI = 16;
|
||||
exports.TIS620_THAI_CI = 18;
|
||||
exports.EUCKR_KOREAN_CI = 19;
|
||||
exports.LATIN7_ESTONIAN_CS = 20;
|
||||
exports.LATIN2_HUNGARIAN_CI = 21;
|
||||
exports.KOI8U_GENERAL_CI = 22;
|
||||
exports.CP1251_UKRAINIAN_CI = 23;
|
||||
exports.GB2312_CHINESE_CI = 24;
|
||||
exports.GREEK_GENERAL_CI = 25;
|
||||
exports.CP1250_GENERAL_CI = 26;
|
||||
exports.LATIN2_CROATIAN_CI = 27;
|
||||
exports.GBK_CHINESE_CI = 28;
|
||||
exports.CP1257_LITHUANIAN_CI = 29;
|
||||
exports.LATIN5_TURKISH_CI = 30;
|
||||
exports.LATIN1_GERMAN2_CI = 31;
|
||||
exports.ARMSCII8_GENERAL_CI = 32;
|
||||
exports.UTF8_GENERAL_CI = 33;
|
||||
exports.CP1250_CZECH_CS = 34;
|
||||
exports.UCS2_GENERAL_CI = 35;
|
||||
exports.CP866_GENERAL_CI = 36;
|
||||
exports.KEYBCS2_GENERAL_CI = 37;
|
||||
exports.MACCE_GENERAL_CI = 38;
|
||||
exports.MACROMAN_GENERAL_CI = 39;
|
||||
exports.CP852_GENERAL_CI = 40;
|
||||
exports.LATIN7_GENERAL_CI = 41;
|
||||
exports.LATIN7_GENERAL_CS = 42;
|
||||
exports.MACCE_BIN = 43;
|
||||
exports.CP1250_CROATIAN_CI = 44;
|
||||
exports.UTF8MB4_GENERAL_CI = 45;
|
||||
exports.UTF8MB4_BIN = 46;
|
||||
exports.LATIN1_BIN = 47;
|
||||
exports.LATIN1_GENERAL_CI = 48;
|
||||
exports.LATIN1_GENERAL_CS = 49;
|
||||
exports.CP1251_BIN = 50;
|
||||
exports.CP1251_GENERAL_CI = 51;
|
||||
exports.CP1251_GENERAL_CS = 52;
|
||||
exports.MACROMAN_BIN = 53;
|
||||
exports.UTF16_GENERAL_CI = 54;
|
||||
exports.UTF16_BIN = 55;
|
||||
exports.UTF16LE_GENERAL_CI = 56;
|
||||
exports.CP1256_GENERAL_CI = 57;
|
||||
exports.CP1257_BIN = 58;
|
||||
exports.CP1257_GENERAL_CI = 59;
|
||||
exports.UTF32_GENERAL_CI = 60;
|
||||
exports.UTF32_BIN = 61;
|
||||
exports.UTF16LE_BIN = 62;
|
||||
exports.BINARY = 63;
|
||||
exports.ARMSCII8_BIN = 64;
|
||||
exports.ASCII_BIN = 65;
|
||||
exports.CP1250_BIN = 66;
|
||||
exports.CP1256_BIN = 67;
|
||||
exports.CP866_BIN = 68;
|
||||
exports.DEC8_BIN = 69;
|
||||
exports.GREEK_BIN = 70;
|
||||
exports.HEBREW_BIN = 71;
|
||||
exports.HP8_BIN = 72;
|
||||
exports.KEYBCS2_BIN = 73;
|
||||
exports.KOI8R_BIN = 74;
|
||||
exports.KOI8U_BIN = 75;
|
||||
exports.LATIN2_BIN = 77;
|
||||
exports.LATIN5_BIN = 78;
|
||||
exports.LATIN7_BIN = 79;
|
||||
exports.CP850_BIN = 80;
|
||||
exports.CP852_BIN = 81;
|
||||
exports.SWE7_BIN = 82;
|
||||
exports.UTF8_BIN = 83;
|
||||
exports.BIG5_BIN = 84;
|
||||
exports.EUCKR_BIN = 85;
|
||||
exports.GB2312_BIN = 86;
|
||||
exports.GBK_BIN = 87;
|
||||
exports.SJIS_BIN = 88;
|
||||
exports.TIS620_BIN = 89;
|
||||
exports.UCS2_BIN = 90;
|
||||
exports.UJIS_BIN = 91;
|
||||
exports.GEOSTD8_GENERAL_CI = 92;
|
||||
exports.GEOSTD8_BIN = 93;
|
||||
exports.LATIN1_SPANISH_CI = 94;
|
||||
exports.CP932_JAPANESE_CI = 95;
|
||||
exports.CP932_BIN = 96;
|
||||
exports.EUCJPMS_JAPANESE_CI = 97;
|
||||
exports.EUCJPMS_BIN = 98;
|
||||
exports.CP1250_POLISH_CI = 99;
|
||||
exports.UTF16_UNICODE_CI = 101;
|
||||
exports.UTF16_ICELANDIC_CI = 102;
|
||||
exports.UTF16_LATVIAN_CI = 103;
|
||||
exports.UTF16_ROMANIAN_CI = 104;
|
||||
exports.UTF16_SLOVENIAN_CI = 105;
|
||||
exports.UTF16_POLISH_CI = 106;
|
||||
exports.UTF16_ESTONIAN_CI = 107;
|
||||
exports.UTF16_SPANISH_CI = 108;
|
||||
exports.UTF16_SWEDISH_CI = 109;
|
||||
exports.UTF16_TURKISH_CI = 110;
|
||||
exports.UTF16_CZECH_CI = 111;
|
||||
exports.UTF16_DANISH_CI = 112;
|
||||
exports.UTF16_LITHUANIAN_CI = 113;
|
||||
exports.UTF16_SLOVAK_CI = 114;
|
||||
exports.UTF16_SPANISH2_CI = 115;
|
||||
exports.UTF16_ROMAN_CI = 116;
|
||||
exports.UTF16_PERSIAN_CI = 117;
|
||||
exports.UTF16_ESPERANTO_CI = 118;
|
||||
exports.UTF16_HUNGARIAN_CI = 119;
|
||||
exports.UTF16_SINHALA_CI = 120;
|
||||
exports.UTF16_GERMAN2_CI = 121;
|
||||
exports.UTF16_CROATIAN_MYSQL561_CI = 122;
|
||||
exports.UTF16_UNICODE_520_CI = 123;
|
||||
exports.UTF16_VIETNAMESE_CI = 124;
|
||||
exports.UCS2_UNICODE_CI = 128;
|
||||
exports.UCS2_ICELANDIC_CI = 129;
|
||||
exports.UCS2_LATVIAN_CI = 130;
|
||||
exports.UCS2_ROMANIAN_CI = 131;
|
||||
exports.UCS2_SLOVENIAN_CI = 132;
|
||||
exports.UCS2_POLISH_CI = 133;
|
||||
exports.UCS2_ESTONIAN_CI = 134;
|
||||
exports.UCS2_SPANISH_CI = 135;
|
||||
exports.UCS2_SWEDISH_CI = 136;
|
||||
exports.UCS2_TURKISH_CI = 137;
|
||||
exports.UCS2_CZECH_CI = 138;
|
||||
exports.UCS2_DANISH_CI = 139;
|
||||
exports.UCS2_LITHUANIAN_CI = 140;
|
||||
exports.UCS2_SLOVAK_CI = 141;
|
||||
exports.UCS2_SPANISH2_CI = 142;
|
||||
exports.UCS2_ROMAN_CI = 143;
|
||||
exports.UCS2_PERSIAN_CI = 144;
|
||||
exports.UCS2_ESPERANTO_CI = 145;
|
||||
exports.UCS2_HUNGARIAN_CI = 146;
|
||||
exports.UCS2_SINHALA_CI = 147;
|
||||
exports.UCS2_GERMAN2_CI = 148;
|
||||
exports.UCS2_CROATIAN_MYSQL561_CI = 149;
|
||||
exports.UCS2_UNICODE_520_CI = 150;
|
||||
exports.UCS2_VIETNAMESE_CI = 151;
|
||||
exports.UCS2_GENERAL_MYSQL500_CI = 159;
|
||||
exports.UTF32_UNICODE_CI = 160;
|
||||
exports.UTF32_ICELANDIC_CI = 161;
|
||||
exports.UTF32_LATVIAN_CI = 162;
|
||||
exports.UTF32_ROMANIAN_CI = 163;
|
||||
exports.UTF32_SLOVENIAN_CI = 164;
|
||||
exports.UTF32_POLISH_CI = 165;
|
||||
exports.UTF32_ESTONIAN_CI = 166;
|
||||
exports.UTF32_SPANISH_CI = 167;
|
||||
exports.UTF32_SWEDISH_CI = 168;
|
||||
exports.UTF32_TURKISH_CI = 169;
|
||||
exports.UTF32_CZECH_CI = 170;
|
||||
exports.UTF32_DANISH_CI = 171;
|
||||
exports.UTF32_LITHUANIAN_CI = 172;
|
||||
exports.UTF32_SLOVAK_CI = 173;
|
||||
exports.UTF32_SPANISH2_CI = 174;
|
||||
exports.UTF32_ROMAN_CI = 175;
|
||||
exports.UTF32_PERSIAN_CI = 176;
|
||||
exports.UTF32_ESPERANTO_CI = 177;
|
||||
exports.UTF32_HUNGARIAN_CI = 178;
|
||||
exports.UTF32_SINHALA_CI = 179;
|
||||
exports.UTF32_GERMAN2_CI = 180;
|
||||
exports.UTF32_CROATIAN_MYSQL561_CI = 181;
|
||||
exports.UTF32_UNICODE_520_CI = 182;
|
||||
exports.UTF32_VIETNAMESE_CI = 183;
|
||||
exports.UTF8_UNICODE_CI = 192;
|
||||
exports.UTF8_ICELANDIC_CI = 193;
|
||||
exports.UTF8_LATVIAN_CI = 194;
|
||||
exports.UTF8_ROMANIAN_CI = 195;
|
||||
exports.UTF8_SLOVENIAN_CI = 196;
|
||||
exports.UTF8_POLISH_CI = 197;
|
||||
exports.UTF8_ESTONIAN_CI = 198;
|
||||
exports.UTF8_SPANISH_CI = 199;
|
||||
exports.UTF8_SWEDISH_CI = 200;
|
||||
exports.UTF8_TURKISH_CI = 201;
|
||||
exports.UTF8_CZECH_CI = 202;
|
||||
exports.UTF8_DANISH_CI = 203;
|
||||
exports.UTF8_LITHUANIAN_CI = 204;
|
||||
exports.UTF8_SLOVAK_CI = 205;
|
||||
exports.UTF8_SPANISH2_CI = 206;
|
||||
exports.UTF8_ROMAN_CI = 207;
|
||||
exports.UTF8_PERSIAN_CI = 208;
|
||||
exports.UTF8_ESPERANTO_CI = 209;
|
||||
exports.UTF8_HUNGARIAN_CI = 210;
|
||||
exports.UTF8_SINHALA_CI = 211;
|
||||
exports.UTF8_GERMAN2_CI = 212;
|
||||
exports.UTF8_CROATIAN_MYSQL561_CI = 213;
|
||||
exports.UTF8_UNICODE_520_CI = 214;
|
||||
exports.UTF8_VIETNAMESE_CI = 215;
|
||||
exports.UTF8_GENERAL_MYSQL500_CI = 223;
|
||||
exports.UTF8MB4_UNICODE_CI = 224;
|
||||
exports.UTF8MB4_ICELANDIC_CI = 225;
|
||||
exports.UTF8MB4_LATVIAN_CI = 226;
|
||||
exports.UTF8MB4_ROMANIAN_CI = 227;
|
||||
exports.UTF8MB4_SLOVENIAN_CI = 228;
|
||||
exports.UTF8MB4_POLISH_CI = 229;
|
||||
exports.UTF8MB4_ESTONIAN_CI = 230;
|
||||
exports.UTF8MB4_SPANISH_CI = 231;
|
||||
exports.UTF8MB4_SWEDISH_CI = 232;
|
||||
exports.UTF8MB4_TURKISH_CI = 233;
|
||||
exports.UTF8MB4_CZECH_CI = 234;
|
||||
exports.UTF8MB4_DANISH_CI = 235;
|
||||
exports.UTF8MB4_LITHUANIAN_CI = 236;
|
||||
exports.UTF8MB4_SLOVAK_CI = 237;
|
||||
exports.UTF8MB4_SPANISH2_CI = 238;
|
||||
exports.UTF8MB4_ROMAN_CI = 239;
|
||||
exports.UTF8MB4_PERSIAN_CI = 240;
|
||||
exports.UTF8MB4_ESPERANTO_CI = 241;
|
||||
exports.UTF8MB4_HUNGARIAN_CI = 242;
|
||||
exports.UTF8MB4_SINHALA_CI = 243;
|
||||
exports.UTF8MB4_GERMAN2_CI = 244;
|
||||
exports.UTF8MB4_CROATIAN_MYSQL561_CI = 245;
|
||||
exports.UTF8MB4_UNICODE_520_CI = 246;
|
||||
exports.UTF8MB4_VIETNAMESE_CI = 247;
|
||||
exports.UTF8_GENERAL50_CI = 253;
|
||||
|
||||
// short aliases
|
||||
exports.ARMSCII8 = exports.ARMSCII8_GENERAL_CI;
|
||||
exports.ASCII = exports.ASCII_GENERAL_CI;
|
||||
exports.BIG5 = exports.BIG5_CHINESE_CI;
|
||||
exports.BINARY = exports.BINARY;
|
||||
exports.CP1250 = exports.CP1250_GENERAL_CI;
|
||||
exports.CP1251 = exports.CP1251_GENERAL_CI;
|
||||
exports.CP1256 = exports.CP1256_GENERAL_CI;
|
||||
exports.CP1257 = exports.CP1257_GENERAL_CI;
|
||||
exports.CP866 = exports.CP866_GENERAL_CI;
|
||||
exports.CP850 = exports.CP850_GENERAL_CI;
|
||||
exports.CP852 = exports.CP852_GENERAL_CI;
|
||||
exports.CP932 = exports.CP932_JAPANESE_CI;
|
||||
exports.DEC8 = exports.DEC8_SWEDISH_CI;
|
||||
exports.EUCJPMS = exports.EUCJPMS_JAPANESE_CI;
|
||||
exports.EUCKR = exports.EUCKR_KOREAN_CI;
|
||||
exports.GB2312 = exports.GB2312_CHINESE_CI;
|
||||
exports.GBK = exports.GBK_CHINESE_CI;
|
||||
exports.GEOSTD8 = exports.GEOSTD8_GENERAL_CI;
|
||||
exports.GREEK = exports.GREEK_GENERAL_CI;
|
||||
exports.HEBREW = exports.HEBREW_GENERAL_CI;
|
||||
exports.HP8 = exports.HP8_ENGLISH_CI;
|
||||
exports.KEYBCS2 = exports.KEYBCS2_GENERAL_CI;
|
||||
exports.KOI8R = exports.KOI8R_GENERAL_CI;
|
||||
exports.KOI8U = exports.KOI8U_GENERAL_CI;
|
||||
exports.LATIN1 = exports.LATIN1_SWEDISH_CI;
|
||||
exports.LATIN2 = exports.LATIN2_GENERAL_CI;
|
||||
exports.LATIN5 = exports.LATIN5_TURKISH_CI;
|
||||
exports.LATIN7 = exports.LATIN7_GENERAL_CI;
|
||||
exports.MACCE = exports.MACCE_GENERAL_CI;
|
||||
exports.MACROMAN = exports.MACROMAN_GENERAL_CI;
|
||||
exports.SJIS = exports.SJIS_JAPANESE_CI;
|
||||
exports.SWE7 = exports.SWE7_SWEDISH_CI;
|
||||
exports.TIS620 = exports.TIS620_THAI_CI;
|
||||
exports.UCS2 = exports.UCS2_GENERAL_CI;
|
||||
exports.UJIS = exports.UJIS_JAPANESE_CI;
|
||||
exports.UTF16 = exports.UTF16_GENERAL_CI;
|
||||
exports.UTF16LE = exports.UTF16LE_GENERAL_CI;
|
||||
exports.UTF8 = exports.UTF8_GENERAL_CI;
|
||||
exports.UTF8MB4 = exports.UTF8MB4_GENERAL_CI;
|
||||
exports.UTF32 = exports.UTF32_GENERAL_CI;
|
||||
26
node_modules/mysql/lib/protocol/constants/client.js
generated
vendored
Normal file
26
node_modules/mysql/lib/protocol/constants/client.js
generated
vendored
Normal file
@ -0,0 +1,26 @@
|
||||
// Manually extracted from mysql-5.5.23/include/mysql_com.h
|
||||
exports.CLIENT_LONG_PASSWORD = 1; /* new more secure passwords */
|
||||
exports.CLIENT_FOUND_ROWS = 2; /* Found instead of affected rows */
|
||||
exports.CLIENT_LONG_FLAG = 4; /* Get all column flags */
|
||||
exports.CLIENT_CONNECT_WITH_DB = 8; /* One can specify db on connect */
|
||||
exports.CLIENT_NO_SCHEMA = 16; /* Don't allow database.table.column */
|
||||
exports.CLIENT_COMPRESS = 32; /* Can use compression protocol */
|
||||
exports.CLIENT_ODBC = 64; /* Odbc client */
|
||||
exports.CLIENT_LOCAL_FILES = 128; /* Can use LOAD DATA LOCAL */
|
||||
exports.CLIENT_IGNORE_SPACE = 256; /* Ignore spaces before '(' */
|
||||
exports.CLIENT_PROTOCOL_41 = 512; /* New 4.1 protocol */
|
||||
exports.CLIENT_INTERACTIVE = 1024; /* This is an interactive client */
|
||||
exports.CLIENT_SSL = 2048; /* Switch to SSL after handshake */
|
||||
exports.CLIENT_IGNORE_SIGPIPE = 4096; /* IGNORE sigpipes */
|
||||
exports.CLIENT_TRANSACTIONS = 8192; /* Client knows about transactions */
|
||||
exports.CLIENT_RESERVED = 16384; /* Old flag for 4.1 protocol */
|
||||
exports.CLIENT_SECURE_CONNECTION = 32768; /* New 4.1 authentication */
|
||||
|
||||
exports.CLIENT_MULTI_STATEMENTS = 65536; /* Enable/disable multi-stmt support */
|
||||
exports.CLIENT_MULTI_RESULTS = 131072; /* Enable/disable multi-results */
|
||||
exports.CLIENT_PS_MULTI_RESULTS = 262144; /* Multi-results in PS-protocol */
|
||||
|
||||
exports.CLIENT_PLUGIN_AUTH = 524288; /* Client supports plugin authentication */
|
||||
|
||||
exports.CLIENT_SSL_VERIFY_SERVER_CERT = 1073741824;
|
||||
exports.CLIENT_REMEMBER_OPTIONS = 2147483648;
|
||||
2476
node_modules/mysql/lib/protocol/constants/errors.js
generated
vendored
Normal file
2476
node_modules/mysql/lib/protocol/constants/errors.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
18
node_modules/mysql/lib/protocol/constants/field_flags.js
generated
vendored
Normal file
18
node_modules/mysql/lib/protocol/constants/field_flags.js
generated
vendored
Normal file
@ -0,0 +1,18 @@
|
||||
// Manually extracted from mysql-5.5.23/include/mysql_com.h
|
||||
exports.NOT_NULL_FLAG = 1; /* Field can't be NULL */
|
||||
exports.PRI_KEY_FLAG = 2; /* Field is part of a primary key */
|
||||
exports.UNIQUE_KEY_FLAG = 4; /* Field is part of a unique key */
|
||||
exports.MULTIPLE_KEY_FLAG = 8; /* Field is part of a key */
|
||||
exports.BLOB_FLAG = 16; /* Field is a blob */
|
||||
exports.UNSIGNED_FLAG = 32; /* Field is unsigned */
|
||||
exports.ZEROFILL_FLAG = 64; /* Field is zerofill */
|
||||
exports.BINARY_FLAG = 128; /* Field is binary */
|
||||
|
||||
/* The following are only sent to new clients */
|
||||
exports.ENUM_FLAG = 256; /* field is an enum */
|
||||
exports.AUTO_INCREMENT_FLAG = 512; /* field is a autoincrement field */
|
||||
exports.TIMESTAMP_FLAG = 1024; /* Field is a timestamp */
|
||||
exports.SET_FLAG = 2048; /* field is a set */
|
||||
exports.NO_DEFAULT_VALUE_FLAG = 4096; /* Field doesn't have default value */
|
||||
exports.ON_UPDATE_NOW_FLAG = 8192; /* Field is set to NOW on UPDATE */
|
||||
exports.NUM_FLAG = 32768; /* Field is num (for clients) */
|
||||
39
node_modules/mysql/lib/protocol/constants/server_status.js
generated
vendored
Normal file
39
node_modules/mysql/lib/protocol/constants/server_status.js
generated
vendored
Normal file
@ -0,0 +1,39 @@
|
||||
// Manually extracted from mysql-5.5.23/include/mysql_com.h
|
||||
|
||||
/**
|
||||
Is raised when a multi-statement transaction
|
||||
has been started, either explicitly, by means
|
||||
of BEGIN or COMMIT AND CHAIN, or
|
||||
implicitly, by the first transactional
|
||||
statement, when autocommit=off.
|
||||
*/
|
||||
exports.SERVER_STATUS_IN_TRANS = 1;
|
||||
exports.SERVER_STATUS_AUTOCOMMIT = 2; /* Server in auto_commit mode */
|
||||
exports.SERVER_MORE_RESULTS_EXISTS = 8; /* Multi query - next query exists */
|
||||
exports.SERVER_QUERY_NO_GOOD_INDEX_USED = 16;
|
||||
exports.SERVER_QUERY_NO_INDEX_USED = 32;
|
||||
/**
|
||||
The server was able to fulfill the clients request and opened a
|
||||
read-only non-scrollable cursor for a query. This flag comes
|
||||
in reply to COM_STMT_EXECUTE and COM_STMT_FETCH commands.
|
||||
*/
|
||||
exports.SERVER_STATUS_CURSOR_EXISTS = 64;
|
||||
/**
|
||||
This flag is sent when a read-only cursor is exhausted, in reply to
|
||||
COM_STMT_FETCH command.
|
||||
*/
|
||||
exports.SERVER_STATUS_LAST_ROW_SENT = 128;
|
||||
exports.SERVER_STATUS_DB_DROPPED = 256; /* A database was dropped */
|
||||
exports.SERVER_STATUS_NO_BACKSLASH_ESCAPES = 512;
|
||||
/**
|
||||
Sent to the client if after a prepared statement reprepare
|
||||
we discovered that the new statement returns a different
|
||||
number of result set columns.
|
||||
*/
|
||||
exports.SERVER_STATUS_METADATA_CHANGED = 1024;
|
||||
exports.SERVER_QUERY_WAS_SLOW = 2048;
|
||||
|
||||
/**
|
||||
To mark ResultSet containing output parameter values.
|
||||
*/
|
||||
exports.SERVER_PS_OUT_PARAMS = 4096;
|
||||
1480
node_modules/mysql/lib/protocol/constants/ssl_profiles.js
generated
vendored
Normal file
1480
node_modules/mysql/lib/protocol/constants/ssl_profiles.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
72
node_modules/mysql/lib/protocol/constants/types.js
generated
vendored
Normal file
72
node_modules/mysql/lib/protocol/constants/types.js
generated
vendored
Normal file
@ -0,0 +1,72 @@
|
||||
/**
|
||||
* MySQL type constants
|
||||
*
|
||||
* Extracted from version 5.7.29
|
||||
*
|
||||
* !! Generated by generate-type-constants.js, do not modify by hand !!
|
||||
*/
|
||||
|
||||
exports.DECIMAL = 0;
|
||||
exports.TINY = 1;
|
||||
exports.SHORT = 2;
|
||||
exports.LONG = 3;
|
||||
exports.FLOAT = 4;
|
||||
exports.DOUBLE = 5;
|
||||
exports.NULL = 6;
|
||||
exports.TIMESTAMP = 7;
|
||||
exports.LONGLONG = 8;
|
||||
exports.INT24 = 9;
|
||||
exports.DATE = 10;
|
||||
exports.TIME = 11;
|
||||
exports.DATETIME = 12;
|
||||
exports.YEAR = 13;
|
||||
exports.NEWDATE = 14;
|
||||
exports.VARCHAR = 15;
|
||||
exports.BIT = 16;
|
||||
exports.TIMESTAMP2 = 17;
|
||||
exports.DATETIME2 = 18;
|
||||
exports.TIME2 = 19;
|
||||
exports.JSON = 245;
|
||||
exports.NEWDECIMAL = 246;
|
||||
exports.ENUM = 247;
|
||||
exports.SET = 248;
|
||||
exports.TINY_BLOB = 249;
|
||||
exports.MEDIUM_BLOB = 250;
|
||||
exports.LONG_BLOB = 251;
|
||||
exports.BLOB = 252;
|
||||
exports.VAR_STRING = 253;
|
||||
exports.STRING = 254;
|
||||
exports.GEOMETRY = 255;
|
||||
|
||||
// Lookup-by-number table
|
||||
exports[0] = 'DECIMAL';
|
||||
exports[1] = 'TINY';
|
||||
exports[2] = 'SHORT';
|
||||
exports[3] = 'LONG';
|
||||
exports[4] = 'FLOAT';
|
||||
exports[5] = 'DOUBLE';
|
||||
exports[6] = 'NULL';
|
||||
exports[7] = 'TIMESTAMP';
|
||||
exports[8] = 'LONGLONG';
|
||||
exports[9] = 'INT24';
|
||||
exports[10] = 'DATE';
|
||||
exports[11] = 'TIME';
|
||||
exports[12] = 'DATETIME';
|
||||
exports[13] = 'YEAR';
|
||||
exports[14] = 'NEWDATE';
|
||||
exports[15] = 'VARCHAR';
|
||||
exports[16] = 'BIT';
|
||||
exports[17] = 'TIMESTAMP2';
|
||||
exports[18] = 'DATETIME2';
|
||||
exports[19] = 'TIME2';
|
||||
exports[245] = 'JSON';
|
||||
exports[246] = 'NEWDECIMAL';
|
||||
exports[247] = 'ENUM';
|
||||
exports[248] = 'SET';
|
||||
exports[249] = 'TINY_BLOB';
|
||||
exports[250] = 'MEDIUM_BLOB';
|
||||
exports[251] = 'LONG_BLOB';
|
||||
exports[252] = 'BLOB';
|
||||
exports[253] = 'VAR_STRING';
|
||||
exports[254] = 'STRING';
|
||||
exports[255] = 'GEOMETRY';
|
||||
20
node_modules/mysql/lib/protocol/packets/AuthSwitchRequestPacket.js
generated
vendored
Normal file
20
node_modules/mysql/lib/protocol/packets/AuthSwitchRequestPacket.js
generated
vendored
Normal file
@ -0,0 +1,20 @@
|
||||
module.exports = AuthSwitchRequestPacket;
|
||||
function AuthSwitchRequestPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.status = 0xfe;
|
||||
this.authMethodName = options.authMethodName;
|
||||
this.authMethodData = options.authMethodData;
|
||||
}
|
||||
|
||||
AuthSwitchRequestPacket.prototype.parse = function parse(parser) {
|
||||
this.status = parser.parseUnsignedNumber(1);
|
||||
this.authMethodName = parser.parseNullTerminatedString();
|
||||
this.authMethodData = parser.parsePacketTerminatedBuffer();
|
||||
};
|
||||
|
||||
AuthSwitchRequestPacket.prototype.write = function write(writer) {
|
||||
writer.writeUnsignedNumber(1, this.status);
|
||||
writer.writeNullTerminatedString(this.authMethodName);
|
||||
writer.writeBuffer(this.authMethodData);
|
||||
};
|
||||
14
node_modules/mysql/lib/protocol/packets/AuthSwitchResponsePacket.js
generated
vendored
Normal file
14
node_modules/mysql/lib/protocol/packets/AuthSwitchResponsePacket.js
generated
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
module.exports = AuthSwitchResponsePacket;
|
||||
function AuthSwitchResponsePacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.data = options.data;
|
||||
}
|
||||
|
||||
AuthSwitchResponsePacket.prototype.parse = function parse(parser) {
|
||||
this.data = parser.parsePacketTerminatedBuffer();
|
||||
};
|
||||
|
||||
AuthSwitchResponsePacket.prototype.write = function write(writer) {
|
||||
writer.writeBuffer(this.data);
|
||||
};
|
||||
54
node_modules/mysql/lib/protocol/packets/ClientAuthenticationPacket.js
generated
vendored
Normal file
54
node_modules/mysql/lib/protocol/packets/ClientAuthenticationPacket.js
generated
vendored
Normal file
@ -0,0 +1,54 @@
|
||||
var Buffer = require('safe-buffer').Buffer;
|
||||
|
||||
module.exports = ClientAuthenticationPacket;
|
||||
function ClientAuthenticationPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.clientFlags = options.clientFlags;
|
||||
this.maxPacketSize = options.maxPacketSize;
|
||||
this.charsetNumber = options.charsetNumber;
|
||||
this.filler = undefined;
|
||||
this.user = options.user;
|
||||
this.scrambleBuff = options.scrambleBuff;
|
||||
this.database = options.database;
|
||||
this.protocol41 = options.protocol41;
|
||||
}
|
||||
|
||||
ClientAuthenticationPacket.prototype.parse = function(parser) {
|
||||
if (this.protocol41) {
|
||||
this.clientFlags = parser.parseUnsignedNumber(4);
|
||||
this.maxPacketSize = parser.parseUnsignedNumber(4);
|
||||
this.charsetNumber = parser.parseUnsignedNumber(1);
|
||||
this.filler = parser.parseFiller(23);
|
||||
this.user = parser.parseNullTerminatedString();
|
||||
this.scrambleBuff = parser.parseLengthCodedBuffer();
|
||||
this.database = parser.parseNullTerminatedString();
|
||||
} else {
|
||||
this.clientFlags = parser.parseUnsignedNumber(2);
|
||||
this.maxPacketSize = parser.parseUnsignedNumber(3);
|
||||
this.user = parser.parseNullTerminatedString();
|
||||
this.scrambleBuff = parser.parseBuffer(8);
|
||||
this.database = parser.parseLengthCodedBuffer();
|
||||
}
|
||||
};
|
||||
|
||||
ClientAuthenticationPacket.prototype.write = function(writer) {
|
||||
if (this.protocol41) {
|
||||
writer.writeUnsignedNumber(4, this.clientFlags);
|
||||
writer.writeUnsignedNumber(4, this.maxPacketSize);
|
||||
writer.writeUnsignedNumber(1, this.charsetNumber);
|
||||
writer.writeFiller(23);
|
||||
writer.writeNullTerminatedString(this.user);
|
||||
writer.writeLengthCodedBuffer(this.scrambleBuff);
|
||||
writer.writeNullTerminatedString(this.database);
|
||||
} else {
|
||||
writer.writeUnsignedNumber(2, this.clientFlags);
|
||||
writer.writeUnsignedNumber(3, this.maxPacketSize);
|
||||
writer.writeNullTerminatedString(this.user);
|
||||
writer.writeBuffer(this.scrambleBuff);
|
||||
if (this.database && this.database.length) {
|
||||
writer.writeFiller(1);
|
||||
writer.writeBuffer(Buffer.from(this.database));
|
||||
}
|
||||
}
|
||||
};
|
||||
26
node_modules/mysql/lib/protocol/packets/ComChangeUserPacket.js
generated
vendored
Normal file
26
node_modules/mysql/lib/protocol/packets/ComChangeUserPacket.js
generated
vendored
Normal file
@ -0,0 +1,26 @@
|
||||
module.exports = ComChangeUserPacket;
|
||||
function ComChangeUserPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.command = 0x11;
|
||||
this.user = options.user;
|
||||
this.scrambleBuff = options.scrambleBuff;
|
||||
this.database = options.database;
|
||||
this.charsetNumber = options.charsetNumber;
|
||||
}
|
||||
|
||||
ComChangeUserPacket.prototype.parse = function(parser) {
|
||||
this.command = parser.parseUnsignedNumber(1);
|
||||
this.user = parser.parseNullTerminatedString();
|
||||
this.scrambleBuff = parser.parseLengthCodedBuffer();
|
||||
this.database = parser.parseNullTerminatedString();
|
||||
this.charsetNumber = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
|
||||
ComChangeUserPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.command);
|
||||
writer.writeNullTerminatedString(this.user);
|
||||
writer.writeLengthCodedBuffer(this.scrambleBuff);
|
||||
writer.writeNullTerminatedString(this.database);
|
||||
writer.writeUnsignedNumber(2, this.charsetNumber);
|
||||
};
|
||||
12
node_modules/mysql/lib/protocol/packets/ComPingPacket.js
generated
vendored
Normal file
12
node_modules/mysql/lib/protocol/packets/ComPingPacket.js
generated
vendored
Normal file
@ -0,0 +1,12 @@
|
||||
module.exports = ComPingPacket;
|
||||
function ComPingPacket() {
|
||||
this.command = 0x0e;
|
||||
}
|
||||
|
||||
ComPingPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.command);
|
||||
};
|
||||
|
||||
ComPingPacket.prototype.parse = function(parser) {
|
||||
this.command = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
15
node_modules/mysql/lib/protocol/packets/ComQueryPacket.js
generated
vendored
Normal file
15
node_modules/mysql/lib/protocol/packets/ComQueryPacket.js
generated
vendored
Normal file
@ -0,0 +1,15 @@
|
||||
module.exports = ComQueryPacket;
|
||||
function ComQueryPacket(sql) {
|
||||
this.command = 0x03;
|
||||
this.sql = sql;
|
||||
}
|
||||
|
||||
ComQueryPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.command);
|
||||
writer.writeString(this.sql);
|
||||
};
|
||||
|
||||
ComQueryPacket.prototype.parse = function(parser) {
|
||||
this.command = parser.parseUnsignedNumber(1);
|
||||
this.sql = parser.parsePacketTerminatedString();
|
||||
};
|
||||
12
node_modules/mysql/lib/protocol/packets/ComQuitPacket.js
generated
vendored
Normal file
12
node_modules/mysql/lib/protocol/packets/ComQuitPacket.js
generated
vendored
Normal file
@ -0,0 +1,12 @@
|
||||
module.exports = ComQuitPacket;
|
||||
function ComQuitPacket() {
|
||||
this.command = 0x01;
|
||||
}
|
||||
|
||||
ComQuitPacket.prototype.parse = function parse(parser) {
|
||||
this.command = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
|
||||
ComQuitPacket.prototype.write = function write(writer) {
|
||||
writer.writeUnsignedNumber(1, this.command);
|
||||
};
|
||||
12
node_modules/mysql/lib/protocol/packets/ComStatisticsPacket.js
generated
vendored
Normal file
12
node_modules/mysql/lib/protocol/packets/ComStatisticsPacket.js
generated
vendored
Normal file
@ -0,0 +1,12 @@
|
||||
module.exports = ComStatisticsPacket;
|
||||
function ComStatisticsPacket() {
|
||||
this.command = 0x09;
|
||||
}
|
||||
|
||||
ComStatisticsPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.command);
|
||||
};
|
||||
|
||||
ComStatisticsPacket.prototype.parse = function(parser) {
|
||||
this.command = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
9
node_modules/mysql/lib/protocol/packets/EmptyPacket.js
generated
vendored
Normal file
9
node_modules/mysql/lib/protocol/packets/EmptyPacket.js
generated
vendored
Normal file
@ -0,0 +1,9 @@
|
||||
module.exports = EmptyPacket;
|
||||
function EmptyPacket() {
|
||||
}
|
||||
|
||||
EmptyPacket.prototype.parse = function parse() {
|
||||
};
|
||||
|
||||
EmptyPacket.prototype.write = function write() {
|
||||
};
|
||||
25
node_modules/mysql/lib/protocol/packets/EofPacket.js
generated
vendored
Normal file
25
node_modules/mysql/lib/protocol/packets/EofPacket.js
generated
vendored
Normal file
@ -0,0 +1,25 @@
|
||||
module.exports = EofPacket;
|
||||
function EofPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.fieldCount = undefined;
|
||||
this.warningCount = options.warningCount;
|
||||
this.serverStatus = options.serverStatus;
|
||||
this.protocol41 = options.protocol41;
|
||||
}
|
||||
|
||||
EofPacket.prototype.parse = function(parser) {
|
||||
this.fieldCount = parser.parseUnsignedNumber(1);
|
||||
if (this.protocol41) {
|
||||
this.warningCount = parser.parseUnsignedNumber(2);
|
||||
this.serverStatus = parser.parseUnsignedNumber(2);
|
||||
}
|
||||
};
|
||||
|
||||
EofPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, 0xfe);
|
||||
if (this.protocol41) {
|
||||
writer.writeUnsignedNumber(2, this.warningCount);
|
||||
writer.writeUnsignedNumber(2, this.serverStatus);
|
||||
}
|
||||
};
|
||||
35
node_modules/mysql/lib/protocol/packets/ErrorPacket.js
generated
vendored
Normal file
35
node_modules/mysql/lib/protocol/packets/ErrorPacket.js
generated
vendored
Normal file
@ -0,0 +1,35 @@
|
||||
module.exports = ErrorPacket;
|
||||
function ErrorPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.fieldCount = options.fieldCount;
|
||||
this.errno = options.errno;
|
||||
this.sqlStateMarker = options.sqlStateMarker;
|
||||
this.sqlState = options.sqlState;
|
||||
this.message = options.message;
|
||||
}
|
||||
|
||||
ErrorPacket.prototype.parse = function(parser) {
|
||||
this.fieldCount = parser.parseUnsignedNumber(1);
|
||||
this.errno = parser.parseUnsignedNumber(2);
|
||||
|
||||
// sqlStateMarker ('#' = 0x23) indicates error packet format
|
||||
if (parser.peak() === 0x23) {
|
||||
this.sqlStateMarker = parser.parseString(1);
|
||||
this.sqlState = parser.parseString(5);
|
||||
}
|
||||
|
||||
this.message = parser.parsePacketTerminatedString();
|
||||
};
|
||||
|
||||
ErrorPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, 0xff);
|
||||
writer.writeUnsignedNumber(2, this.errno);
|
||||
|
||||
if (this.sqlStateMarker) {
|
||||
writer.writeString(this.sqlStateMarker);
|
||||
writer.writeString(this.sqlState);
|
||||
}
|
||||
|
||||
writer.writeString(this.message);
|
||||
};
|
||||
26
node_modules/mysql/lib/protocol/packets/Field.js
generated
vendored
Normal file
26
node_modules/mysql/lib/protocol/packets/Field.js
generated
vendored
Normal file
@ -0,0 +1,26 @@
|
||||
var Types = require('../constants/types');
|
||||
|
||||
module.exports = Field;
|
||||
function Field(options) {
|
||||
options = options || {};
|
||||
|
||||
this.parser = options.parser;
|
||||
this.packet = options.packet;
|
||||
this.db = options.packet.db;
|
||||
this.table = options.packet.table;
|
||||
this.name = options.packet.name;
|
||||
this.type = Types[options.packet.type];
|
||||
this.length = options.packet.length;
|
||||
}
|
||||
|
||||
Field.prototype.string = function () {
|
||||
return this.parser.parseLengthCodedString();
|
||||
};
|
||||
|
||||
Field.prototype.buffer = function () {
|
||||
return this.parser.parseLengthCodedBuffer();
|
||||
};
|
||||
|
||||
Field.prototype.geometry = function () {
|
||||
return this.parser.parseGeometryValue();
|
||||
};
|
||||
93
node_modules/mysql/lib/protocol/packets/FieldPacket.js
generated
vendored
Normal file
93
node_modules/mysql/lib/protocol/packets/FieldPacket.js
generated
vendored
Normal file
@ -0,0 +1,93 @@
|
||||
module.exports = FieldPacket;
|
||||
function FieldPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.catalog = options.catalog;
|
||||
this.db = options.db;
|
||||
this.table = options.table;
|
||||
this.orgTable = options.orgTable;
|
||||
this.name = options.name;
|
||||
this.orgName = options.orgName;
|
||||
this.charsetNr = options.charsetNr;
|
||||
this.length = options.length;
|
||||
this.type = options.type;
|
||||
this.flags = options.flags;
|
||||
this.decimals = options.decimals;
|
||||
this.default = options.default;
|
||||
this.zeroFill = options.zeroFill;
|
||||
this.protocol41 = options.protocol41;
|
||||
}
|
||||
|
||||
FieldPacket.prototype.parse = function(parser) {
|
||||
if (this.protocol41) {
|
||||
this.catalog = parser.parseLengthCodedString();
|
||||
this.db = parser.parseLengthCodedString();
|
||||
this.table = parser.parseLengthCodedString();
|
||||
this.orgTable = parser.parseLengthCodedString();
|
||||
this.name = parser.parseLengthCodedString();
|
||||
this.orgName = parser.parseLengthCodedString();
|
||||
|
||||
if (parser.parseLengthCodedNumber() !== 0x0c) {
|
||||
var err = new TypeError('Received invalid field length');
|
||||
err.code = 'PARSER_INVALID_FIELD_LENGTH';
|
||||
throw err;
|
||||
}
|
||||
|
||||
this.charsetNr = parser.parseUnsignedNumber(2);
|
||||
this.length = parser.parseUnsignedNumber(4);
|
||||
this.type = parser.parseUnsignedNumber(1);
|
||||
this.flags = parser.parseUnsignedNumber(2);
|
||||
this.decimals = parser.parseUnsignedNumber(1);
|
||||
|
||||
var filler = parser.parseBuffer(2);
|
||||
if (filler[0] !== 0x0 || filler[1] !== 0x0) {
|
||||
var err = new TypeError('Received invalid filler');
|
||||
err.code = 'PARSER_INVALID_FILLER';
|
||||
throw err;
|
||||
}
|
||||
|
||||
// parsed flags
|
||||
this.zeroFill = (this.flags & 0x0040 ? true : false);
|
||||
|
||||
if (parser.reachedPacketEnd()) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.default = parser.parseLengthCodedString();
|
||||
} else {
|
||||
this.table = parser.parseLengthCodedString();
|
||||
this.name = parser.parseLengthCodedString();
|
||||
this.length = parser.parseUnsignedNumber(parser.parseUnsignedNumber(1));
|
||||
this.type = parser.parseUnsignedNumber(parser.parseUnsignedNumber(1));
|
||||
}
|
||||
};
|
||||
|
||||
FieldPacket.prototype.write = function(writer) {
|
||||
if (this.protocol41) {
|
||||
writer.writeLengthCodedString(this.catalog);
|
||||
writer.writeLengthCodedString(this.db);
|
||||
writer.writeLengthCodedString(this.table);
|
||||
writer.writeLengthCodedString(this.orgTable);
|
||||
writer.writeLengthCodedString(this.name);
|
||||
writer.writeLengthCodedString(this.orgName);
|
||||
|
||||
writer.writeLengthCodedNumber(0x0c);
|
||||
writer.writeUnsignedNumber(2, this.charsetNr || 0);
|
||||
writer.writeUnsignedNumber(4, this.length || 0);
|
||||
writer.writeUnsignedNumber(1, this.type || 0);
|
||||
writer.writeUnsignedNumber(2, this.flags || 0);
|
||||
writer.writeUnsignedNumber(1, this.decimals || 0);
|
||||
writer.writeFiller(2);
|
||||
|
||||
if (this.default !== undefined) {
|
||||
writer.writeLengthCodedString(this.default);
|
||||
}
|
||||
} else {
|
||||
writer.writeLengthCodedString(this.table);
|
||||
writer.writeLengthCodedString(this.name);
|
||||
writer.writeUnsignedNumber(1, 0x01);
|
||||
writer.writeUnsignedNumber(1, this.length);
|
||||
writer.writeUnsignedNumber(1, 0x01);
|
||||
writer.writeUnsignedNumber(1, this.type);
|
||||
}
|
||||
};
|
||||
103
node_modules/mysql/lib/protocol/packets/HandshakeInitializationPacket.js
generated
vendored
Normal file
103
node_modules/mysql/lib/protocol/packets/HandshakeInitializationPacket.js
generated
vendored
Normal file
@ -0,0 +1,103 @@
|
||||
var Buffer = require('safe-buffer').Buffer;
|
||||
var Client = require('../constants/client');
|
||||
|
||||
module.exports = HandshakeInitializationPacket;
|
||||
function HandshakeInitializationPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.protocolVersion = options.protocolVersion;
|
||||
this.serverVersion = options.serverVersion;
|
||||
this.threadId = options.threadId;
|
||||
this.scrambleBuff1 = options.scrambleBuff1;
|
||||
this.filler1 = options.filler1;
|
||||
this.serverCapabilities1 = options.serverCapabilities1;
|
||||
this.serverLanguage = options.serverLanguage;
|
||||
this.serverStatus = options.serverStatus;
|
||||
this.serverCapabilities2 = options.serverCapabilities2;
|
||||
this.scrambleLength = options.scrambleLength;
|
||||
this.filler2 = options.filler2;
|
||||
this.scrambleBuff2 = options.scrambleBuff2;
|
||||
this.filler3 = options.filler3;
|
||||
this.pluginData = options.pluginData;
|
||||
this.protocol41 = options.protocol41;
|
||||
|
||||
if (this.protocol41) {
|
||||
// force set the bit in serverCapabilities1
|
||||
this.serverCapabilities1 |= Client.CLIENT_PROTOCOL_41;
|
||||
}
|
||||
}
|
||||
|
||||
HandshakeInitializationPacket.prototype.parse = function(parser) {
|
||||
this.protocolVersion = parser.parseUnsignedNumber(1);
|
||||
this.serverVersion = parser.parseNullTerminatedString();
|
||||
this.threadId = parser.parseUnsignedNumber(4);
|
||||
this.scrambleBuff1 = parser.parseBuffer(8);
|
||||
this.filler1 = parser.parseFiller(1);
|
||||
this.serverCapabilities1 = parser.parseUnsignedNumber(2);
|
||||
this.serverLanguage = parser.parseUnsignedNumber(1);
|
||||
this.serverStatus = parser.parseUnsignedNumber(2);
|
||||
|
||||
this.protocol41 = (this.serverCapabilities1 & (1 << 9)) > 0;
|
||||
|
||||
if (this.protocol41) {
|
||||
this.serverCapabilities2 = parser.parseUnsignedNumber(2);
|
||||
this.scrambleLength = parser.parseUnsignedNumber(1);
|
||||
this.filler2 = parser.parseFiller(10);
|
||||
// scrambleBuff2 should be 0x00 terminated, but sphinx does not do this
|
||||
// so we assume scrambleBuff2 to be 12 byte and treat the next byte as a
|
||||
// filler byte.
|
||||
this.scrambleBuff2 = parser.parseBuffer(12);
|
||||
this.filler3 = parser.parseFiller(1);
|
||||
} else {
|
||||
this.filler2 = parser.parseFiller(13);
|
||||
}
|
||||
|
||||
if (parser.reachedPacketEnd()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// According to the docs this should be 0x00 terminated, but MariaDB does
|
||||
// not do this, so we assume this string to be packet terminated.
|
||||
this.pluginData = parser.parsePacketTerminatedString();
|
||||
|
||||
// However, if there is a trailing '\0', strip it
|
||||
var lastChar = this.pluginData.length - 1;
|
||||
if (this.pluginData[lastChar] === '\0') {
|
||||
this.pluginData = this.pluginData.substr(0, lastChar);
|
||||
}
|
||||
};
|
||||
|
||||
HandshakeInitializationPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.protocolVersion);
|
||||
writer.writeNullTerminatedString(this.serverVersion);
|
||||
writer.writeUnsignedNumber(4, this.threadId);
|
||||
writer.writeBuffer(this.scrambleBuff1);
|
||||
writer.writeFiller(1);
|
||||
writer.writeUnsignedNumber(2, this.serverCapabilities1);
|
||||
writer.writeUnsignedNumber(1, this.serverLanguage);
|
||||
writer.writeUnsignedNumber(2, this.serverStatus);
|
||||
if (this.protocol41) {
|
||||
writer.writeUnsignedNumber(2, this.serverCapabilities2);
|
||||
writer.writeUnsignedNumber(1, this.scrambleLength);
|
||||
writer.writeFiller(10);
|
||||
}
|
||||
writer.writeNullTerminatedBuffer(this.scrambleBuff2);
|
||||
|
||||
if (this.pluginData !== undefined) {
|
||||
writer.writeNullTerminatedString(this.pluginData);
|
||||
}
|
||||
};
|
||||
|
||||
HandshakeInitializationPacket.prototype.scrambleBuff = function() {
|
||||
var buffer = null;
|
||||
|
||||
if (typeof this.scrambleBuff2 === 'undefined') {
|
||||
buffer = Buffer.from(this.scrambleBuff1);
|
||||
} else {
|
||||
buffer = Buffer.allocUnsafe(this.scrambleBuff1.length + this.scrambleBuff2.length);
|
||||
this.scrambleBuff1.copy(buffer, 0);
|
||||
this.scrambleBuff2.copy(buffer, this.scrambleBuff1.length);
|
||||
}
|
||||
|
||||
return buffer;
|
||||
};
|
||||
15
node_modules/mysql/lib/protocol/packets/LocalDataFilePacket.js
generated
vendored
Normal file
15
node_modules/mysql/lib/protocol/packets/LocalDataFilePacket.js
generated
vendored
Normal file
@ -0,0 +1,15 @@
|
||||
module.exports = LocalDataFilePacket;
|
||||
|
||||
/**
|
||||
* Create a new LocalDataFilePacket
|
||||
* @constructor
|
||||
* @param {Buffer} data The data contents of the packet
|
||||
* @public
|
||||
*/
|
||||
function LocalDataFilePacket(data) {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
LocalDataFilePacket.prototype.write = function(writer) {
|
||||
writer.writeBuffer(this.data);
|
||||
};
|
||||
21
node_modules/mysql/lib/protocol/packets/LocalInfileRequestPacket.js
generated
vendored
Normal file
21
node_modules/mysql/lib/protocol/packets/LocalInfileRequestPacket.js
generated
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
module.exports = LocalInfileRequestPacket;
|
||||
function LocalInfileRequestPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.filename = options.filename;
|
||||
}
|
||||
|
||||
LocalInfileRequestPacket.prototype.parse = function parse(parser) {
|
||||
if (parser.parseLengthCodedNumber() !== null) {
|
||||
var err = new TypeError('Received invalid field length');
|
||||
err.code = 'PARSER_INVALID_FIELD_LENGTH';
|
||||
throw err;
|
||||
}
|
||||
|
||||
this.filename = parser.parsePacketTerminatedString();
|
||||
};
|
||||
|
||||
LocalInfileRequestPacket.prototype.write = function write(writer) {
|
||||
writer.writeLengthCodedNumber(null);
|
||||
writer.writeString(this.filename);
|
||||
};
|
||||
44
node_modules/mysql/lib/protocol/packets/OkPacket.js
generated
vendored
Normal file
44
node_modules/mysql/lib/protocol/packets/OkPacket.js
generated
vendored
Normal file
@ -0,0 +1,44 @@
|
||||
|
||||
// Language-neutral expression to match ER_UPDATE_INFO
|
||||
var ER_UPDATE_INFO_REGEXP = /^[^:0-9]+: [0-9]+[^:0-9]+: ([0-9]+)[^:0-9]+: [0-9]+[^:0-9]*$/;
|
||||
|
||||
module.exports = OkPacket;
|
||||
function OkPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.fieldCount = undefined;
|
||||
this.affectedRows = undefined;
|
||||
this.insertId = undefined;
|
||||
this.serverStatus = undefined;
|
||||
this.warningCount = undefined;
|
||||
this.message = undefined;
|
||||
this.protocol41 = options.protocol41;
|
||||
}
|
||||
|
||||
OkPacket.prototype.parse = function(parser) {
|
||||
this.fieldCount = parser.parseUnsignedNumber(1);
|
||||
this.affectedRows = parser.parseLengthCodedNumber();
|
||||
this.insertId = parser.parseLengthCodedNumber();
|
||||
if (this.protocol41) {
|
||||
this.serverStatus = parser.parseUnsignedNumber(2);
|
||||
this.warningCount = parser.parseUnsignedNumber(2);
|
||||
}
|
||||
this.message = parser.parsePacketTerminatedString();
|
||||
this.changedRows = 0;
|
||||
|
||||
var m = ER_UPDATE_INFO_REGEXP.exec(this.message);
|
||||
if (m !== null) {
|
||||
this.changedRows = parseInt(m[1], 10);
|
||||
}
|
||||
};
|
||||
|
||||
OkPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, 0x00);
|
||||
writer.writeLengthCodedNumber(this.affectedRows || 0);
|
||||
writer.writeLengthCodedNumber(this.insertId || 0);
|
||||
if (this.protocol41) {
|
||||
writer.writeUnsignedNumber(2, this.serverStatus || 0);
|
||||
writer.writeUnsignedNumber(2, this.warningCount || 0);
|
||||
}
|
||||
writer.writeString(this.message);
|
||||
};
|
||||
14
node_modules/mysql/lib/protocol/packets/OldPasswordPacket.js
generated
vendored
Normal file
14
node_modules/mysql/lib/protocol/packets/OldPasswordPacket.js
generated
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
module.exports = OldPasswordPacket;
|
||||
function OldPasswordPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.scrambleBuff = options.scrambleBuff;
|
||||
}
|
||||
|
||||
OldPasswordPacket.prototype.parse = function(parser) {
|
||||
this.scrambleBuff = parser.parsePacketTerminatedBuffer();
|
||||
};
|
||||
|
||||
OldPasswordPacket.prototype.write = function(writer) {
|
||||
writer.writeBuffer(this.scrambleBuff);
|
||||
};
|
||||
14
node_modules/mysql/lib/protocol/packets/ResultSetHeaderPacket.js
generated
vendored
Normal file
14
node_modules/mysql/lib/protocol/packets/ResultSetHeaderPacket.js
generated
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
module.exports = ResultSetHeaderPacket;
|
||||
function ResultSetHeaderPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.fieldCount = options.fieldCount;
|
||||
}
|
||||
|
||||
ResultSetHeaderPacket.prototype.parse = function(parser) {
|
||||
this.fieldCount = parser.parseLengthCodedNumber();
|
||||
};
|
||||
|
||||
ResultSetHeaderPacket.prototype.write = function(writer) {
|
||||
writer.writeLengthCodedNumber(this.fieldCount);
|
||||
};
|
||||
130
node_modules/mysql/lib/protocol/packets/RowDataPacket.js
generated
vendored
Normal file
130
node_modules/mysql/lib/protocol/packets/RowDataPacket.js
generated
vendored
Normal file
@ -0,0 +1,130 @@
|
||||
var Types = require('../constants/types');
|
||||
var Charsets = require('../constants/charsets');
|
||||
var Field = require('./Field');
|
||||
var IEEE_754_BINARY_64_PRECISION = Math.pow(2, 53);
|
||||
|
||||
module.exports = RowDataPacket;
|
||||
function RowDataPacket() {
|
||||
}
|
||||
|
||||
Object.defineProperty(RowDataPacket.prototype, 'parse', {
|
||||
configurable : true,
|
||||
enumerable : false,
|
||||
value : parse
|
||||
});
|
||||
|
||||
Object.defineProperty(RowDataPacket.prototype, '_typeCast', {
|
||||
configurable : true,
|
||||
enumerable : false,
|
||||
value : typeCast
|
||||
});
|
||||
|
||||
function parse(parser, fieldPackets, typeCast, nestTables, connection) {
|
||||
var self = this;
|
||||
var next = function () {
|
||||
return self._typeCast(fieldPacket, parser, connection.config.timezone, connection.config.supportBigNumbers, connection.config.bigNumberStrings, connection.config.dateStrings);
|
||||
};
|
||||
|
||||
for (var i = 0; i < fieldPackets.length; i++) {
|
||||
var fieldPacket = fieldPackets[i];
|
||||
var value;
|
||||
|
||||
if (typeof typeCast === 'function') {
|
||||
value = typeCast.apply(connection, [ new Field({ packet: fieldPacket, parser: parser }), next ]);
|
||||
} else {
|
||||
value = (typeCast)
|
||||
? this._typeCast(fieldPacket, parser, connection.config.timezone, connection.config.supportBigNumbers, connection.config.bigNumberStrings, connection.config.dateStrings)
|
||||
: ( (fieldPacket.charsetNr === Charsets.BINARY)
|
||||
? parser.parseLengthCodedBuffer()
|
||||
: parser.parseLengthCodedString() );
|
||||
}
|
||||
|
||||
if (typeof nestTables === 'string' && nestTables.length) {
|
||||
this[fieldPacket.table + nestTables + fieldPacket.name] = value;
|
||||
} else if (nestTables) {
|
||||
this[fieldPacket.table] = this[fieldPacket.table] || {};
|
||||
this[fieldPacket.table][fieldPacket.name] = value;
|
||||
} else {
|
||||
this[fieldPacket.name] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function typeCast(field, parser, timeZone, supportBigNumbers, bigNumberStrings, dateStrings) {
|
||||
var numberString;
|
||||
|
||||
switch (field.type) {
|
||||
case Types.TIMESTAMP:
|
||||
case Types.TIMESTAMP2:
|
||||
case Types.DATE:
|
||||
case Types.DATETIME:
|
||||
case Types.DATETIME2:
|
||||
case Types.NEWDATE:
|
||||
var dateString = parser.parseLengthCodedString();
|
||||
|
||||
if (typeMatch(field.type, dateStrings)) {
|
||||
return dateString;
|
||||
}
|
||||
|
||||
if (dateString === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
var originalString = dateString;
|
||||
if (field.type === Types.DATE) {
|
||||
dateString += ' 00:00:00';
|
||||
}
|
||||
|
||||
if (timeZone !== 'local') {
|
||||
dateString += ' ' + timeZone;
|
||||
}
|
||||
|
||||
var dt = new Date(dateString);
|
||||
if (isNaN(dt.getTime())) {
|
||||
return originalString;
|
||||
}
|
||||
|
||||
return dt;
|
||||
case Types.TINY:
|
||||
case Types.SHORT:
|
||||
case Types.LONG:
|
||||
case Types.INT24:
|
||||
case Types.YEAR:
|
||||
case Types.FLOAT:
|
||||
case Types.DOUBLE:
|
||||
numberString = parser.parseLengthCodedString();
|
||||
return (numberString === null || (field.zeroFill && numberString[0] === '0'))
|
||||
? numberString : Number(numberString);
|
||||
case Types.NEWDECIMAL:
|
||||
case Types.LONGLONG:
|
||||
numberString = parser.parseLengthCodedString();
|
||||
return (numberString === null || (field.zeroFill && numberString[0] === '0'))
|
||||
? numberString
|
||||
: ((supportBigNumbers && (bigNumberStrings || (Number(numberString) >= IEEE_754_BINARY_64_PRECISION) || Number(numberString) <= -IEEE_754_BINARY_64_PRECISION))
|
||||
? numberString
|
||||
: Number(numberString));
|
||||
case Types.BIT:
|
||||
return parser.parseLengthCodedBuffer();
|
||||
case Types.STRING:
|
||||
case Types.VAR_STRING:
|
||||
case Types.TINY_BLOB:
|
||||
case Types.MEDIUM_BLOB:
|
||||
case Types.LONG_BLOB:
|
||||
case Types.BLOB:
|
||||
return (field.charsetNr === Charsets.BINARY)
|
||||
? parser.parseLengthCodedBuffer()
|
||||
: parser.parseLengthCodedString();
|
||||
case Types.GEOMETRY:
|
||||
return parser.parseGeometryValue();
|
||||
default:
|
||||
return parser.parseLengthCodedString();
|
||||
}
|
||||
}
|
||||
|
||||
function typeMatch(type, list) {
|
||||
if (Array.isArray(list)) {
|
||||
return list.indexOf(Types[type]) !== -1;
|
||||
} else {
|
||||
return Boolean(list);
|
||||
}
|
||||
}
|
||||
27
node_modules/mysql/lib/protocol/packets/SSLRequestPacket.js
generated
vendored
Normal file
27
node_modules/mysql/lib/protocol/packets/SSLRequestPacket.js
generated
vendored
Normal file
@ -0,0 +1,27 @@
|
||||
// http://dev.mysql.com/doc/internals/en/ssl.html
|
||||
// http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::SSLRequest
|
||||
|
||||
var ClientConstants = require('../constants/client');
|
||||
|
||||
module.exports = SSLRequestPacket;
|
||||
|
||||
function SSLRequestPacket(options) {
|
||||
options = options || {};
|
||||
this.clientFlags = options.clientFlags | ClientConstants.CLIENT_SSL;
|
||||
this.maxPacketSize = options.maxPacketSize;
|
||||
this.charsetNumber = options.charsetNumber;
|
||||
}
|
||||
|
||||
SSLRequestPacket.prototype.parse = function(parser) {
|
||||
// TODO: check SSLRequest packet v41 vs pre v41
|
||||
this.clientFlags = parser.parseUnsignedNumber(4);
|
||||
this.maxPacketSize = parser.parseUnsignedNumber(4);
|
||||
this.charsetNumber = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
|
||||
SSLRequestPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(4, this.clientFlags);
|
||||
writer.writeUnsignedNumber(4, this.maxPacketSize);
|
||||
writer.writeUnsignedNumber(1, this.charsetNumber);
|
||||
writer.writeFiller(23);
|
||||
};
|
||||
20
node_modules/mysql/lib/protocol/packets/StatisticsPacket.js
generated
vendored
Normal file
20
node_modules/mysql/lib/protocol/packets/StatisticsPacket.js
generated
vendored
Normal file
@ -0,0 +1,20 @@
|
||||
module.exports = StatisticsPacket;
|
||||
function StatisticsPacket() {
|
||||
this.message = undefined;
|
||||
}
|
||||
|
||||
StatisticsPacket.prototype.parse = function(parser) {
|
||||
this.message = parser.parsePacketTerminatedString();
|
||||
|
||||
var items = this.message.split(/\s\s/);
|
||||
for (var i = 0; i < items.length; i++) {
|
||||
var m = items[i].match(/^(.+)\:\s+(.+)$/);
|
||||
if (m !== null) {
|
||||
this[m[1].toLowerCase().replace(/\s/g, '_')] = Number(m[2]);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
StatisticsPacket.prototype.write = function(writer) {
|
||||
writer.writeString(this.message);
|
||||
};
|
||||
14
node_modules/mysql/lib/protocol/packets/UseOldPasswordPacket.js
generated
vendored
Normal file
14
node_modules/mysql/lib/protocol/packets/UseOldPasswordPacket.js
generated
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
module.exports = UseOldPasswordPacket;
|
||||
function UseOldPasswordPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.firstByte = options.firstByte || 0xfe;
|
||||
}
|
||||
|
||||
UseOldPasswordPacket.prototype.parse = function(parser) {
|
||||
this.firstByte = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
|
||||
UseOldPasswordPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.firstByte);
|
||||
};
|
||||
23
node_modules/mysql/lib/protocol/packets/index.js
generated
vendored
Normal file
23
node_modules/mysql/lib/protocol/packets/index.js
generated
vendored
Normal file
@ -0,0 +1,23 @@
|
||||
exports.AuthSwitchRequestPacket = require('./AuthSwitchRequestPacket');
|
||||
exports.AuthSwitchResponsePacket = require('./AuthSwitchResponsePacket');
|
||||
exports.ClientAuthenticationPacket = require('./ClientAuthenticationPacket');
|
||||
exports.ComChangeUserPacket = require('./ComChangeUserPacket');
|
||||
exports.ComPingPacket = require('./ComPingPacket');
|
||||
exports.ComQueryPacket = require('./ComQueryPacket');
|
||||
exports.ComQuitPacket = require('./ComQuitPacket');
|
||||
exports.ComStatisticsPacket = require('./ComStatisticsPacket');
|
||||
exports.EmptyPacket = require('./EmptyPacket');
|
||||
exports.EofPacket = require('./EofPacket');
|
||||
exports.ErrorPacket = require('./ErrorPacket');
|
||||
exports.Field = require('./Field');
|
||||
exports.FieldPacket = require('./FieldPacket');
|
||||
exports.HandshakeInitializationPacket = require('./HandshakeInitializationPacket');
|
||||
exports.LocalDataFilePacket = require('./LocalDataFilePacket');
|
||||
exports.LocalInfileRequestPacket = require('./LocalInfileRequestPacket');
|
||||
exports.OkPacket = require('./OkPacket');
|
||||
exports.OldPasswordPacket = require('./OldPasswordPacket');
|
||||
exports.ResultSetHeaderPacket = require('./ResultSetHeaderPacket');
|
||||
exports.RowDataPacket = require('./RowDataPacket');
|
||||
exports.SSLRequestPacket = require('./SSLRequestPacket');
|
||||
exports.StatisticsPacket = require('./StatisticsPacket');
|
||||
exports.UseOldPasswordPacket = require('./UseOldPasswordPacket');
|
||||
67
node_modules/mysql/lib/protocol/sequences/ChangeUser.js
generated
vendored
Normal file
67
node_modules/mysql/lib/protocol/sequences/ChangeUser.js
generated
vendored
Normal file
@ -0,0 +1,67 @@
|
||||
var Sequence = require('./Sequence');
|
||||
var Util = require('util');
|
||||
var Packets = require('../packets');
|
||||
var Auth = require('../Auth');
|
||||
|
||||
module.exports = ChangeUser;
|
||||
Util.inherits(ChangeUser, Sequence);
|
||||
function ChangeUser(options, callback) {
|
||||
Sequence.call(this, options, callback);
|
||||
|
||||
this._user = options.user;
|
||||
this._password = options.password;
|
||||
this._database = options.database;
|
||||
this._charsetNumber = options.charsetNumber;
|
||||
this._currentConfig = options.currentConfig;
|
||||
}
|
||||
|
||||
ChangeUser.prototype.determinePacket = function determinePacket(firstByte) {
|
||||
switch (firstByte) {
|
||||
case 0xfe: return Packets.AuthSwitchRequestPacket;
|
||||
case 0xff: return Packets.ErrorPacket;
|
||||
default: return undefined;
|
||||
}
|
||||
};
|
||||
|
||||
ChangeUser.prototype.start = function(handshakeInitializationPacket) {
|
||||
var scrambleBuff = handshakeInitializationPacket.scrambleBuff();
|
||||
scrambleBuff = Auth.token(this._password, scrambleBuff);
|
||||
|
||||
var packet = new Packets.ComChangeUserPacket({
|
||||
user : this._user,
|
||||
scrambleBuff : scrambleBuff,
|
||||
database : this._database,
|
||||
charsetNumber : this._charsetNumber
|
||||
});
|
||||
|
||||
this._currentConfig.user = this._user;
|
||||
this._currentConfig.password = this._password;
|
||||
this._currentConfig.database = this._database;
|
||||
this._currentConfig.charsetNumber = this._charsetNumber;
|
||||
|
||||
this.emit('packet', packet);
|
||||
};
|
||||
|
||||
ChangeUser.prototype['AuthSwitchRequestPacket'] = function (packet) {
|
||||
var name = packet.authMethodName;
|
||||
var data = Auth.auth(name, packet.authMethodData, {
|
||||
password: this._password
|
||||
});
|
||||
|
||||
if (data !== undefined) {
|
||||
this.emit('packet', new Packets.AuthSwitchResponsePacket({
|
||||
data: data
|
||||
}));
|
||||
} else {
|
||||
var err = new Error('MySQL is requesting the ' + name + ' authentication method, which is not supported.');
|
||||
err.code = 'UNSUPPORTED_AUTH_METHOD';
|
||||
err.fatal = true;
|
||||
this.end(err);
|
||||
}
|
||||
};
|
||||
|
||||
ChangeUser.prototype['ErrorPacket'] = function(packet) {
|
||||
var err = this._packetToError(packet);
|
||||
err.fatal = true;
|
||||
this.end(err);
|
||||
};
|
||||
126
node_modules/mysql/lib/protocol/sequences/Handshake.js
generated
vendored
Normal file
126
node_modules/mysql/lib/protocol/sequences/Handshake.js
generated
vendored
Normal file
@ -0,0 +1,126 @@
|
||||
var Sequence = require('./Sequence');
|
||||
var Util = require('util');
|
||||
var Packets = require('../packets');
|
||||
var Auth = require('../Auth');
|
||||
var ClientConstants = require('../constants/client');
|
||||
|
||||
module.exports = Handshake;
|
||||
Util.inherits(Handshake, Sequence);
|
||||
function Handshake(options, callback) {
|
||||
Sequence.call(this, options, callback);
|
||||
|
||||
options = options || {};
|
||||
|
||||
this._config = options.config;
|
||||
this._handshakeInitializationPacket = null;
|
||||
}
|
||||
|
||||
Handshake.prototype.determinePacket = function determinePacket(firstByte, parser) {
|
||||
if (firstByte === 0xff) {
|
||||
return Packets.ErrorPacket;
|
||||
}
|
||||
|
||||
if (!this._handshakeInitializationPacket) {
|
||||
return Packets.HandshakeInitializationPacket;
|
||||
}
|
||||
|
||||
if (firstByte === 0xfe) {
|
||||
return (parser.packetLength() === 1)
|
||||
? Packets.UseOldPasswordPacket
|
||||
: Packets.AuthSwitchRequestPacket;
|
||||
}
|
||||
|
||||
return undefined;
|
||||
};
|
||||
|
||||
Handshake.prototype['AuthSwitchRequestPacket'] = function (packet) {
|
||||
var name = packet.authMethodName;
|
||||
var data = Auth.auth(name, packet.authMethodData, {
|
||||
password: this._config.password
|
||||
});
|
||||
|
||||
if (data !== undefined) {
|
||||
this.emit('packet', new Packets.AuthSwitchResponsePacket({
|
||||
data: data
|
||||
}));
|
||||
} else {
|
||||
var err = new Error('MySQL is requesting the ' + name + ' authentication method, which is not supported.');
|
||||
err.code = 'UNSUPPORTED_AUTH_METHOD';
|
||||
err.fatal = true;
|
||||
this.end(err);
|
||||
}
|
||||
};
|
||||
|
||||
Handshake.prototype['HandshakeInitializationPacket'] = function(packet) {
|
||||
this._handshakeInitializationPacket = packet;
|
||||
|
||||
this._config.protocol41 = packet.protocol41;
|
||||
|
||||
var serverSSLSupport = packet.serverCapabilities1 & ClientConstants.CLIENT_SSL;
|
||||
|
||||
if (this._config.ssl) {
|
||||
if (!serverSSLSupport) {
|
||||
var err = new Error('Server does not support secure connection');
|
||||
|
||||
err.code = 'HANDSHAKE_NO_SSL_SUPPORT';
|
||||
err.fatal = true;
|
||||
|
||||
this.end(err);
|
||||
return;
|
||||
}
|
||||
|
||||
this._config.clientFlags |= ClientConstants.CLIENT_SSL;
|
||||
this.emit('packet', new Packets.SSLRequestPacket({
|
||||
clientFlags : this._config.clientFlags,
|
||||
maxPacketSize : this._config.maxPacketSize,
|
||||
charsetNumber : this._config.charsetNumber
|
||||
}));
|
||||
this.emit('start-tls');
|
||||
} else {
|
||||
this._sendCredentials();
|
||||
}
|
||||
};
|
||||
|
||||
Handshake.prototype._tlsUpgradeCompleteHandler = function() {
|
||||
this._sendCredentials();
|
||||
};
|
||||
|
||||
Handshake.prototype._sendCredentials = function() {
|
||||
var packet = this._handshakeInitializationPacket;
|
||||
this.emit('packet', new Packets.ClientAuthenticationPacket({
|
||||
clientFlags : this._config.clientFlags,
|
||||
maxPacketSize : this._config.maxPacketSize,
|
||||
charsetNumber : this._config.charsetNumber,
|
||||
user : this._config.user,
|
||||
database : this._config.database,
|
||||
protocol41 : packet.protocol41,
|
||||
scrambleBuff : (packet.protocol41)
|
||||
? Auth.token(this._config.password, packet.scrambleBuff())
|
||||
: Auth.scramble323(packet.scrambleBuff(), this._config.password)
|
||||
}));
|
||||
};
|
||||
|
||||
Handshake.prototype['UseOldPasswordPacket'] = function() {
|
||||
if (!this._config.insecureAuth) {
|
||||
var err = new Error(
|
||||
'MySQL server is requesting the old and insecure pre-4.1 auth mechanism. ' +
|
||||
'Upgrade the user password or use the {insecureAuth: true} option.'
|
||||
);
|
||||
|
||||
err.code = 'HANDSHAKE_INSECURE_AUTH';
|
||||
err.fatal = true;
|
||||
|
||||
this.end(err);
|
||||
return;
|
||||
}
|
||||
|
||||
this.emit('packet', new Packets.OldPasswordPacket({
|
||||
scrambleBuff: Auth.scramble323(this._handshakeInitializationPacket.scrambleBuff(), this._config.password)
|
||||
}));
|
||||
};
|
||||
|
||||
Handshake.prototype['ErrorPacket'] = function(packet) {
|
||||
var err = this._packetToError(packet, true);
|
||||
err.fatal = true;
|
||||
this.end(err);
|
||||
};
|
||||
19
node_modules/mysql/lib/protocol/sequences/Ping.js
generated
vendored
Normal file
19
node_modules/mysql/lib/protocol/sequences/Ping.js
generated
vendored
Normal file
@ -0,0 +1,19 @@
|
||||
var Sequence = require('./Sequence');
|
||||
var Util = require('util');
|
||||
var Packets = require('../packets');
|
||||
|
||||
module.exports = Ping;
|
||||
Util.inherits(Ping, Sequence);
|
||||
|
||||
function Ping(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
Sequence.call(this, options, callback);
|
||||
}
|
||||
|
||||
Ping.prototype.start = function() {
|
||||
this.emit('packet', new Packets.ComPingPacket());
|
||||
};
|
||||
228
node_modules/mysql/lib/protocol/sequences/Query.js
generated
vendored
Normal file
228
node_modules/mysql/lib/protocol/sequences/Query.js
generated
vendored
Normal file
@ -0,0 +1,228 @@
|
||||
var ClientConstants = require('../constants/client');
|
||||
var fs = require('fs');
|
||||
var Packets = require('../packets');
|
||||
var ResultSet = require('../ResultSet');
|
||||
var Sequence = require('./Sequence');
|
||||
var ServerStatus = require('../constants/server_status');
|
||||
var Readable = require('readable-stream');
|
||||
var Util = require('util');
|
||||
|
||||
module.exports = Query;
|
||||
Util.inherits(Query, Sequence);
|
||||
function Query(options, callback) {
|
||||
Sequence.call(this, options, callback);
|
||||
|
||||
this.sql = options.sql;
|
||||
this.values = options.values;
|
||||
this.typeCast = (options.typeCast === undefined)
|
||||
? true
|
||||
: options.typeCast;
|
||||
this.nestTables = options.nestTables || false;
|
||||
|
||||
this._resultSet = null;
|
||||
this._results = [];
|
||||
this._fields = [];
|
||||
this._index = 0;
|
||||
this._loadError = null;
|
||||
}
|
||||
|
||||
Query.prototype.start = function() {
|
||||
this.emit('packet', new Packets.ComQueryPacket(this.sql));
|
||||
};
|
||||
|
||||
Query.prototype.determinePacket = function determinePacket(byte, parser) {
|
||||
var resultSet = this._resultSet;
|
||||
|
||||
if (!resultSet) {
|
||||
switch (byte) {
|
||||
case 0x00: return Packets.OkPacket;
|
||||
case 0xfb: return Packets.LocalInfileRequestPacket;
|
||||
case 0xff: return Packets.ErrorPacket;
|
||||
default: return Packets.ResultSetHeaderPacket;
|
||||
}
|
||||
}
|
||||
|
||||
if (resultSet.eofPackets.length === 0) {
|
||||
return (resultSet.fieldPackets.length < resultSet.resultSetHeaderPacket.fieldCount)
|
||||
? Packets.FieldPacket
|
||||
: Packets.EofPacket;
|
||||
}
|
||||
|
||||
if (byte === 0xff) {
|
||||
return Packets.ErrorPacket;
|
||||
}
|
||||
|
||||
if (byte === 0xfe && parser.packetLength() < 9) {
|
||||
return Packets.EofPacket;
|
||||
}
|
||||
|
||||
return Packets.RowDataPacket;
|
||||
};
|
||||
|
||||
Query.prototype['OkPacket'] = function(packet) {
|
||||
// try...finally for exception safety
|
||||
try {
|
||||
if (!this._callback) {
|
||||
this.emit('result', packet, this._index);
|
||||
} else {
|
||||
this._results.push(packet);
|
||||
this._fields.push(undefined);
|
||||
}
|
||||
} finally {
|
||||
this._index++;
|
||||
this._resultSet = null;
|
||||
this._handleFinalResultPacket(packet);
|
||||
}
|
||||
};
|
||||
|
||||
Query.prototype['ErrorPacket'] = function(packet) {
|
||||
var err = this._packetToError(packet);
|
||||
|
||||
var results = (this._results.length > 0)
|
||||
? this._results
|
||||
: undefined;
|
||||
|
||||
var fields = (this._fields.length > 0)
|
||||
? this._fields
|
||||
: undefined;
|
||||
|
||||
err.index = this._index;
|
||||
err.sql = this.sql;
|
||||
|
||||
this.end(err, results, fields);
|
||||
};
|
||||
|
||||
Query.prototype['LocalInfileRequestPacket'] = function(packet) {
|
||||
if (this._connection.config.clientFlags & ClientConstants.CLIENT_LOCAL_FILES) {
|
||||
this._sendLocalDataFile(packet.filename);
|
||||
} else {
|
||||
this._loadError = new Error('Load local files command is disabled');
|
||||
this._loadError.code = 'LOCAL_FILES_DISABLED';
|
||||
this._loadError.fatal = false;
|
||||
|
||||
this.emit('packet', new Packets.EmptyPacket());
|
||||
}
|
||||
};
|
||||
|
||||
Query.prototype['ResultSetHeaderPacket'] = function(packet) {
|
||||
this._resultSet = new ResultSet(packet);
|
||||
};
|
||||
|
||||
Query.prototype['FieldPacket'] = function(packet) {
|
||||
this._resultSet.fieldPackets.push(packet);
|
||||
};
|
||||
|
||||
Query.prototype['EofPacket'] = function(packet) {
|
||||
this._resultSet.eofPackets.push(packet);
|
||||
|
||||
if (this._resultSet.eofPackets.length === 1 && !this._callback) {
|
||||
this.emit('fields', this._resultSet.fieldPackets, this._index);
|
||||
}
|
||||
|
||||
if (this._resultSet.eofPackets.length !== 2) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (this._callback) {
|
||||
this._results.push(this._resultSet.rows);
|
||||
this._fields.push(this._resultSet.fieldPackets);
|
||||
}
|
||||
|
||||
this._index++;
|
||||
this._resultSet = null;
|
||||
this._handleFinalResultPacket(packet);
|
||||
};
|
||||
|
||||
Query.prototype._handleFinalResultPacket = function(packet) {
|
||||
if (packet.serverStatus & ServerStatus.SERVER_MORE_RESULTS_EXISTS) {
|
||||
return;
|
||||
}
|
||||
|
||||
var results = (this._results.length > 1)
|
||||
? this._results
|
||||
: this._results[0];
|
||||
|
||||
var fields = (this._fields.length > 1)
|
||||
? this._fields
|
||||
: this._fields[0];
|
||||
|
||||
this.end(this._loadError, results, fields);
|
||||
};
|
||||
|
||||
Query.prototype['RowDataPacket'] = function(packet, parser, connection) {
|
||||
packet.parse(parser, this._resultSet.fieldPackets, this.typeCast, this.nestTables, connection);
|
||||
|
||||
if (this._callback) {
|
||||
this._resultSet.rows.push(packet);
|
||||
} else {
|
||||
this.emit('result', packet, this._index);
|
||||
}
|
||||
};
|
||||
|
||||
Query.prototype._sendLocalDataFile = function(path) {
|
||||
var self = this;
|
||||
var localStream = fs.createReadStream(path, {
|
||||
flag : 'r',
|
||||
encoding : null,
|
||||
autoClose : true
|
||||
});
|
||||
|
||||
this.on('pause', function () {
|
||||
localStream.pause();
|
||||
});
|
||||
|
||||
this.on('resume', function () {
|
||||
localStream.resume();
|
||||
});
|
||||
|
||||
localStream.on('data', function (data) {
|
||||
self.emit('packet', new Packets.LocalDataFilePacket(data));
|
||||
});
|
||||
|
||||
localStream.on('error', function (err) {
|
||||
self._loadError = err;
|
||||
localStream.emit('end');
|
||||
});
|
||||
|
||||
localStream.on('end', function () {
|
||||
self.emit('packet', new Packets.EmptyPacket());
|
||||
});
|
||||
};
|
||||
|
||||
Query.prototype.stream = function(options) {
|
||||
var self = this;
|
||||
|
||||
options = options || {};
|
||||
options.objectMode = true;
|
||||
|
||||
var stream = new Readable(options);
|
||||
|
||||
stream._read = function() {
|
||||
self._connection && self._connection.resume();
|
||||
};
|
||||
|
||||
stream.once('end', function() {
|
||||
process.nextTick(function () {
|
||||
stream.emit('close');
|
||||
});
|
||||
});
|
||||
|
||||
this.on('result', function(row, i) {
|
||||
if (!stream.push(row)) self._connection.pause();
|
||||
stream.emit('result', row, i); // replicate old emitter
|
||||
});
|
||||
|
||||
this.on('error', function(err) {
|
||||
stream.emit('error', err); // Pass on any errors
|
||||
});
|
||||
|
||||
this.on('end', function() {
|
||||
stream.push(null); // pushing null, indicating EOF
|
||||
});
|
||||
|
||||
this.on('fields', function(fields, i) {
|
||||
stream.emit('fields', fields, i); // replicate old emitter
|
||||
});
|
||||
|
||||
return stream;
|
||||
};
|
||||
40
node_modules/mysql/lib/protocol/sequences/Quit.js
generated
vendored
Normal file
40
node_modules/mysql/lib/protocol/sequences/Quit.js
generated
vendored
Normal file
@ -0,0 +1,40 @@
|
||||
var Sequence = require('./Sequence');
|
||||
var Util = require('util');
|
||||
var Packets = require('../packets');
|
||||
|
||||
module.exports = Quit;
|
||||
Util.inherits(Quit, Sequence);
|
||||
function Quit(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
Sequence.call(this, options, callback);
|
||||
|
||||
this._started = false;
|
||||
}
|
||||
|
||||
Quit.prototype.end = function end(err) {
|
||||
if (this._ended) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!this._started) {
|
||||
Sequence.prototype.end.call(this, err);
|
||||
return;
|
||||
}
|
||||
|
||||
if (err && err.code === 'ECONNRESET' && err.syscall === 'read') {
|
||||
// Ignore read errors after packet sent
|
||||
Sequence.prototype.end.call(this);
|
||||
return;
|
||||
}
|
||||
|
||||
Sequence.prototype.end.call(this, err);
|
||||
};
|
||||
|
||||
Quit.prototype.start = function() {
|
||||
this._started = true;
|
||||
this.emit('packet', new Packets.ComQuitPacket());
|
||||
};
|
||||
125
node_modules/mysql/lib/protocol/sequences/Sequence.js
generated
vendored
Normal file
125
node_modules/mysql/lib/protocol/sequences/Sequence.js
generated
vendored
Normal file
@ -0,0 +1,125 @@
|
||||
var Util = require('util');
|
||||
var EventEmitter = require('events').EventEmitter;
|
||||
var Packets = require('../packets');
|
||||
var ErrorConstants = require('../constants/errors');
|
||||
var Timer = require('../Timer');
|
||||
|
||||
// istanbul ignore next: Node.js < 0.10 not covered
|
||||
var listenerCount = EventEmitter.listenerCount
|
||||
|| function(emitter, type){ return emitter.listeners(type).length; };
|
||||
|
||||
var LONG_STACK_DELIMITER = '\n --------------------\n';
|
||||
|
||||
module.exports = Sequence;
|
||||
Util.inherits(Sequence, EventEmitter);
|
||||
function Sequence(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
EventEmitter.call(this);
|
||||
|
||||
options = options || {};
|
||||
|
||||
this._callback = callback;
|
||||
this._callSite = null;
|
||||
this._ended = false;
|
||||
this._timeout = options.timeout;
|
||||
this._timer = new Timer(this);
|
||||
}
|
||||
|
||||
Sequence.determinePacket = function(byte) {
|
||||
switch (byte) {
|
||||
case 0x00: return Packets.OkPacket;
|
||||
case 0xfe: return Packets.EofPacket;
|
||||
case 0xff: return Packets.ErrorPacket;
|
||||
default: return undefined;
|
||||
}
|
||||
};
|
||||
|
||||
Sequence.prototype.hasErrorHandler = function() {
|
||||
return Boolean(this._callback) || listenerCount(this, 'error') > 1;
|
||||
};
|
||||
|
||||
Sequence.prototype._packetToError = function(packet) {
|
||||
var code = ErrorConstants[packet.errno] || 'UNKNOWN_CODE_PLEASE_REPORT';
|
||||
var err = new Error(code + ': ' + packet.message);
|
||||
err.code = code;
|
||||
err.errno = packet.errno;
|
||||
|
||||
err.sqlMessage = packet.message;
|
||||
err.sqlState = packet.sqlState;
|
||||
|
||||
return err;
|
||||
};
|
||||
|
||||
Sequence.prototype.end = function(err) {
|
||||
if (this._ended) {
|
||||
return;
|
||||
}
|
||||
|
||||
this._ended = true;
|
||||
|
||||
if (err) {
|
||||
this._addLongStackTrace(err);
|
||||
}
|
||||
|
||||
// Without this we are leaking memory. This problem was introduced in
|
||||
// 8189925374e7ce3819bbe88b64c7b15abac96b16. I suspect that the error object
|
||||
// causes a cyclic reference that the GC does not detect properly, but I was
|
||||
// unable to produce a standalone version of this leak. This would be a great
|
||||
// challenge for somebody interested in difficult problems : )!
|
||||
this._callSite = null;
|
||||
|
||||
// try...finally for exception safety
|
||||
try {
|
||||
if (err) {
|
||||
this.emit('error', err);
|
||||
}
|
||||
} finally {
|
||||
try {
|
||||
if (this._callback) {
|
||||
this._callback.apply(this, arguments);
|
||||
}
|
||||
} finally {
|
||||
this.emit('end');
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Sequence.prototype['OkPacket'] = function(packet) {
|
||||
this.end(null, packet);
|
||||
};
|
||||
|
||||
Sequence.prototype['ErrorPacket'] = function(packet) {
|
||||
this.end(this._packetToError(packet));
|
||||
};
|
||||
|
||||
// Implemented by child classes
|
||||
Sequence.prototype.start = function() {};
|
||||
|
||||
Sequence.prototype._addLongStackTrace = function _addLongStackTrace(err) {
|
||||
var callSiteStack = this._callSite && this._callSite.stack;
|
||||
|
||||
if (!callSiteStack || typeof callSiteStack !== 'string') {
|
||||
// No recorded call site
|
||||
return;
|
||||
}
|
||||
|
||||
if (err.stack.indexOf(LONG_STACK_DELIMITER) !== -1) {
|
||||
// Error stack already looks long
|
||||
return;
|
||||
}
|
||||
|
||||
var index = callSiteStack.indexOf('\n');
|
||||
|
||||
if (index !== -1) {
|
||||
// Append recorded call site
|
||||
err.stack += LONG_STACK_DELIMITER + callSiteStack.substr(index + 1);
|
||||
}
|
||||
};
|
||||
|
||||
Sequence.prototype._onTimeout = function _onTimeout() {
|
||||
this.emit('timeout');
|
||||
};
|
||||
30
node_modules/mysql/lib/protocol/sequences/Statistics.js
generated
vendored
Normal file
30
node_modules/mysql/lib/protocol/sequences/Statistics.js
generated
vendored
Normal file
@ -0,0 +1,30 @@
|
||||
var Sequence = require('./Sequence');
|
||||
var Util = require('util');
|
||||
var Packets = require('../packets');
|
||||
|
||||
module.exports = Statistics;
|
||||
Util.inherits(Statistics, Sequence);
|
||||
function Statistics(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
Sequence.call(this, options, callback);
|
||||
}
|
||||
|
||||
Statistics.prototype.start = function() {
|
||||
this.emit('packet', new Packets.ComStatisticsPacket());
|
||||
};
|
||||
|
||||
Statistics.prototype['StatisticsPacket'] = function (packet) {
|
||||
this.end(null, packet);
|
||||
};
|
||||
|
||||
Statistics.prototype.determinePacket = function determinePacket(firstByte) {
|
||||
if (firstByte === 0x55) {
|
||||
return Packets.StatisticsPacket;
|
||||
}
|
||||
|
||||
return undefined;
|
||||
};
|
||||
7
node_modules/mysql/lib/protocol/sequences/index.js
generated
vendored
Normal file
7
node_modules/mysql/lib/protocol/sequences/index.js
generated
vendored
Normal file
@ -0,0 +1,7 @@
|
||||
exports.ChangeUser = require('./ChangeUser');
|
||||
exports.Handshake = require('./Handshake');
|
||||
exports.Ping = require('./Ping');
|
||||
exports.Query = require('./Query');
|
||||
exports.Quit = require('./Quit');
|
||||
exports.Sequence = require('./Sequence');
|
||||
exports.Statistics = require('./Statistics');
|
||||
98
node_modules/mysql/package.json
generated
vendored
Normal file
98
node_modules/mysql/package.json
generated
vendored
Normal file
@ -0,0 +1,98 @@
|
||||
{
|
||||
"_from": "mysql@^2.18.1",
|
||||
"_id": "mysql@2.18.1",
|
||||
"_inBundle": false,
|
||||
"_integrity": "sha512-Bca+gk2YWmqp2Uf6k5NFEurwY/0td0cpebAucFpY/3jhrwrVGuxU2uQFCHjU19SJfje0yQvi+rVWdq78hR5lig==",
|
||||
"_location": "/mysql",
|
||||
"_phantomChildren": {},
|
||||
"_requested": {
|
||||
"type": "range",
|
||||
"registry": true,
|
||||
"raw": "mysql@^2.18.1",
|
||||
"name": "mysql",
|
||||
"escapedName": "mysql",
|
||||
"rawSpec": "^2.18.1",
|
||||
"saveSpec": null,
|
||||
"fetchSpec": "^2.18.1"
|
||||
},
|
||||
"_requiredBy": [
|
||||
"#USER",
|
||||
"/"
|
||||
],
|
||||
"_resolved": "https://registry.npmjs.org/mysql/-/mysql-2.18.1.tgz",
|
||||
"_shasum": "2254143855c5a8c73825e4522baf2ea021766717",
|
||||
"_spec": "mysql@^2.18.1",
|
||||
"_where": "E:\\IntellijProjects\\woam-antispam-bot",
|
||||
"author": {
|
||||
"name": "Felix Geisendörfer",
|
||||
"email": "felix@debuggable.com",
|
||||
"url": "http://debuggable.com/"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/mysqljs/mysql/issues"
|
||||
},
|
||||
"bundleDependencies": false,
|
||||
"contributors": [
|
||||
{
|
||||
"name": "Andrey Sidorov",
|
||||
"email": "sidorares@yandex.ru"
|
||||
},
|
||||
{
|
||||
"name": "Bradley Grainger",
|
||||
"email": "bgrainger@gmail.com"
|
||||
},
|
||||
{
|
||||
"name": "Douglas Christopher Wilson",
|
||||
"email": "doug@somethingdoug.com"
|
||||
},
|
||||
{
|
||||
"name": "Diogo Resende",
|
||||
"email": "dresende@thinkdigital.pt"
|
||||
},
|
||||
{
|
||||
"name": "Nathan Woltman",
|
||||
"email": "nwoltman@outlook.com"
|
||||
}
|
||||
],
|
||||
"dependencies": {
|
||||
"bignumber.js": "9.0.0",
|
||||
"readable-stream": "2.3.7",
|
||||
"safe-buffer": "5.1.2",
|
||||
"sqlstring": "2.3.1"
|
||||
},
|
||||
"deprecated": false,
|
||||
"description": "A node.js driver for mysql. It is written in JavaScript, does not require compiling, and is 100% MIT licensed.",
|
||||
"devDependencies": {
|
||||
"after": "0.8.2",
|
||||
"eslint": "5.16.0",
|
||||
"seedrandom": "3.0.5",
|
||||
"timezone-mock": "0.0.7",
|
||||
"urun": "0.0.8",
|
||||
"utest": "0.0.8"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">= 0.6"
|
||||
},
|
||||
"files": [
|
||||
"lib/",
|
||||
"Changes.md",
|
||||
"License",
|
||||
"Readme.md",
|
||||
"index.js"
|
||||
],
|
||||
"homepage": "https://github.com/mysqljs/mysql#readme",
|
||||
"license": "MIT",
|
||||
"name": "mysql",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/mysqljs/mysql.git"
|
||||
},
|
||||
"scripts": {
|
||||
"lint": "eslint . && node tool/lint-readme.js",
|
||||
"test": "node test/run.js",
|
||||
"test-ci": "node tool/install-nyc.js --nyc-optional --reporter=text -- npm test",
|
||||
"test-cov": "node tool/install-nyc.js --reporter=html --reporter=text -- npm test",
|
||||
"version": "node tool/version-changes.js && git add Changes.md"
|
||||
},
|
||||
"version": "2.18.1"
|
||||
}
|
||||
Reference in New Issue
Block a user