1497 lines
44 KiB
JavaScript
1497 lines
44 KiB
JavaScript
// Copyright IBM Corp. 2014,2016. All Rights Reserved.
|
|
// Node module: loopback-connector
|
|
// This file is licensed under the MIT License.
|
|
// License text available at https://opensource.org/licenses/MIT
|
|
|
|
var SG = require('strong-globalize');
|
|
var g = SG();
|
|
|
|
var util = require('util');
|
|
var async = require('async');
|
|
var assert = require('assert');
|
|
var Connector = require('./connector');
|
|
var debug = require('debug')('loopback:connector:sql');
|
|
var ParameterizedSQL = require('./parameterized-sql');
|
|
var Transaction = require('./transaction');
|
|
|
|
module.exports = SQLConnector;
|
|
|
|
function NOOP() {}
|
|
|
|
/**
|
|
* Base class for connectors that connect to relational databases using SQL
|
|
* @class
|
|
*/
|
|
function SQLConnector() {
|
|
// Call the super constructor
|
|
Connector.apply(this, [].slice.call(arguments));
|
|
}
|
|
|
|
// Inherit from the base Connector
|
|
util.inherits(SQLConnector, Connector);
|
|
|
|
// Export ParameterizedSQL
|
|
SQLConnector.ParameterizedSQL = ParameterizedSQL;
|
|
|
|
// The generic placeholder
|
|
var PLACEHOLDER = SQLConnector.PLACEHOLDER = ParameterizedSQL.PLACEHOLDER;
|
|
|
|
SQLConnector.Transaction = Transaction;
|
|
|
|
/**
|
|
* Set the relational property to indicate the backend is a relational DB
|
|
* @type {boolean}
|
|
*/
|
|
SQLConnector.prototype.relational = true;
|
|
|
|
/**
|
|
* Invoke a prototype method on the super class
|
|
* @param {String} methodName Method name
|
|
*/
|
|
SQLConnector.prototype.invokeSuper = function(methodName) {
|
|
var args = [].slice.call(arguments, 1);
|
|
var superMethod = this.constructor.super_.prototype[methodName];
|
|
return superMethod.apply(this, args);
|
|
};
|
|
|
|
/**
|
|
* Get types associated with the connector
|
|
* Returns {String[]} The types for the connector
|
|
*/
|
|
SQLConnector.prototype.getTypes = function() {
|
|
return ['db', 'rdbms', 'sql'];
|
|
};
|
|
|
|
/**
|
|
* Get the default data type for ID
|
|
* @param prop Property definition
|
|
* Returns {Function}
|
|
*/
|
|
SQLConnector.prototype.getDefaultIdType = function(prop) {
|
|
return Number;
|
|
};
|
|
|
|
/**
|
|
* Get the default database schema name
|
|
* @returns {string} The default schema name, such as 'public' or 'dbo'
|
|
*/
|
|
SQLConnector.prototype.getDefaultSchemaName = function() {
|
|
return '';
|
|
};
|
|
|
|
/**
|
|
* Get the database schema name for the given model. The schema name can be
|
|
* customized at model settings or connector configuration level as `schema` or
|
|
* `schemaName`. For example,
|
|
*
|
|
* ```json
|
|
* "Customer": {
|
|
* "name": "Customer",
|
|
* "mysql": {
|
|
* "schema": "MYDB",
|
|
* "table": "CUSTOMER"
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* @param {String} model The model name
|
|
* @returns {String} The database schema name
|
|
*/
|
|
SQLConnector.prototype.schema = function(model) {
|
|
// Check if there is a 'schema' property for connector
|
|
var dbMeta = this.getConnectorSpecificSettings(model);
|
|
var schemaName = (dbMeta && (dbMeta.schema || dbMeta.schemaName)) ||
|
|
(this.settings.schema || this.settings.schemaName) ||
|
|
this.getDefaultSchemaName();
|
|
return schemaName;
|
|
};
|
|
|
|
/**
|
|
* Get the table name for the given model. The table name can be customized
|
|
* at model settings as `table` or `tableName`. For example,
|
|
*
|
|
* ```json
|
|
* "Customer": {
|
|
* "name": "Customer",
|
|
* "mysql": {
|
|
* "table": "CUSTOMER"
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* Returns the table name (String).
|
|
* @param {String} model The model name
|
|
*/
|
|
SQLConnector.prototype.table = function(model) {
|
|
var dbMeta = this.getConnectorSpecificSettings(model);
|
|
var tableName;
|
|
if (dbMeta) {
|
|
tableName = dbMeta.table || dbMeta.tableName;
|
|
if (tableName) {
|
|
// Explicit table name, return as-is
|
|
return tableName;
|
|
}
|
|
}
|
|
tableName = model;
|
|
if (typeof this.dbName === 'function') {
|
|
tableName = this.dbName(tableName);
|
|
}
|
|
return tableName;
|
|
};
|
|
|
|
/**
|
|
* Get the column name for the given model property. The column name can be
|
|
* customized at the model property definition level as `column` or
|
|
* `columnName`. For example,
|
|
*
|
|
* ```json
|
|
* "name": {
|
|
* "type": "string",
|
|
* "mysql": {
|
|
* "column": "NAME"
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* @param {String} model The model name
|
|
* @param {String} property The property name
|
|
* @returns {String} The column name
|
|
*/
|
|
SQLConnector.prototype.column = function(model, property) {
|
|
var prop = this.getPropertyDefinition(model, property);
|
|
var columnName;
|
|
if (prop && prop[this.name]) {
|
|
columnName = prop[this.name].column || prop[this.name].columnName;
|
|
if (columnName) {
|
|
// Explicit column name, return as-is
|
|
return columnName;
|
|
}
|
|
}
|
|
columnName = property;
|
|
if (typeof this.dbName === 'function') {
|
|
columnName = this.dbName(columnName);
|
|
}
|
|
return columnName;
|
|
};
|
|
|
|
/**
|
|
* Get the column metadata for the given model property
|
|
* @param {String} model The model name
|
|
* @param {String} property The property name
|
|
* @returns {Object} The column metadata
|
|
*/
|
|
SQLConnector.prototype.columnMetadata = function(model, property) {
|
|
return this.getDataSource(model).columnMetadata(model, property);
|
|
};
|
|
|
|
/**
|
|
* Get the corresponding property name for the given column name
|
|
* @param {String} model The model name
|
|
* @param {String} column The column name
|
|
* @returns {String} The property name for a given column
|
|
*/
|
|
SQLConnector.prototype.propertyName = function(model, column) {
|
|
var props = this.getModelDefinition(model).properties;
|
|
for (var p in props) {
|
|
if (this.column(model, p) === column) {
|
|
return p;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Get the id column name
|
|
* @param {String} model The model name
|
|
* @returns {String} The id column name
|
|
*/
|
|
SQLConnector.prototype.idColumn = function(model) {
|
|
var name = this.getDataSource(model).idColumnName(model);
|
|
var dbName = this.dbName;
|
|
if (typeof dbName === 'function') {
|
|
name = dbName(name);
|
|
}
|
|
return name;
|
|
};
|
|
|
|
/**
|
|
* Get the escaped id column name
|
|
* @param {String} model The model name
|
|
* @returns {String} the escaped id column name
|
|
*/
|
|
SQLConnector.prototype.idColumnEscaped = function(model) {
|
|
return this.escapeName(this.idColumn(model));
|
|
};
|
|
|
|
/**
|
|
* Get the escaped table name
|
|
* @param {String} model The model name
|
|
* @returns {String} the escaped table name
|
|
*/
|
|
SQLConnector.prototype.tableEscaped = function(model) {
|
|
return this.escapeName(this.table(model));
|
|
};
|
|
|
|
/**
|
|
* Get the escaped column name for a given model property
|
|
* @param {String} model The model name
|
|
* @param {String} property The property name
|
|
* @returns {String} The escaped column name
|
|
*/
|
|
SQLConnector.prototype.columnEscaped = function(model, property) {
|
|
return this.escapeName(this.column(model, property));
|
|
};
|
|
|
|
/*!
|
|
* Check if id value is set
|
|
* @param idValue
|
|
* @param cb
|
|
* @param returningNull
|
|
* @returns {boolean}
|
|
*/
|
|
function isIdValuePresent(idValue, cb, returningNull) {
|
|
try {
|
|
assert(idValue !== null && idValue !== undefined, 'id value is required');
|
|
return true;
|
|
} catch (err) {
|
|
process.nextTick(function() {
|
|
if (cb) cb(returningNull ? null : err);
|
|
});
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert the id value to the form required by database column
|
|
* @param {String} model The model name
|
|
* @param {*} idValue The id property value
|
|
* @returns {*} The escaped id column value
|
|
*/
|
|
SQLConnector.prototype.idColumnValue = function(model, idValue) {
|
|
var idProp = this.getDataSource(model).idProperty(model);
|
|
if (typeof this.toColumnValue === 'function') {
|
|
return this.toColumnValue(idProp, idValue);
|
|
} else {
|
|
return idValue;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Replace `?` with connector specific placeholders. For example,
|
|
*
|
|
* ```
|
|
* {sql: 'SELECT * FROM CUSTOMER WHERE NAME=?', params: ['John']}
|
|
* ==>
|
|
* {sql: 'SELECT * FROM CUSTOMER WHERE NAME=:1', params: ['John']}
|
|
* ```
|
|
* *LIMITATION*: We don't handle the ? inside escaped values, for example,
|
|
* `SELECT * FROM CUSTOMER WHERE NAME='J?hn'` will not be parameterized
|
|
* correctly.
|
|
*
|
|
* @param {ParameterizedSQL|Object} ps Parameterized SQL
|
|
* @returns {ParameterizedSQL} Parameterized SQL with the connector specific
|
|
* placeholders
|
|
*/
|
|
SQLConnector.prototype.parameterize = function(ps) {
|
|
ps = new ParameterizedSQL(ps);
|
|
|
|
// The value is parameterized, for example
|
|
// {sql: 'to_point(?,?)', values: [1, 2]}
|
|
var parts = ps.sql.split(PLACEHOLDER);
|
|
var clause = [];
|
|
for (var j = 0, m = parts.length; j < m; j++) {
|
|
// Replace ? with the keyed placeholder, such as :5
|
|
clause.push(parts[j]);
|
|
if (j !== parts.length - 1) {
|
|
clause.push(this.getPlaceholderForValue(j + 1));
|
|
}
|
|
}
|
|
ps.sql = clause.join('');
|
|
return ps;
|
|
};
|
|
|
|
/**
|
|
* Build the the `INSERT INTO` statement
|
|
* @param {String} model The model name
|
|
* @param {Object} fields Fields to be inserted
|
|
* @param {Object} options Options object
|
|
* @returns {ParameterizedSQL}
|
|
*/
|
|
SQLConnector.prototype.buildInsertInto = function(model, fields, options) {
|
|
var stmt = new ParameterizedSQL('INSERT INTO ' + this.tableEscaped(model));
|
|
var columnNames = fields.names.join(',');
|
|
if (columnNames) {
|
|
stmt.merge('(' + columnNames + ')', '');
|
|
}
|
|
return stmt;
|
|
};
|
|
|
|
/**
|
|
* Build the clause to return id values after insert
|
|
* @param {String} model The model name
|
|
* @param {Object} data The model data object
|
|
* @param {Object} options Options object
|
|
* @returns {string}
|
|
*/
|
|
SQLConnector.prototype.buildInsertReturning = function(model, data, options) {
|
|
return '';
|
|
};
|
|
|
|
/**
|
|
* Build the clause for default values if the fields is empty
|
|
* @param {String} model The model name
|
|
* @param {Object} data The model data object
|
|
* @param {Object} options Options object
|
|
* @returns {string} 'DEFAULT VALUES'
|
|
*/
|
|
SQLConnector.prototype.buildInsertDefaultValues = function(model, data, options) {
|
|
return 'VALUES()';
|
|
};
|
|
|
|
/**
|
|
* Build INSERT SQL statement
|
|
* @param {String} model The model name
|
|
* @param {Object} data The model data object
|
|
* @param {Object} options The options object
|
|
* @returns {string} The INSERT SQL statement
|
|
*/
|
|
SQLConnector.prototype.buildInsert = function(model, data, options) {
|
|
var fields = this.buildFields(model, data);
|
|
var insertStmt = this.buildInsertInto(model, fields, options);
|
|
var columnValues = fields.columnValues;
|
|
var fieldNames = fields.names;
|
|
if (fieldNames.length) {
|
|
var values = ParameterizedSQL.join(columnValues, ',');
|
|
values.sql = 'VALUES(' + values.sql + ')';
|
|
insertStmt.merge(values);
|
|
} else {
|
|
insertStmt.merge(this.buildInsertDefaultValues(model, data, options));
|
|
}
|
|
var returning = this.buildInsertReturning(model, data, options);
|
|
if (returning) {
|
|
insertStmt.merge(returning);
|
|
}
|
|
return this.parameterize(insertStmt);
|
|
};
|
|
|
|
/**
|
|
* Execute a SQL statement with given parameters.
|
|
*
|
|
* @param {String} sql The SQL statement
|
|
* @param {*[]} [params] An array of parameter values
|
|
* @param {Object} [options] Options object
|
|
* @param {Function} [callback] The callback function
|
|
*/
|
|
SQLConnector.prototype.execute = function(sql, params, options, callback) {
|
|
assert(typeof sql === 'string', 'sql must be a string');
|
|
if (typeof params === 'function' && options === undefined &&
|
|
callback === undefined) {
|
|
// execute(sql, callback)
|
|
options = {};
|
|
callback = params;
|
|
params = [];
|
|
} else if (typeof options === 'function' && callback === undefined) {
|
|
// execute(sql, params, callback)
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
params = params || [];
|
|
options = options || {};
|
|
assert(Array.isArray(params), 'params must be an array');
|
|
assert(typeof options === 'object', 'options must be an object');
|
|
assert(typeof callback === 'function', 'callback must be a function');
|
|
|
|
var self = this;
|
|
if (!this.dataSource.connected) {
|
|
return this.dataSource.once('connected', function() {
|
|
self.execute(sql, params, options, callback);
|
|
});
|
|
}
|
|
var context = {
|
|
req: {
|
|
sql: sql,
|
|
params: params,
|
|
},
|
|
options: options,
|
|
};
|
|
this.notifyObserversAround('execute', context, function(context, done) {
|
|
self.executeSQL(context.req.sql, context.req.params, context.options,
|
|
function(err, info) {
|
|
if (err) {
|
|
debug('Error: %j %j %j', err, context.req.sql, context.req.params);
|
|
}
|
|
|
|
if (!err && info != null) {
|
|
context.res = info;
|
|
}
|
|
// Don't pass more than one args as it will confuse async.waterfall
|
|
done(err, info);
|
|
});
|
|
}, callback);
|
|
};
|
|
|
|
/**
|
|
* Create the data model in MySQL
|
|
*
|
|
* @param {String} model The model name
|
|
* @param {Object} data The model instance data
|
|
* @param {Object} options Options object
|
|
* @param {Function} [callback] The callback function
|
|
*/
|
|
SQLConnector.prototype.create = function(model, data, options, callback) {
|
|
var self = this;
|
|
var stmt = this.buildInsert(model, data, options);
|
|
this.execute(stmt.sql, stmt.params, options, function(err, info) {
|
|
if (err) {
|
|
callback(err);
|
|
} else {
|
|
var insertedId = self.getInsertedId(model, info);
|
|
callback(err, insertedId);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Save the model instance into the database
|
|
* @param {String} model The model name
|
|
* @param {Object} data The model instance data
|
|
* @param {Object} options Options object
|
|
* @param {Function} cb The callback function
|
|
*/
|
|
SQLConnector.prototype.save = function(model, data, options, cb) {
|
|
var idName = this.idName(model);
|
|
var idValue = data[idName];
|
|
|
|
if (!isIdValuePresent(idValue, cb)) {
|
|
return;
|
|
}
|
|
|
|
var where = {};
|
|
where[idName] = idValue;
|
|
|
|
var updateStmt = new ParameterizedSQL('UPDATE ' + this.tableEscaped(model));
|
|
updateStmt.merge(this.buildFieldsForUpdate(model, data));
|
|
var whereStmt = this.buildWhere(model, where);
|
|
updateStmt.merge(whereStmt);
|
|
updateStmt = this.parameterize(updateStmt);
|
|
this.execute(updateStmt.sql, updateStmt.params, options,
|
|
function(err, result) {
|
|
if (cb) cb(err, result);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Check if a model instance exists for the given id value
|
|
* @param {String} model The model name
|
|
* @param {*} id The id value
|
|
* @param {Object} options Options object
|
|
* @param {Function} cb The callback function
|
|
*/
|
|
SQLConnector.prototype.exists = function(model, id, options, cb) {
|
|
if (!isIdValuePresent(id, cb, true)) {
|
|
return;
|
|
}
|
|
var idName = this.idName(model);
|
|
var where = {};
|
|
where[idName] = id;
|
|
var selectStmt = new ParameterizedSQL(
|
|
'SELECT 1 FROM ' + this.tableEscaped(model) +
|
|
' WHERE ' + this.idColumnEscaped(model)
|
|
);
|
|
selectStmt.merge(this.buildWhere(model, where));
|
|
selectStmt = this.applyPagination(model, selectStmt, {
|
|
limit: 1,
|
|
offset: 0,
|
|
order: [idName],
|
|
});
|
|
selectStmt = this.parameterize(selectStmt);
|
|
|
|
this.execute(selectStmt.sql, selectStmt.params, options, function(err, data) {
|
|
if (!cb) return;
|
|
if (err) {
|
|
cb(err);
|
|
} else {
|
|
cb(null, data.length >= 1);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* ATM, this method is not used by loopback-datasource-juggler dao, which
|
|
* maps `destroy` to `destroyAll` with a `where` filter that includes the `id`
|
|
* instead.
|
|
*
|
|
* Delete a model instance by id value
|
|
* @param {String} model The model name
|
|
* @param {*} id The id value
|
|
* @param {Object} options Options object
|
|
* @param {Function} cb The callback function
|
|
* @private
|
|
*/
|
|
SQLConnector.prototype.destroy = function(model, id, options, cb) {
|
|
if (!isIdValuePresent(id, cb, true)) {
|
|
return;
|
|
}
|
|
var idName = this.idName(model);
|
|
var where = {};
|
|
where[idName] = id;
|
|
this.destroyAll(model, where, options, cb);
|
|
};
|
|
|
|
// Alias to `destroy`. Juggler checks `destroy` only.
|
|
Connector.defineAliases(SQLConnector.prototype, 'destroy',
|
|
['delete', 'deleteById', 'destroyById']);
|
|
|
|
/**
|
|
* Build the `DELETE FROM` SQL statement
|
|
* @param {String} model The model name
|
|
* @param {Object} where The where object
|
|
* @param {Object} options Options object
|
|
* @returns {ParameterizedSQL} The SQL DELETE FROM statement
|
|
*/
|
|
SQLConnector.prototype.buildDelete = function(model, where, options) {
|
|
var deleteStmt = new ParameterizedSQL('DELETE FROM ' +
|
|
this.tableEscaped(model));
|
|
deleteStmt.merge(this.buildWhere(model, where));
|
|
return this.parameterize(deleteStmt);
|
|
};
|
|
|
|
/**
|
|
* Delete all matching model instances
|
|
*
|
|
* @param {String} model The model name
|
|
* @param {Object} where The where object
|
|
* @param {Object} options The options object
|
|
* @param {Function} cb The callback function
|
|
*/
|
|
SQLConnector.prototype.destroyAll = function(model, where, options, cb) {
|
|
var stmt = this.buildDelete(model, where, options);
|
|
this._executeAlteringQuery(model, stmt.sql, stmt.params, options, cb || NOOP);
|
|
};
|
|
|
|
// Alias to `destroyAll`. Juggler checks `destroyAll` only.
|
|
Connector.defineAliases(SQLConnector.prototype, 'destroyAll', ['deleteAll']);
|
|
|
|
/**
|
|
* ATM, this method is not used by loopback-datasource-juggler dao, which
|
|
* maps `updateAttributes` to `update` with a `where` filter that includes the
|
|
* `id` instead.
|
|
*
|
|
* Update attributes for a given model instance
|
|
* @param {String} model The model name
|
|
* @param {*} id The id value
|
|
* @param {Object} data The model data instance containing all properties to
|
|
* be updated
|
|
* @param {Object} options Options object
|
|
* @param {Function} cb The callback function
|
|
* @private
|
|
*/
|
|
SQLConnector.prototype.updateAttributes = function(model, id, data, options, cb) {
|
|
if (!isIdValuePresent(id, cb)) return;
|
|
var where = this._buildWhereObjById(model, id, data);
|
|
this.updateAll(model, where, data, options, cb);
|
|
};
|
|
|
|
/**
|
|
* Replace attributes for a given model instance
|
|
* @param {String} model The model name
|
|
* @param {*} id The id value
|
|
* @param {Object} data The model data instance containing all properties to
|
|
* be replaced
|
|
* @param {Object} options Options object
|
|
* @param {Function} cb The callback function
|
|
* @private
|
|
*/
|
|
SQLConnector.prototype.replaceById = function(model, id, data, options, cb) {
|
|
if (!isIdValuePresent(id, cb)) return;
|
|
var where = this._buildWhereObjById(model, id, data);
|
|
this._replace(model, where, data, options, cb);
|
|
};
|
|
|
|
/*
|
|
* @param model The model name.
|
|
* @param id The instance ID.
|
|
* @param {Object} data The data Object.
|
|
* @returns {Object} where The where object for a spcific instance.
|
|
* @private
|
|
*/
|
|
SQLConnector.prototype._buildWhereObjById = function(model, id, data) {
|
|
var idName = this.idName(model);
|
|
delete data[idName];
|
|
var where = {};
|
|
where[idName] = id;
|
|
return where;
|
|
};
|
|
|
|
/**
|
|
* Build the UPDATE statement
|
|
* @param {String} model The model name
|
|
* @param {Object} where The where object
|
|
* @param {Object} data The data to be changed
|
|
* @param {Object} options The options object
|
|
* @param {Function} cb The callback function
|
|
* @returns {ParameterizedSQL} The UPDATE SQL statement
|
|
*/
|
|
SQLConnector.prototype.buildUpdate = function(model, where, data, options) {
|
|
var fields = this.buildFieldsForUpdate(model, data);
|
|
return this._constructUpdateQuery(model, where, fields);
|
|
};
|
|
|
|
/**
|
|
* Build the UPDATE statement for replacing
|
|
* @param {String} model The model name
|
|
* @param {Object} where The where object
|
|
* @param {Object} data The data to be changed
|
|
* @param {Object} options The options object
|
|
* @param {Function} cb The callback function
|
|
* @returns {ParameterizedSQL} The UPDATE SQL statement for replacing fields
|
|
*/
|
|
SQLConnector.prototype.buildReplace = function(model, where, data, options) {
|
|
var fields = this.buildFieldsForReplace(model, data);
|
|
return this._constructUpdateQuery(model, where, fields);
|
|
};
|
|
|
|
/*
|
|
* @param model The model name.
|
|
* @param {} where The where object.
|
|
* @param {Object} field The parameterizedSQL fileds.
|
|
* @returns {Object} update query Constructed update query.
|
|
* @private
|
|
*/
|
|
SQLConnector.prototype._constructUpdateQuery = function(model, where, fields) {
|
|
var updateClause = new ParameterizedSQL('UPDATE ' + this.tableEscaped(model));
|
|
var whereClause = this.buildWhere(model, where);
|
|
updateClause.merge([fields, whereClause]);
|
|
return this.parameterize(updateClause);
|
|
};
|
|
|
|
/**
|
|
* Update all instances that match the where clause with the given data
|
|
* @param {String} model The model name
|
|
* @param {Object} where The where object
|
|
* @param {Object} data The property/value object representing changes
|
|
* to be made
|
|
* @param {Object} options The options object
|
|
* @param {Function} cb The callback function
|
|
*/
|
|
SQLConnector.prototype.update = function(model, where, data, options, cb) {
|
|
var stmt = this.buildUpdate(model, where, data, options);
|
|
this._executeAlteringQuery(model, stmt.sql, stmt.params, options, cb || NOOP);
|
|
};
|
|
|
|
/**
|
|
* Replace all instances that match the where clause with the given data
|
|
* @param {String} model The model name
|
|
* @param {Object} where The where object
|
|
* @param {Object} data The property/value object representing changes
|
|
* to be made
|
|
* @param {Object} options The options object
|
|
* @param {Function} cb The callback function
|
|
*/
|
|
SQLConnector.prototype._replace = function(model, where, data, options, cb) {
|
|
var stmt = this.buildReplace(model, where, data, options);
|
|
this.execute(stmt.sql, stmt.params, options, cb);
|
|
};
|
|
|
|
SQLConnector.prototype._executeAlteringQuery = function(model, sql, params, options, cb) {
|
|
var self = this;
|
|
this.execute(sql, params, options, function(err, info) {
|
|
var affectedRows = self.getCountForAffectedRows(model, info);
|
|
cb(err, { count: affectedRows });
|
|
});
|
|
};
|
|
|
|
// Alias to `update` and `replace`. Juggler checks `update` and `replace` only.
|
|
Connector.defineAliases(SQLConnector.prototype, 'update', ['updateAll']);
|
|
Connector.defineAliases(SQLConnector.prototype, 'replace', ['replaceAll']);
|
|
|
|
/**
|
|
* Build the SQL WHERE clause for the where object
|
|
* @param {string} model Model name
|
|
* @param {object} where An object for the where conditions
|
|
* @returns {ParameterizedSQL} The SQL WHERE clause
|
|
*/
|
|
SQLConnector.prototype.buildWhere = function(model, where) {
|
|
var whereClause = this._buildWhere(model, where);
|
|
if (whereClause.sql) {
|
|
whereClause.sql = 'WHERE ' + whereClause.sql;
|
|
}
|
|
return whereClause;
|
|
};
|
|
|
|
/**
|
|
* Build SQL expression
|
|
* @param {String} columnName Escaped column name
|
|
* @param {String} operator SQL operator
|
|
* @param {*} columnValue Column value
|
|
* @param {*} propertyValue Property value
|
|
* @returns {ParameterizedSQL} The SQL expression
|
|
*/
|
|
SQLConnector.prototype.buildExpression =
|
|
function(columnName, operator, columnValue, propertyValue) {
|
|
function buildClause(columnValue, separator, grouping) {
|
|
var values = [];
|
|
for (var i = 0, n = columnValue.length; i < n; i++) {
|
|
if (columnValue[i] instanceof ParameterizedSQL) {
|
|
values.push(columnValue[i]);
|
|
} else {
|
|
values.push(new ParameterizedSQL(PLACEHOLDER, [columnValue[i]]));
|
|
}
|
|
}
|
|
separator = separator || ',';
|
|
var clause = ParameterizedSQL.join(values, separator);
|
|
if (grouping) {
|
|
clause.sql = '(' + clause.sql + ')';
|
|
}
|
|
return clause;
|
|
}
|
|
|
|
var sqlExp = columnName;
|
|
var clause;
|
|
if (columnValue instanceof ParameterizedSQL) {
|
|
clause = columnValue;
|
|
} else {
|
|
clause = new ParameterizedSQL(PLACEHOLDER, [columnValue]);
|
|
}
|
|
switch (operator) {
|
|
case 'gt':
|
|
sqlExp += '>';
|
|
break;
|
|
case 'gte':
|
|
sqlExp += '>=';
|
|
break;
|
|
case 'lt':
|
|
sqlExp += '<';
|
|
break;
|
|
case 'lte':
|
|
sqlExp += '<=';
|
|
break;
|
|
case 'between':
|
|
sqlExp += ' BETWEEN ';
|
|
clause = buildClause(columnValue, ' AND ', false);
|
|
break;
|
|
case 'inq':
|
|
sqlExp += ' IN ';
|
|
clause = buildClause(columnValue, ',', true);
|
|
break;
|
|
case 'nin':
|
|
sqlExp += ' NOT IN ';
|
|
clause = buildClause(columnValue, ',', true);
|
|
break;
|
|
case 'neq':
|
|
if (columnValue == null) {
|
|
return new ParameterizedSQL(sqlExp + ' IS NOT NULL');
|
|
}
|
|
sqlExp += '!=';
|
|
break;
|
|
case 'like':
|
|
sqlExp += ' LIKE ';
|
|
break;
|
|
case 'nlike':
|
|
sqlExp += ' NOT LIKE ';
|
|
break;
|
|
// this case not needed since each database has its own regex syntax, but
|
|
// we leave the MySQL syntax here as a placeholder
|
|
case 'regexp':
|
|
sqlExp += ' REGEXP ';
|
|
break;
|
|
}
|
|
var stmt = ParameterizedSQL.join([sqlExp, clause], '');
|
|
return stmt;
|
|
};
|
|
|
|
/*!
|
|
* @param model
|
|
* @param where
|
|
* @returns {ParameterizedSQL}
|
|
* @private
|
|
*/
|
|
SQLConnector.prototype._buildWhere = function(model, where) {
|
|
if (!where) {
|
|
return new ParameterizedSQL('');
|
|
}
|
|
if (typeof where !== 'object' || Array.isArray(where)) {
|
|
debug('Invalid value for where: %j', where);
|
|
return new ParameterizedSQL('');
|
|
}
|
|
var self = this;
|
|
var props = self.getModelDefinition(model).properties;
|
|
|
|
var whereStmts = [];
|
|
for (var key in where) {
|
|
var stmt = new ParameterizedSQL('', []);
|
|
// Handle and/or operators
|
|
if (key === 'and' || key === 'or') {
|
|
var branches = [];
|
|
var branchParams = [];
|
|
var clauses = where[key];
|
|
if (Array.isArray(clauses)) {
|
|
for (var i = 0, n = clauses.length; i < n; i++) {
|
|
var stmtForClause = self._buildWhere(model, clauses[i]);
|
|
if (stmtForClause.sql) {
|
|
stmtForClause.sql = '(' + stmtForClause.sql + ')';
|
|
branchParams = branchParams.concat(stmtForClause.params);
|
|
branches.push(stmtForClause.sql);
|
|
}
|
|
}
|
|
stmt.merge({
|
|
sql: branches.join(' ' + key.toUpperCase() + ' '),
|
|
params: branchParams,
|
|
});
|
|
whereStmts.push(stmt);
|
|
continue;
|
|
}
|
|
// The value is not an array, fall back to regular fields
|
|
}
|
|
var p = props[key];
|
|
if (p == null) {
|
|
// Unknown property, ignore it
|
|
debug('Unknown property %s is skipped for model %s', key, model);
|
|
continue;
|
|
}
|
|
/* eslint-disable one-var */
|
|
var columnName = self.columnEscaped(model, key);
|
|
var expression = where[key];
|
|
var columnValue;
|
|
var sqlExp;
|
|
/* eslint-enable one-var */
|
|
if (expression === null || expression === undefined) {
|
|
stmt.merge(columnName + ' IS NULL');
|
|
} else if (expression && expression.constructor === Object) {
|
|
var operator = Object.keys(expression)[0];
|
|
// Get the expression without the operator
|
|
expression = expression[operator];
|
|
if (operator === 'inq' || operator === 'nin' || operator === 'between') {
|
|
columnValue = [];
|
|
if (Array.isArray(expression)) {
|
|
// Column value is a list
|
|
for (var j = 0, m = expression.length; j < m; j++) {
|
|
columnValue.push(this.toColumnValue(p, expression[j]));
|
|
}
|
|
} else {
|
|
columnValue.push(this.toColumnValue(p, expression));
|
|
}
|
|
if (operator === 'between') {
|
|
// BETWEEN v1 AND v2
|
|
var v1 = columnValue[0] === undefined ? null : columnValue[0];
|
|
var v2 = columnValue[1] === undefined ? null : columnValue[1];
|
|
columnValue = [v1, v2];
|
|
} else {
|
|
// IN (v1,v2,v3) or NOT IN (v1,v2,v3)
|
|
if (columnValue.length === 0) {
|
|
if (operator === 'inq') {
|
|
columnValue = [null];
|
|
} else {
|
|
// nin () is true
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
} else if (operator === 'regexp' && expression instanceof RegExp) {
|
|
// do not coerce RegExp based on property definitions
|
|
columnValue = expression;
|
|
} else {
|
|
columnValue = this.toColumnValue(p, expression);
|
|
}
|
|
sqlExp = self.buildExpression(
|
|
columnName, operator, columnValue, p);
|
|
stmt.merge(sqlExp);
|
|
} else {
|
|
// The expression is the field value, not a condition
|
|
columnValue = self.toColumnValue(p, expression);
|
|
if (columnValue === null) {
|
|
stmt.merge(columnName + ' IS NULL');
|
|
} else {
|
|
if (columnValue instanceof ParameterizedSQL) {
|
|
stmt.merge(columnName + '=').merge(columnValue);
|
|
} else {
|
|
stmt.merge({
|
|
sql: columnName + '=?',
|
|
params: [columnValue],
|
|
});
|
|
}
|
|
}
|
|
}
|
|
whereStmts.push(stmt);
|
|
}
|
|
var params = [];
|
|
var sqls = [];
|
|
for (var k = 0, s = whereStmts.length; k < s; k++) {
|
|
sqls.push(whereStmts[k].sql);
|
|
params = params.concat(whereStmts[k].params);
|
|
}
|
|
var whereStmt = new ParameterizedSQL({
|
|
sql: sqls.join(' AND '),
|
|
params: params,
|
|
});
|
|
return whereStmt;
|
|
};
|
|
|
|
/**
|
|
* Build the ORDER BY clause
|
|
* @param {string} model Model name
|
|
* @param {string[]} order An array of sorting criteria
|
|
* @returns {string} The ORDER BY clause
|
|
*/
|
|
SQLConnector.prototype.buildOrderBy = function(model, order) {
|
|
if (!order) {
|
|
return '';
|
|
}
|
|
var self = this;
|
|
if (typeof order === 'string') {
|
|
order = [order];
|
|
}
|
|
var clauses = [];
|
|
for (var i = 0, n = order.length; i < n; i++) {
|
|
var t = order[i].split(/[\s,]+/);
|
|
if (t.length === 1) {
|
|
clauses.push(self.columnEscaped(model, order[i]));
|
|
} else {
|
|
clauses.push(self.columnEscaped(model, t[0]) + ' ' + t[1]);
|
|
}
|
|
}
|
|
return 'ORDER BY ' + clauses.join(',');
|
|
};
|
|
|
|
/**
|
|
* Build an array of fields for the database operation
|
|
* @param {String} model Model name
|
|
* @param {Object} data Model data object
|
|
* @param {Boolean} excludeIds Exclude id properties or not, default to false
|
|
* @returns {{names: Array, values: Array, properties: Array}}
|
|
*/
|
|
SQLConnector.prototype.buildFields = function(model, data, excludeIds) {
|
|
var keys = Object.keys(data);
|
|
return this._buildFieldsForKeys(model, data, keys, excludeIds);
|
|
};
|
|
|
|
/**
|
|
* Build an array of fields for the replace database operation
|
|
* @param {String} model Model name
|
|
* @param {Object} data Model data object
|
|
* @param {Boolean} excludeIds Exclude id properties or not, default to false
|
|
* @returns {{names: Array, values: Array, properties: Array}}
|
|
*/
|
|
SQLConnector.prototype.buildReplaceFields = function(model, data, excludeIds) {
|
|
var props = this.getModelDefinition(model).properties;
|
|
var keys = Object.keys(props);
|
|
return this._buildFieldsForKeys(model, data, keys, excludeIds);
|
|
};
|
|
|
|
/*
|
|
* @param {String} model The model name.
|
|
* @returns {Object} data The model data object.
|
|
* @returns {Array} keys The key fields for which need to be built.
|
|
* @param {Boolean} excludeIds Exclude id properties or not, default to false
|
|
* @private
|
|
*/
|
|
SQLConnector.prototype._buildFieldsForKeys = function(model, data, keys, excludeIds) {
|
|
var props = this.getModelDefinition(model).properties;
|
|
var fields = {
|
|
names: [], // field names
|
|
columnValues: [], // an array of ParameterizedSQL
|
|
properties: [], // model properties
|
|
};
|
|
for (var i = 0, n = keys.length; i < n; i++) {
|
|
var key = keys[i];
|
|
var p = props[key];
|
|
if (p == null) {
|
|
// Unknown property, ignore it
|
|
debug('Unknown property %s is skipped for model %s', key, model);
|
|
continue;
|
|
}
|
|
|
|
if (excludeIds && p.id) {
|
|
continue;
|
|
}
|
|
var k = this.columnEscaped(model, key);
|
|
var v = this.toColumnValue(p, data[key]);
|
|
if (v !== undefined) {
|
|
fields.names.push(k);
|
|
if (v instanceof ParameterizedSQL) {
|
|
fields.columnValues.push(v);
|
|
} else {
|
|
fields.columnValues.push(new ParameterizedSQL(PLACEHOLDER, [v]));
|
|
}
|
|
fields.properties.push(p);
|
|
}
|
|
}
|
|
return fields;
|
|
};
|
|
|
|
/**
|
|
* Build the SET clause for database update.
|
|
* @param {String} model Model name.
|
|
* @param {Object} data The model data object.
|
|
* @param {Boolean} excludeIds Exclude id properties or not, default to true.
|
|
* @returns {string} The list of fields for update query.
|
|
*/
|
|
SQLConnector.prototype.buildFieldsForUpdate = function(model, data, excludeIds) {
|
|
if (excludeIds === undefined) {
|
|
excludeIds = true;
|
|
}
|
|
var fields = this.buildFields(model, data, excludeIds);
|
|
return this._constructUpdateParameterizedSQL(fields);
|
|
};
|
|
|
|
/**
|
|
* Build the SET clause for database replace through update query.
|
|
* @param {String} model Model name.
|
|
* @param {Object} data The model data object.
|
|
* @param {Boolean} excludeIds Exclude id properties or not, default to true.
|
|
* @returns {string} The list of fields for update query.
|
|
*/
|
|
SQLConnector.prototype.buildFieldsForReplace = function(model, data, excludeIds) {
|
|
if (excludeIds === undefined) {
|
|
excludeIds = true;
|
|
}
|
|
var fields = this.buildReplaceFields(model, data, excludeIds);
|
|
return this._constructUpdateParameterizedSQL(fields);
|
|
};
|
|
|
|
/*
|
|
* @param {Object} field The fileds.
|
|
* @returns {Object} parameterizedSQL.
|
|
* @private
|
|
*/
|
|
SQLConnector.prototype._constructUpdateParameterizedSQL = function(fields) {
|
|
var columns = new ParameterizedSQL('');
|
|
for (var i = 0, n = fields.names.length; i < n; i++) {
|
|
var clause = ParameterizedSQL.append(fields.names[i],
|
|
fields.columnValues[i], '=');
|
|
columns.merge(clause, ',');
|
|
}
|
|
columns.sql = 'SET ' + columns.sql;
|
|
return columns;
|
|
};
|
|
|
|
/**
|
|
* Build a list of escaped column names for the given model and fields filter
|
|
* @param {string} model Model name
|
|
* @param {object} filter The filter object
|
|
* @returns {string} Comma separated string of escaped column names
|
|
*/
|
|
SQLConnector.prototype.buildColumnNames = function(model, filter) {
|
|
var fieldsFilter = filter && filter.fields;
|
|
var cols = this.getModelDefinition(model).properties;
|
|
if (!cols) {
|
|
return '*';
|
|
}
|
|
var self = this;
|
|
var keys = Object.keys(cols);
|
|
if (Array.isArray(fieldsFilter) && fieldsFilter.length > 0) {
|
|
// Not empty array, including all the fields that are valid properties
|
|
keys = fieldsFilter.filter(function(f) {
|
|
return cols[f];
|
|
});
|
|
} else if ('object' === typeof fieldsFilter &&
|
|
Object.keys(fieldsFilter).length > 0) {
|
|
// { field1: boolean, field2: boolean ... }
|
|
var included = [];
|
|
var excluded = [];
|
|
keys.forEach(function(k) {
|
|
if (fieldsFilter[k]) {
|
|
included.push(k);
|
|
} else if ((k in fieldsFilter) && !fieldsFilter[k]) {
|
|
excluded.push(k);
|
|
}
|
|
});
|
|
if (included.length > 0) {
|
|
keys = included;
|
|
} else if (excluded.length > 0) {
|
|
excluded.forEach(function(e) {
|
|
var index = keys.indexOf(e);
|
|
keys.splice(index, 1);
|
|
});
|
|
}
|
|
}
|
|
var names = keys.map(function(c) {
|
|
return self.columnEscaped(model, c);
|
|
});
|
|
return names.join(',');
|
|
};
|
|
|
|
/**
|
|
* Build a SQL SELECT statement
|
|
* @param {String} model Model name
|
|
* @param {Object} filter Filter object
|
|
* @param {Object} options Options object
|
|
* @returns {ParameterizedSQL} Statement object {sql: ..., params: [...]}
|
|
*/
|
|
SQLConnector.prototype.buildSelect = function(model, filter, options) {
|
|
if (!filter.order) {
|
|
var idNames = this.idNames(model);
|
|
if (idNames && idNames.length) {
|
|
filter.order = idNames;
|
|
}
|
|
}
|
|
|
|
var selectStmt = new ParameterizedSQL('SELECT ' +
|
|
this.buildColumnNames(model, filter) +
|
|
' FROM ' + this.tableEscaped(model)
|
|
);
|
|
|
|
if (filter) {
|
|
if (filter.where) {
|
|
var whereStmt = this.buildWhere(model, filter.where);
|
|
selectStmt.merge(whereStmt);
|
|
}
|
|
|
|
if (filter.order) {
|
|
selectStmt.merge(this.buildOrderBy(model, filter.order));
|
|
}
|
|
|
|
if (filter.limit || filter.skip || filter.offset) {
|
|
selectStmt = this.applyPagination(
|
|
model, selectStmt, filter);
|
|
}
|
|
}
|
|
return this.parameterize(selectStmt);
|
|
};
|
|
|
|
/**
|
|
* Transform the row data into a model data object
|
|
* @param {string} model Model name
|
|
* @param {object} rowData An object representing the row data from DB
|
|
* @returns {object} Model data object
|
|
*/
|
|
SQLConnector.prototype.fromRow = SQLConnector.prototype.fromDatabase =
|
|
function(model, rowData) {
|
|
if (rowData == null) {
|
|
return rowData;
|
|
}
|
|
var props = this.getModelDefinition(model).properties;
|
|
var data = {};
|
|
for (var p in props) {
|
|
var columnName = this.column(model, p);
|
|
// Load properties from the row
|
|
var columnValue = this.fromColumnValue(props[p], rowData[columnName]);
|
|
if (columnValue !== undefined) {
|
|
data[p] = columnValue;
|
|
}
|
|
}
|
|
return data;
|
|
};
|
|
|
|
/**
|
|
* Find matching model instances by the filter
|
|
*
|
|
* Please also note the name `all` is confusing. `Model.find` is to find all
|
|
* matching instances while `Model.findById` is to find an instance by id. On
|
|
* the other hand, `Connector.prototype.all` implements `Model.find` while
|
|
* `Connector.prototype.find` implements `Model.findById` due to the `bad`
|
|
* naming convention we inherited from juggling-db.
|
|
*
|
|
* @param {String} model The model name
|
|
* @param {Object} filter The filter
|
|
* @param {Function} [cb] The cb function
|
|
*/
|
|
SQLConnector.prototype.all = function find(model, filter, options, cb) {
|
|
var self = this;
|
|
// Order by id if no order is specified
|
|
filter = filter || {};
|
|
var stmt = this.buildSelect(model, filter, options);
|
|
this.execute(stmt.sql, stmt.params, options, function(err, data) {
|
|
if (err) {
|
|
return cb(err, []);
|
|
}
|
|
|
|
var objs = data.map(function(obj) {
|
|
return self.fromRow(model, obj);
|
|
});
|
|
if (filter && filter.include) {
|
|
self.getModelDefinition(model).model.include(
|
|
objs, filter.include, options, cb);
|
|
} else {
|
|
cb(null, objs);
|
|
}
|
|
});
|
|
};
|
|
|
|
// Alias to `all`. Juggler checks `all` only.
|
|
Connector.defineAliases(SQLConnector.prototype, 'all', ['findAll']);
|
|
|
|
/**
|
|
* ATM, this method is not used by loopback-datasource-juggler dao, which
|
|
* maps `findById` to `find` with a `where` filter that includes the `id`
|
|
* instead.
|
|
*
|
|
* Please also note the name `find` is confusing. `Model.find` is to find all
|
|
* matching instances while `Model.findById` is to find an instance by id. On
|
|
* the other hand, `Connector.prototype.find` is for `findById` and
|
|
* `Connector.prototype.all` is for `find` due the `bad` convention used by
|
|
* juggling-db.
|
|
*
|
|
* Find by id
|
|
* @param {String} model The Model name
|
|
* @param {*} id The id value
|
|
* @param {Object} options The options object
|
|
* @param {Function} cb The callback function
|
|
* @private
|
|
*/
|
|
SQLConnector.prototype.find = function(model, id, options, cb) {
|
|
if (id == null) {
|
|
process.nextTick(function() {
|
|
var err = new Error(g.f('id value is required'));
|
|
if (cb) {
|
|
cb(err);
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
var where = {};
|
|
var idName = this.idName(model);
|
|
where[idName] = id;
|
|
|
|
var filter = { limit: 1, offset: 0, order: idName, where: where };
|
|
return this.all(model, filter, options, function(err, results) {
|
|
cb(err, (results && results[0]) || null);
|
|
});
|
|
};
|
|
// Alias to `find`. Juggler checks `findById` only.
|
|
Connector.defineAliases(SQLConnector.prototype, 'find', ['findById']);
|
|
|
|
/**
|
|
* Count all model instances by the where filter
|
|
*
|
|
* @param {String} model The model name
|
|
* @param {Object} where The where object
|
|
* @param {Object} options The options object
|
|
* @param {Function} cb The callback function
|
|
*/
|
|
SQLConnector.prototype.count = function(model, where, options, cb) {
|
|
if (typeof where === 'function') {
|
|
// Backward compatibility for 1.x style signature:
|
|
// count(model, cb, where)
|
|
var tmp = options;
|
|
cb = where;
|
|
where = tmp;
|
|
}
|
|
|
|
var stmt = new ParameterizedSQL('SELECT count(*) as "cnt" FROM ' +
|
|
this.tableEscaped(model));
|
|
stmt = stmt.merge(this.buildWhere(model, where));
|
|
stmt = this.parameterize(stmt);
|
|
this.execute(stmt.sql, stmt.params,
|
|
function(err, res) {
|
|
if (err) {
|
|
return cb(err);
|
|
}
|
|
var c = (res && res[0] && res[0].cnt) || 0;
|
|
// Some drivers return count as a string to contain bigint
|
|
// See https://github.com/brianc/node-postgres/pull/427
|
|
cb(err, Number(c));
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Drop the table for the given model from the database
|
|
* @param {String} model The model name
|
|
* @param {Function} [cb] The callback function
|
|
*/
|
|
SQLConnector.prototype.dropTable = function(model, cb) {
|
|
this.execute('DROP TABLE IF EXISTS ' + this.tableEscaped(model), cb);
|
|
};
|
|
|
|
/**
|
|
* Create the table for the given model
|
|
* @param {String} model The model name
|
|
* @param {Function} [cb] The callback function
|
|
*/
|
|
SQLConnector.prototype.createTable = function(model, cb) {
|
|
var sql = 'CREATE TABLE ' + this.tableEscaped(model) +
|
|
' (\n ' + this.buildColumnDefinitions(model) + '\n)';
|
|
this.execute(sql, cb);
|
|
};
|
|
|
|
/**
|
|
* Recreate the tables for the given models
|
|
* @param {[String]|String} [models] A model name or an array of model names,
|
|
* if not present, apply to all models defined in the connector
|
|
* @param {Function} [cb] The callback function
|
|
*/
|
|
SQLConnector.prototype.automigrate = function(models, cb) {
|
|
var self = this;
|
|
|
|
if ((!cb) && ('function' === typeof models)) {
|
|
cb = models;
|
|
models = undefined;
|
|
}
|
|
// First argument is a model name
|
|
if ('string' === typeof models) {
|
|
models = [models];
|
|
}
|
|
|
|
models = models || Object.keys(self._models);
|
|
if (models.length === 0) {
|
|
return process.nextTick(cb);
|
|
}
|
|
|
|
var invalidModels = models.filter(function(m) {
|
|
return !(m in self._models);
|
|
});
|
|
if (invalidModels.length) {
|
|
return process.nextTick(function() {
|
|
cb(new Error(g.f('Cannot migrate models not attached to this datasource: %s',
|
|
invalidModels.join(' '))));
|
|
});
|
|
}
|
|
|
|
async.each(models, function(model, done) {
|
|
self.dropTable(model, function(err) {
|
|
if (err) {
|
|
// TODO(bajtos) should we abort here and call cb(err)?
|
|
// The original code in juggler ignored the error completely
|
|
console.error(err);
|
|
}
|
|
self.createTable(model, function(err, result) {
|
|
if (err) {
|
|
console.error(err);
|
|
}
|
|
done(err, result);
|
|
});
|
|
});
|
|
}, cb);
|
|
};
|
|
|
|
/**
|
|
* Serialize an object into JSON string or other primitive types so that it
|
|
* can be saved into a RDB column
|
|
* @param {Object} obj The object value
|
|
* @returns {*}
|
|
*/
|
|
SQLConnector.prototype.serializeObject = function(obj) {
|
|
var val;
|
|
if (obj && typeof obj.toJSON === 'function') {
|
|
obj = obj.toJSON();
|
|
}
|
|
if (typeof obj !== 'string') {
|
|
val = JSON.stringify(obj);
|
|
} else {
|
|
val = obj;
|
|
}
|
|
return val;
|
|
};
|
|
|
|
/*!
|
|
* @param obj
|
|
*/
|
|
SQLConnector.prototype.escapeObject = function(obj) {
|
|
var val = this.serializeObject(obj);
|
|
return this.escapeValue(val);
|
|
};
|
|
|
|
/**
|
|
* The following _abstract_ methods have to be implemented by connectors that
|
|
* extend from SQLConnector to reuse the base implementations of CRUD methods
|
|
* from SQLConnector
|
|
*/
|
|
|
|
/**
|
|
* Converts a model property value into the form required by the
|
|
* database column. The result should be one of following forms:
|
|
*
|
|
* - {sql: "point(?,?)", params:[10,20]}
|
|
* - {sql: "'John'", params: []}
|
|
* - "John"
|
|
*
|
|
* @param {Object} propertyDef Model property definition
|
|
* @param {*} value Model property value
|
|
* @returns {ParameterizedSQL|*} Database column value.
|
|
*
|
|
*/
|
|
SQLConnector.prototype.toColumnValue = function(propertyDef, value) {
|
|
throw new Error(g.f('{{toColumnValue()}} must be implemented by the connector'));
|
|
};
|
|
|
|
/**
|
|
* Convert the data from database column to model property
|
|
* @param {object} propertyDef Model property definition
|
|
* @param {*) value Column value
|
|
* @returns {*} Model property value
|
|
*/
|
|
SQLConnector.prototype.fromColumnValue = function(propertyDef, value) {
|
|
throw new Error(g.f('{{fromColumnValue()}} must be implemented by the connector'));
|
|
};
|
|
|
|
/**
|
|
* Escape the name for the underlying database
|
|
* @param {String} name The name
|
|
* @returns {String} An escaped name for SQL
|
|
*/
|
|
SQLConnector.prototype.escapeName = function(name) {
|
|
throw new Error(g.f('{{escapeName()}} must be implemented by the connector'));
|
|
};
|
|
|
|
/**
|
|
* Escape the name for the underlying database
|
|
* @param {String} value The value to be escaped
|
|
* @returns {*} An escaped value for SQL
|
|
*/
|
|
SQLConnector.prototype.escapeValue = function(value) {
|
|
throw new Error(g.f('{{escapeValue()}} must be implemented by the connector'));
|
|
};
|
|
|
|
/**
|
|
* Get the place holder in SQL for identifiers, such as ??
|
|
* @param {String} key Optional key, such as 1 or id
|
|
* @returns {String} The place holder
|
|
*/
|
|
SQLConnector.prototype.getPlaceholderForIdentifier = function(key) {
|
|
throw new Error(g.f('{{getPlaceholderForIdentifier()}} must be implemented by ' +
|
|
'the connector'));
|
|
};
|
|
|
|
/**
|
|
* Get the place holder in SQL for values, such as :1 or ?
|
|
* @param {String} key Optional key, such as 1 or id
|
|
* @returns {String} The place holder
|
|
*/
|
|
SQLConnector.prototype.getPlaceholderForValue = function(key) {
|
|
throw new Error(g.f('{{getPlaceholderForValue()}} must be implemented by ' +
|
|
'the connector'));
|
|
};
|
|
|
|
/**
|
|
* Build a new SQL statement with pagination support by wrapping the given sql
|
|
* @param {String} model The model name
|
|
* @param {ParameterizedSQL} stmt The sql statement
|
|
* @param {Object} filter The filter object from the query
|
|
*/
|
|
SQLConnector.prototype.applyPagination = function(model, stmt, filter) {
|
|
throw new Error(g.f('{{applyPagination()}} must be implemented by the connector'));
|
|
};
|
|
|
|
/**
|
|
* Parse the result for SQL UPDATE/DELETE/INSERT for the number of rows
|
|
* affected
|
|
* @param {String} model Model name
|
|
* @param {Object} info Status object
|
|
* @returns {Number} Number of rows affected
|
|
*/
|
|
SQLConnector.prototype.getCountForAffectedRows = function(model, info) {
|
|
throw new Error(g.f('{{getCountForAffectedRows()}} must be implemented by ' +
|
|
'the connector'));
|
|
};
|
|
|
|
/**
|
|
* Parse the result for SQL INSERT for newly inserted id
|
|
* @param {String} model Model name
|
|
* @param {Object} info The status object from driver
|
|
* @returns {*} The inserted id value
|
|
*/
|
|
SQLConnector.prototype.getInsertedId = function(model, info) {
|
|
throw new Error(g.f('{{getInsertedId()}} must be implemented by the connector'));
|
|
};
|
|
|
|
/**
|
|
* Execute a SQL statement with given parameters
|
|
* @param {String} sql The SQL statement
|
|
* @param {*[]} [params] An array of parameter values
|
|
* @param {Object} [options] Options object
|
|
* @param {Function} [callback] The callback function
|
|
*/
|
|
SQLConnector.prototype.executeSQL = function(sql, params, options, callback) {
|
|
throw new Error(g.f('{{executeSQL()}} must be implemented by the connector'));
|
|
};
|