Skip to content

public / sequelize

Go to a project

不要怂，就是干，撸起袖子干！

Commit 1c5aac4c by Jan Aagaard Meier
Options

Refactored .query for all dialects to return promises

1 parent bbd668eb
Inline Side-by-side
Showing with 290 additions and 272 deletions
lib/dialects/mariadb/connector-manager.js
......@@ -159,54 +159,88 @@ module.exports = (function() {
Utils._.extend(ConnectorManager.prototype, require("../abstract/connector-manager").prototype)
ConnectorManager.prototype.query = function(sql, callee, options) {
if (!this.isConnected && !this.pool) {
this.connect()
}
var self = this
options = options || {}
if (this.useQueue) {
// If queueing we'll let the execQueueItem method handle connecting
var queueItem = {
query: new Query(this.client, this.sequelize, callee, options || {}),
client: this.client,
query: new Query(null, this.sequelize, callee, options),
sql: sql
}
};
queueItem.query.options.uuid = this.config.uuid
enqueue.call(this, queueItem, options)
return queueItem.query
return queueItem.query.promise.finally(function () {
afterQuery.call(self, queueItem)
})
}
var self = this
, query = new Query(this.client, this.sequelize, callee, options || {})
this.pendingQueries++
query.done(function() {
self.pendingQueries--
if (self.pool) {
self.pool.release(query.client)
} else {
if (self.pendingQueries === 0) {
setTimeout(function() {
self.pendingQueries === 0 && self.disconnect.call(self)
}, 100)
var query = new Query(null, this.sequelize, callee, options);
this.pendingQueries++;
query.options.uuid = this.config.uuid
return this.getConnection(options).then(function (client) {
query.client = client
return query.run(sql).finally(function () {
self.pendingQueries--;
if (self.pool) {
self.pool.release(query.client);
} else {
if (self.pendingQueries === 0) {
setTimeout(function() {
if (self.pendingQueries === 0){
self.disconnect.call(self);
}
}, 100);
}
}
}
});
})
};
ConnectorManager.prototype.getConnection = function(options) {
var self = this;
if (!this.pool) {
query.run(sql)
} else {
this.pool.acquire(function(err, client) {
if (err) {
return query.emit('error', err)
}
options = options || {}
query.client = client
query.run(sql)
return
}, undefined, options.type)
}
return new Utils.Promise(function (resolve, reject) {
if (!self.pool) {
// Regular client caching
if (self.client) {
return resolve(self.client);
} else {
// Cache for concurrent queries
if (self._getConnection) {
return resolve(self._getConnection)
}
return query
}
// Set cache and acquire connection
self._getConnection = this;
connect.call(self, function(err, client) {
if (err) {
return reject(err);
}
// Unset caching, should now be caught by the self.client check
self._getConnection = null;
self.client = client;
resolve(client);
});
}
} else {
// Acquire from pool
self.pool.acquire(function(err, client) {
if (err) {
return reject(err);
}
resolve(client);
}, options.priority, options.type);
}
})
};
ConnectorManager.prototype.connect = function() {
var self = this
......@@ -228,10 +262,12 @@ module.exports = (function() {
return
}
// private
var disconnect = function(client) {
if (!client) {
return // TODO possible orphaning of clients?
}
var self = this
if (!this.useQueue) {
this.client = null
......@@ -257,7 +293,7 @@ module.exports = (function() {
var connect = function(done, config) {
config = config || this.config
var self = this
, client
......@@ -324,7 +360,7 @@ module.exports = (function() {
var self = this
this.pool.acquire(function(err, client) {
if (err) {
queueItem.query.emit('error', err)
queueItem.query.reject(err)
return
}
//we set the client here, asynchronously, when getting a pooled connection
......@@ -367,12 +403,6 @@ module.exports = (function() {
var execQueueItem = function(queueItem) {
var self = this
queueItem.query
.success(function(){ afterQuery.call(self, queueItem) })
.error(function(){ afterQuery.call(self, queueItem) })
queueItem.query.run(queueItem.sql, queueItem.client)
}
......
lib/dialects/mariadb/query.js
......@@ -12,7 +12,12 @@ module.exports = (function() {
raw: false
}, options || {})
var self = this
this.checkLoggingOption()
this.promise = new Utils.Promise(function (resolve, reject) {
self.resolve = resolve
self.reject = reject
})
}
Utils.inherit(Query, AbstractQuery)
......@@ -87,9 +92,9 @@ module.exports = (function() {
})
.on('error', function(err) {
errorDetected = true
self.emit('sql', self.sql)
self.promise.emit('sql', self.sql)
err.sql = sql
self.emit('error', err, self.callee)
self.reject(err)
})
.on('end', function(info) {
if (alreadyEnded || errorDetected) {
......@@ -97,19 +102,18 @@ module.exports = (function() {
}
alreadyEnded = true
self.emit('sql', self.sql)
self.promise.emit('sql', self.sql)
// we need to figure out whether to send the result set
// or info depending upon the type of query
if (/^call/.test(self.sql.toLowerCase())) {
self.emit('success', resultSet)
self.resolve(resultSet)
} else if( /^show/.test(self.sql.toLowerCase()) ||
/^select/.test(self.sql.toLowerCase()) ||
/^describe/.test(self.sql.toLowerCase())) {
self.emit('success', self.formatResults(resultSet))
self.resolve(self.formatResults(resultSet))
} else {
self.emit('success', self.formatResults(info))
self.resolve(self.formatResults(info))
}
})
})
.on('error', function(err) {
......@@ -117,12 +121,12 @@ module.exports = (function() {
return
}
errorDetected = true
self.emit('sql', self.sql)
self.emit('error', err, self.callee)
self.promise.emit('sql', self.sql)
self.reject(err)
})
.setMaxListeners(100)
return this
return this.promise
}
return Query
......
lib/dialects/mysql/connector-manager.js
......@@ -2,7 +2,7 @@ var mysql
, Pooling = require('generic-pool')
, Query = require("./query")
, Utils = require("../../utils")
, without = function(arr, elem) { return arr.filter(function(e) { return e != elem }) }
, without = function(arr, elem) { return arr.filter(function(e) { return e.query.uuid != elem.query.uuid }) }
module.exports = (function() {
var ConnectorManager = function(sequelize, config) {
......@@ -160,79 +160,75 @@ module.exports = (function() {
Utils._.extend(ConnectorManager.prototype, require("../abstract/connector-manager").prototype);
ConnectorManager.prototype.query = function(sql, callee, options) {
var self = this
options = options || {}
if (this.useQueue) {
// If queueing we'll let the execQueueItem method handle connecting
var queueItem = {
query: new Query(null, this.sequelize, callee, options || {}),
query: new Query(null, this.sequelize, callee, options),
sql: sql
};
queueItem.query.options.uuid = this.config.uuid
enqueue.call(this, queueItem, options);
return queueItem.query;
enqueue.call(this, queueItem, options)
return queueItem.query.promise.finally(function () {
afterQuery.call(self, queueItem)
})
}
var self = this, query = new Query(null, this.sequelize, callee, options || {});
var query = new Query(null, this.sequelize, callee, options);
this.pendingQueries++;
query.options.uuid = this.config.uuid
query.done(function() {
self.pendingQueries--;
if (self.pool) {
self.pool.release(query.client);
} else {
if (self.pendingQueries === 0) {
setTimeout(function() {
if (self.pendingQueries === 0){
self.disconnect.call(self);
}
}, 100);
}
}
});
this.getConnection(options, function (err, client) {
if (err) {
return query.emit('error', err)
}
return this.getConnection(options).then(function (client) {
query.client = client
query.run(sql)
});
return query;
return query.run(sql).finally(function () {
self.pendingQueries--;
if (self.pool) {
self.pool.release(query.client);
} else {
if (self.pendingQueries === 0) {
setTimeout(function() {
if (self.pendingQueries === 0){
self.disconnect.call(self);
}
}, 100);
}
}
});
})
};
ConnectorManager.prototype.getConnection = function(options, callback) {
ConnectorManager.prototype.getConnection = function(options) {
var self = this;
if (typeof options === "function") {
callback = options;
options = {};
}
options = options || {}
return new Utils.CustomEventEmitter(function (emitter) {
return new Utils.Promise(function (resolve, reject) {
if (!self.pool) {
// Regular client caching
if (self.client) {
return emitter.emit('success', self.client);
return resolve(self.client);
} else {
// Cache for concurrent queries
if (self._getConnection) {
self._getConnection.proxy(emitter);
return;
return resolve(self._getConnection)
}
// Set cache and acquire connection
self._getConnection = emitter;
self._getConnection = this;
connect.call(self, function(err, client) {
if (err) {
return emitter.emit('error', err);
return reject(err);
}
// Unset caching, should now be caught by the self.client check
self._getConnection = null;
self.client = client;
emitter.emit('success', client);
resolve(client);
});
}
}
......@@ -240,12 +236,12 @@ module.exports = (function() {
// Acquire from pool
self.pool.acquire(function(err, client) {
if (err) {
return emitter.emit('error', err);
return reject(err);
}
emitter.emit('success', client);
resolve(client);
}, options.priority, options.type);
}
}).run().done(callback);
})
};
ConnectorManager.prototype.disconnect = function() {
......@@ -255,13 +251,15 @@ module.exports = (function() {
return
};
// private
var disconnect = function(client) {
var self = this;
this.client = null;
if (!client) {
return
}
client.end(function() {
if (!self.useQueue) {
return client.destroy();
......@@ -269,7 +267,6 @@ module.exports = (function() {
var intervalObj = null
var cleanup = function () {
var retryCt = 0
// make sure to let client finish before calling destroy
if (client._queue && (client._queue.length > 0)) {
return
......@@ -287,7 +284,6 @@ module.exports = (function() {
var connect = function(done, config) {
config = config || this.config
var emitter = new (require('events').EventEmitter)()
var connectionConfig = {
host: config.host,
port: config.port,
......@@ -309,22 +305,22 @@ module.exports = (function() {
switch(err.code) {
case 'ECONNREFUSED':
case 'ER_ACCESS_D2ENIED_ERROR':
emitter.emit('error', 'Failed to authenticate for MySQL. Please double check your settings.')
done('Failed to authenticate for MySQL. Please double check your settings.')
break
case 'ENOTFOUND':
case 'EHOSTUNREACH':
case 'EINVAL':
emitter.emit('error', 'Failed to find MySQL server. Please double check your settings.')
done('Failed to find MySQL server. Please double check your settings.')
break
default:
emitter.emit('error', err);
done(err);
break;
}
return;
}
emitter.emit('success', connection);
done(null, connection);
})
connection.query("SET time_zone = '+0:00'");
......@@ -333,13 +329,6 @@ module.exports = (function() {
if (config.pool !== null && config.pool.handleDisconnects) {
handleDisconnect(this.pool, connection)
}
emitter.on('error', function (err) {
done(err);
});
emitter.on('success', function (connection) {
done(null, connection);
});
}
var handleDisconnect = function(pool, client) {
......@@ -388,26 +377,17 @@ module.exports = (function() {
disconnectIfNoConnections.call(this)
}
var execQueueItem = function(queueItem) {
var self = this
self.getConnection({
this.getConnection({
priority: queueItem.query.options.priority,
type: queueItem.query.options.type
}, function (err, connection) {
if (err) {
queueItem.query.emit('error', err)
return
}
}).then(function (connection) {
queueItem.query.client = connection
queueItem.client = connection
queueItem.query
.success(function(){ afterQuery.call(self, queueItem) })
.error(function(){ afterQuery.call(self, queueItem) })
queueItem.query.run(queueItem.sql, queueItem.client)
queueItem.query.run(queueItem.sql)
}, function (err) {
queueItem.query.reject(err)
})
}
......@@ -421,7 +401,7 @@ module.exports = (function() {
})
ConnectorManager.prototype.__defineGetter__('isConnected', function() {
return this.client != null
return this.client !== null
})
var disconnectIfNoConnections = function() {
......
lib/dialects/mysql/query.js
var Utils = require("../../utils")
, AbstractQuery = require('../abstract/query')
, uuid = require('node-uuid')
module.exports = (function() {
var Query = function(client, sequelize, callee, options) {
this.client = client
this.callee = callee
this.sequelize = sequelize
this.uuid = uuid.v4()
this.options = Utils._.extend({
logging: console.log,
plain: false,
raw: false
}, options || {})
var self = this
this.checkLoggingOption()
this.promise = new Utils.Promise(function (resolve, reject) {
self.resolve = resolve
self.reject = reject
})
}
Utils.inherit(Query, AbstractQuery)
Query.prototype.run = function(sql) {
var self = this
this.sql = sql
if (this.options.logging !== false) {
this.sequelize.log('Executing (' + this.options.uuid + '): ' + this.sql)
}
this.client.query(this.sql, function(err, results, fields) {
this.emit('sql', this.sql, this.options.uuid)
self.client.query(self.sql, function(err, results, fields) {
self.promise.emit('sql', self.sql, self.options.uuid)
if (err) {
err.sql = sql
this.emit('error', err)
self.reject(err)
} else {
this.emit('success', this.formatResults(results))
self.resolve(self.formatResults(results))
}
}.bind(this)).setMaxListeners(100)
return this
}).setMaxListeners(100)
return this.promise
}
return Query
......
lib/dialects/sqlite/query.js
......@@ -23,6 +23,7 @@ module.exports = (function() {
Query.prototype.run = function(sql) {
var self = this
, promise
this.sql = sql
......@@ -30,70 +31,145 @@ module.exports = (function() {
this.sequelize.log('Executing (' + this.options.uuid + '): ' + this.sql)
}
var columnTypes = {}
this.database.serialize(function() {
var executeSql = function() {
if (self.sql.indexOf('-- ') === 0) {
// the sql query starts with a comment. don't bother the server with that ...
Utils.tick(function() {
self.emit('sql', self.sql, self.options.uuid)
self.emit('success', null)
})
} else {
self.database[getDatabaseMethod.call(self)](self.sql, function(err, results) {
// allow clients to listen to sql to do their own logging or whatnot
self.emit('sql', self.sql, self.options.uuid)
if (err) {
err.sql = self.sql
onFailure.call(self, err)
} else {
this.columnTypes = columnTypes
onSuccess.call(self, results, this)
}
})
}
}
if ((getDatabaseMethod.call(self) === 'all')) {
var tableNames = []
if (self.options && self.options.tableNames) {
tableNames = self.options.tableNames
} else if (/FROM `(.*?)`/i.exec(self.sql)) {
tableNames.push(/FROM `(.*?)`/i.exec(self.sql)[1])
}
return new Utils.Promise(function (resolve) {
var columnTypes = {}
promise = this
self.database.serialize(function() {
var executeSql = function() {
if (self.sql.indexOf('-- ') === 0) {
// the sql query starts with a comment. don't bother the server with that ...
promise.emit('sql', self.sql, self.options.uuid)
return resolve()
} else {
resolve(new Utils.Promise(function (resolve, reject) {
self.database[getDatabaseMethod.call(self)](self.sql, function(err, results) {
// allow clients to listen to sql to do their own logging or whatnot
promise.emit('sql', self.sql, self.options.uuid)
if (err) {
err.sql = self.sql
reject(err)
} else {
var metaData = this
metaData.columnTypes = columnTypes
var result = self.callee
// add the inserted row id to the instance
if (self.send('isInsertQuery', results, metaData)) {
self.send('handleInsertQuery', results, metaData)
}
if (!tableNames.length) {
executeSql()
} else {
var execute = Utils._.after(tableNames.length, executeSql)
tableNames.forEach(function (tableName) {
if (tableName !== 'sqlite_master') {
// get the column types
self.database.all("PRAGMA table_info(" + tableName + ")", function(err, results) {
if (!err) {
for (var i=0, l=results.length; i<l; i++) {
columnTypes[tableName + '.' + results[i].name] = columnTypes[results[i].name] = results[i].type
if (self.sql.indexOf('sqlite_master') !== -1) {
result = results.map(function(resultSet) { return resultSet.name })
} else if (self.send('isSelectQuery')) {
if(!self.options.raw) {
results = results.map(function(result) {
for (var name in result) {
if (result.hasOwnProperty(name) && metaData.columnTypes[name]) {
if (metaData.columnTypes[name] === 'DATETIME') {
// we need to convert the timestamps into actual date objects
var val = result[name]
if (val !== null) {
result[name] = new Date(val+'Z') // Z means UTC
}
} else if (metaData.columnTypes[name].lastIndexOf('BLOB') !== -1) {
if (result[name]) {
result[name] = new Buffer(result[name])
}
}
}
}
return result
})
}
result = self.send('handleSelectQuery', results)
} else if (self.send('isShowOrDescribeQuery')) {
result = results
} else if (self.sql.indexOf('PRAGMA INDEX_LIST') !== -1) {
// this is the sqlite way of getting the indexes of a table
result = results.map(function(result) {
return {
name: result.name,
tableName: result.name.split('_')[0],
unique: (result.unique === 0)
}
})
} else if (self.sql.indexOf('PRAGMA TABLE_INFO') !== -1) {
// this is the sqlite way of getting the metadata of a table
result = {}
results.forEach(function(_result) {
result[_result.name] = {
type: _result.type,
allowNull: (_result.notnull === 0),
defaultValue: _result.dflt_value
}
if (result[_result.name].type === 'TINYINT(1)') {
result[_result.name].defaultValue = { '0': false, '1': true }[result[_result.name].defaultValue]
}
if (result[_result.name].defaultValue === undefined) {
result[_result.name].defaultValue = null
}
if (typeof result[_result.name].defaultValue === 'string') {
result[_result.name].defaultValue = result[_result.name].defaultValue.replace(/'/g, "")
}
})
} else if (self.sql.indexOf('PRAGMA foreign_keys;') !== -1) {
result = results[0]
} else if (self.sql.indexOf('PRAGMA foreign_keys') !== -1) {
result = results
} else if ([QueryTypes.BULKUPDATE, QueryTypes.BULKDELETE].indexOf(self.options.type) !== -1) {
result = metaData.changes
}
resolve(result)
}
execute()
});
} else {
execute()
}
})
})
}))
}
}
} else {
executeSql()
}
})
return this
if ((getDatabaseMethod.call(self) === 'all')) {
var tableNames = []
if (self.options && self.options.tableNames) {
tableNames = self.options.tableNames
} else if (/FROM `(.*?)`/i.exec(self.sql)) {
tableNames.push(/FROM `(.*?)`/i.exec(self.sql)[1])
}
if (!tableNames.length) {
return executeSql()
} else {
return Utils.Promise.map(tableNames, function (tableName) {
if (tableName !== 'sqlite_master') {
return new Utils.Promise(function (resolve) {
// get the column types
self.database.all("PRAGMA table_info(" + tableName + ")", function(err, results) {
if (!err) {
for (var i=0, l=results.length; i<l; i++) {
columnTypes[tableName + '.' + results[i].name] = columnTypes[results[i].name] = results[i].type
}
}
resolve()
});
})
}
}).then(executeSql)
}
} else {
return executeSql()
}
})
})
}
//private
var getDatabaseMethod = function() {
if (this.send('isInsertQuery') || this.send('isUpdateQuery') || (this.sql.toLowerCase().indexOf('CREATE TEMPORARY TABLE'.toLowerCase()) !== -1) || this.options.type === QueryTypes.BULKDELETE) {
return 'run'
......@@ -102,87 +178,5 @@ module.exports = (function() {
}
}
var onSuccess = function(results, metaData) {
var result = this.callee
// add the inserted row id to the instance
if (this.send('isInsertQuery', results, metaData)) {
this.send('handleInsertQuery', results, metaData)
}
if (this.sql.indexOf('sqlite_master') !== -1) {
result = results.map(function(resultSet) { return resultSet.name })
} else if (this.send('isSelectQuery')) {
if(!this.options.raw) {
results = results.map(function(result) {
for (var name in result) {
if (result.hasOwnProperty(name) && metaData.columnTypes[name]) {
if (metaData.columnTypes[name] === 'DATETIME') {
// we need to convert the timestamps into actual date objects
var val = result[name]
if (val !== null) {
result[name] = new Date(val+'Z') // Z means UTC
}
} else if (metaData.columnTypes[name].lastIndexOf('BLOB') !== -1) {
if (result[name]) {
result[name] = new Buffer(result[name])
}
}
}
}
return result
})
}
result = this.send('handleSelectQuery', results)
} else if (this.send('isShowOrDescribeQuery')) {
result = results
} else if (this.sql.indexOf('PRAGMA INDEX_LIST') !== -1) {
// this is the sqlite way of getting the indexes of a table
result = results.map(function(result) {
return {
name: result.name,
tableName: result.name.split('_')[0],
unique: (result.unique === 0)
}
})
} else if (this.sql.indexOf('PRAGMA TABLE_INFO') !== -1) {
// this is the sqlite way of getting the metadata of a table
result = {}
results.forEach(function(_result) {
result[_result.name] = {
type: _result.type,
allowNull: (_result.notnull === 0),
defaultValue: _result.dflt_value
}
if (result[_result.name].type === 'TINYINT(1)') {
result[_result.name].defaultValue = { '0': false, '1': true }[result[_result.name].defaultValue]
}
if (result[_result.name].defaultValue === undefined) {
result[_result.name].defaultValue = null
}
if (typeof result[_result.name].defaultValue === 'string') {
result[_result.name].defaultValue = result[_result.name].defaultValue.replace(/'/g, "")
}
})
} else if (this.sql.indexOf('PRAGMA foreign_keys;') !== -1) {
result = results[0]
} else if (this.sql.indexOf('PRAGMA foreign_keys') !== -1) {
result = results
} else if ([QueryTypes.BULKUPDATE, QueryTypes.BULKDELETE].indexOf(this.options.type) !== -1) {
result = metaData.changes
}
this.emit('success', result)
}
var onFailure = function(err) {
this.emit('error', err, this.callee)
}
return Query
})()
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!