var safeRequire = require('../utils').safeRequire;/** * Module dependencies */var pg = safeRequire('pg');1var BaseSQL = require('../sql');1var util = require('util');1exports.initialize = function initializeSchema(schema, callback) { if (!pg) return;1 var Client = pg.Client;1 var s = schema.settings;1 schema.client = new Client(s.url ? s.url : { host: s.host || 'localhost', port: s.port || 5432, user: s.username, password: s.password, database: s.database, debug: s.debug });1 schema.adapter = new PG(schema.client);1 schema.adapter.connect(callback);1};1function PG(client) { this._models = {};1 this.client = client;1}require('util').inherits(PG, BaseSQL);1PG.prototype.connect = function (callback) { this.client.connect(function (err) { if (!err){ callback();1 }else{ console.error(err); throw err; } });1};1PG.prototype.query = function (sql, callback) { var time = Date.now();8 var log = this.log;8 this.client.query(sql, function (err, data) { if (log) log(sql, time);8 callback(err, data ? data.rows : null);8 });8};1/** * Must invoke callback(err, id) */PG.prototype.create = function (model, data, callback) { var fields = this.toFields(model, data, true);4 var sql = 'INSERT INTO ' + this.tableEscaped(model) + '';4 if (fields) { sql += ' ' + fields;4 } else { sql += ' VALUES ()'; } sql += ' RETURNING id';4 this.query(sql, function (err, info) { if (err) return callback(err);4 callback(err, info && info[0] && info[0].id);4 });4};1PG.prototype.updateOrCreate = function (model, data, callback) { var pg = this; var fieldsNames = []; var fieldValues = []; var combined = []; var props = this._models[model].properties; Object.keys(data).forEach(function (key) { if (props[key] || key === 'id') { var k = '"' + key + '"'; var v; if (key !== 'id') { v = pg.toDatabase(props[key], data[key]); } else { v = data[key]; } fieldsNames.push(k); fieldValues.push(v); if (key !== 'id') combined.push(k + ' = ' + v); } }); var sql = 'UPDATE ' + this.tableEscaped(model); sql += ' SET ' + combined + ' WHERE id = ' + data.id + ';'; sql += ' INSERT INTO ' + this.tableEscaped(model); sql += ' (' + fieldsNames.join(', ') + ')'; sql += ' SELECT ' + fieldValues.join(', ') sql += ' WHERE NOT EXISTS (SELECT 1 FROM ' + this.tableEscaped(model); sql += ' WHERE id = ' + data.id + ') RETURNING id'; this.query(sql, function (err, info) { if (!err && info && info[0] && info[0].id) { data.id = info[0].id; } callback(err, data); });};1PG.prototype.toFields = function (model, data, forCreate) { var fields = [];4 var props = this._models[model].properties;4 if(forCreate){ var columns = [];4 Object.keys(data).forEach(function (key) { if (props[key]) { columns.push('"' + key + '"');8 fields.push(this.toDatabase(props[key], data[key]));8 } }.bind(this));4 return '(' + columns.join(',') + ') VALUES ('+fields.join(',')+')';4 }else{ Object.keys(data).forEach(function (key) { if (props[key]) { fields.push('"' + key + '" = ' + this.toDatabase(props[key], data[key])); } }.bind(this)); return fields.join(','); }};1function dateToPostgres(val) { return [ val.getUTCFullYear(), fz(val.getUTCMonth() + 1), fz(val.getUTCDate()) ].join('-') + ' ' + [ fz(val.getUTCHours()), fz(val.getUTCMinutes()), fz(val.getUTCSeconds()) ].join(':'); function fz(v) { return v < 10 ? '0' + v : v; }}PG.prototype.toDatabase = function (prop, val) { if (val === null) { // Postgres complains with NULLs in not null columns // If we have an autoincrement value, return DEFAULT instead if( prop.autoIncrement ) { return 'DEFAULT'; } else { return 'NULL'; } } if (val.constructor.name === 'Object') { var operator = Object.keys(val)[0] val = val[operator]; if (operator === 'between') { return this.toDatabase(prop, val[0]) + ' AND ' + this.toDatabase(prop, val[1]); } } if (prop.type.name === 'Number') return val;4 if (prop.type.name === 'Date') { if (!val) { if( prop.autoIncrement ) { return 'DEFAULT'; } else { return 'NULL'; } } if (!val.toUTCString) { val = new Date(val); } return escape(dateToPostgres(val)); } return escape(val.toString());4};1PG.prototype.fromDatabase = function (model, data) { if (!data) return null; var props = this._models[model].properties; Object.keys(data).forEach(function (key) { var val = data[key]; data[key] = val; }); return data;};1PG.prototype.escapeName = function (name) { return '"' + name.replace(/\./g, '"."') + '"';6};1PG.prototype.all = function all(model, filter, callback) { this.query('SELECT * FROM ' + this.tableEscaped(model) + ' ' + this.toFilter(model, filter), function (err, data) { if (err) { return callback(err, []); } callback(err, data); }.bind(this));};1PG.prototype.toFilter = function (model, filter) { if (filter && typeof filter.where === 'function') { return filter(); } if (!filter) return ''; var props = this._models[model].properties; var out = ''; if (filter.where) { var fields = []; var conds = filter.where; Object.keys(conds).forEach(function (key) { if (filter.where[key] && filter.where[key].constructor.name === 'RegExp') { return; } if (props[key]) { var filterValue = this.toDatabase(props[key], filter.where[key]); if (filterValue === 'NULL') { fields.push('"' + key + '" IS ' + filterValue); } else if (conds[key].constructor.name === 'Object') { var condType = Object.keys(conds[key])[0]; var sqlCond = key; switch (condType) { case 'gt': sqlCond += ' > '; break; case 'gte': sqlCond += ' >= '; break; case 'lt': sqlCond += ' < '; break; case 'lte': sqlCond += ' <= '; break; case 'between': sqlCond += ' BETWEEN '; break; } sqlCond += filterValue; fields.push(sqlCond); } else { fields.push('"' + key + '" = ' + filterValue); } } }.bind(this)); if (fields.length) { out += ' WHERE ' + fields.join(' AND '); } } if (filter.order) { out += ' ORDER BY ' + filter.order; } if (filter.limit) { out += ' LIMIT ' + filter.limit + ' ' + (filter.offset || ''); } return out;};1function getTableStatus(model, cb){ function decoratedCallback(err, data){ data.forEach(function(field){ field.Type = mapPostgresDatatypes(field.Type); }); cb(err, data); }; this.query('SELECT column_name as "Field", udt_name as "Type", is_nullable as "Null", column_default as "Default" FROM information_schema.COLUMNS WHERE table_name = \'' + this.table(model) + '\'', decoratedCallback);};1PG.prototype.autoupdate = function (cb) { var self = this; var wait = 0; Object.keys(this._models).forEach(function (model) { wait += 1; var fields; getTableStatus.call(self, model, function(err, fields){ if(err) console.log(err); self.alterTable(model, fields, done); }); }); function done(err) { if (err) { console.log(err); } if (--wait === 0 && cb) { cb(); } };};1PG.prototype.isActual = function(cb) { var self = this; var wait = 0; changes = []; Object.keys(this._models).forEach(function (model) { wait += 1; getTableStatus.call(self, model, function(err, fields){ changes = changes.concat(getPendingChanges.call(self, model, fields)); done(err, changes); }); }); function done(err, fields) { if (err) { console.log(err); } if (--wait === 0 && cb) { var actual = (changes.length === 0); cb(null, actual); } };};1PG.prototype.alterTable = function (model, actualFields, done) { var self = this; var pendingChanges = getPendingChanges.call(self, model, actualFields); applySqlChanges.call(self, model, pendingChanges, done);};1function getPendingChanges(model, actualFields){ var sql = []; var self = this; sql = sql.concat(getColumnsToAdd.call(self, model, actualFields)); sql = sql.concat(getPropertiesToModify.call(self, model, actualFields)); sql = sql.concat(getColumnsToDrop.call(self, model, actualFields)); return sql;};1function getColumnsToAdd(model, actualFields){ var self = this; var m = self._models[model]; var propNames = Object.keys(m.properties); var sql = []; propNames.forEach(function (propName) { var found = searchForPropertyInActual.call(self, propName, actualFields); if(!found && propertyHasNotBeenDeleted.call(self, model, propName)){ sql.push(addPropertyToActual.call(self, model, propName)); } }); return sql;};1function addPropertyToActual(model, propName){ var self = this; var p = self._models[model].properties[propName]; sqlCommand = 'ADD COLUMN "' + propName + '" ' + datatype(p) + " " + (propertyCanBeNull.call(self, model, propName) ? "" : " NOT NULL"); return sqlCommand;};1function searchForPropertyInActual(propName, actualFields){ var found = false; actualFields.forEach(function (f) { if (f.Field === propName) { found = f; return; } }); return found;};1function getPropertiesToModify(model, actualFields){ var self = this; var sql = []; var m = self._models[model]; var propNames = Object.keys(m.properties); var found; propNames.forEach(function (propName) { found = searchForPropertyInActual.call(self, propName, actualFields); if(found && propertyHasNotBeenDeleted.call(self, model, propName)){ if (datatypeChanged(propName, found)) { sql.push(modifyDatatypeInActual.call(self, model, propName)); } if (nullabilityChanged(propName, found)){ sql.push(modifyNullabilityInActual.call(self, model, propName)); } } }); return sql; function datatypeChanged(propName, oldSettings){ var newSettings = m.properties[propName]; if(!newSettings) return false; return oldSettings.Type.toLowerCase() !== datatype(newSettings); }; function nullabilityChanged(propName, oldSettings){ var newSettings = m.properties[propName]; if(!newSettings) return false; var changed = false; if (oldSettings.Null === 'YES' && (newSettings.allowNull === false || newSettings.null === false)) changed = true; if (oldSettings.Null === 'NO' && !(newSettings.allowNull === false || newSettings.null === false)) changed = true; return changed; };};1function modifyDatatypeInActual(model, propName) { var self = this; var sqlCommand = 'ALTER COLUMN "' + propName + '" TYPE ' + datatype(self._models[model].properties[propName]); return sqlCommand;};1function modifyNullabilityInActual(model, propName) { var self = this; var sqlCommand = 'ALTER COLUMN "' + propName + '" '; if(propertyCanBeNull.call(self, model, propName)){ sqlCommand = sqlCommand + "DROP "; } else { sqlCommand = sqlCommand + "SET "; } sqlCommand = sqlCommand + "NOT NULL"; return sqlCommand;};1function getColumnsToDrop(model, actualFields){ var self = this; var sql = []; actualFields.forEach(function (actualField) { if (actualField.Field === 'id') return; if (actualFieldNotPresentInModel(actualField, model)) { sql.push('DROP COLUMN "' + actualField.Field + '"'); } }); return sql; function actualFieldNotPresentInModel(actualField, model){ return !(self._models[model].properties[actualField.Field]); };};1function applySqlChanges(model, pendingChanges, done){ var self = this; if (pendingChanges.length) { var thisQuery = 'ALTER TABLE ' + self.tableEscaped(model); var ranOnce = false; pendingChanges.forEach(function(change){ if(ranOnce) thisQuery = thisQuery + ','; thisQuery = thisQuery + ' ' + change; ranOnce = true; }); thisQuery = thisQuery + ';'; self.query(thisQuery, callback); } function callback(err, data){ if(err) console.log(err); } done();};1PG.prototype.propertiesSQL = function (model) { var self = this;1 var sql = ['"id" SERIAL PRIMARY KEY'];1 Object.keys(this._models[model].properties).forEach(function (prop) { sql.push('"' + prop + '" ' + self.propertySettingsSQL(model, prop));2 });1 return sql.join(',\n ');1};1PG.prototype.propertySettingsSQL = function (model, propName) { var self = this;2 var p = self._models[model].properties[propName];2 var result = datatype(p) + ' '; if(!propertyCanBeNull.call(self, model, propName)) result = result + 'NOT NULL ';2 return result;2};1function propertyCanBeNull(model, propName){ var p = this._models[model].properties[propName];2 return !(p.allowNull === false || p['null'] === false);2};1function escape(val) { if (val === undefined || val === null) { return 'NULL'; } switch (typeof val) { case 'boolean': return (val) ? 'true' : 'false'; case 'number': return val+''; } if (typeof val === 'object') { val = (typeof val.toISOString === 'function') ? val.toISOString() : val.toString(); } val = val.replace(/[\0\n\r\b\t\\\'\"\x1a]/g, function(s) { switch(s) { case "\0": return "\\0"; case "\n": return "\\n"; case "\r": return "\\r"; case "\b": return "\\b"; case "\t": return "\\t"; case "\x1a": return "\\Z"; default: return "\\"+s; } });4 return "'"+val+"'";4};1function datatype(p) { switch (p.type.name) { case 'String': return 'varchar';1 case 'Text': return 'text'; case 'Number': return 'integer';1 case 'Date': return 'timestamp'; case 'Boolean': return 'boolean'; default: console.log("Warning: postgres adapter does not explicitly handle type '" + p.type.name +"'"); return p.type.toLowerCase(); //TODO a default case might not be the safest thing here... postgres has a fair number of extra types though }};1function mapPostgresDatatypes(typeName) { //TODO there are a lot of synonymous type names that should go here-- this is just what i've run into so far switch (typeName){ case 'int4': return 'integer'; default: return typeName; }};1function propertyHasNotBeenDeleted(model, propName){ return !!this._models[model].properties[propName];};1
module.exports = BaseSQL;/** * Base SQL class */function BaseSQL() {}BaseSQL.prototype.query = function () { throw new Error('query method should be declared in adapter');};1BaseSQL.prototype.command = function (sql, callback) { return this.query(sql, callback);2};1BaseSQL.prototype.queryOne = function (sql, callback) { return this.query(sql, function (err, data) { if (err) return callback(err); callback(err, data[0]); });};1BaseSQL.prototype.table = function (model) { return this._models[model].model.schema.tableName(model);6};1BaseSQL.prototype.escapeName = function (name) { throw new Error('escapeName method should be declared in adapter');};1BaseSQL.prototype.tableEscaped = function (model) { return this.escapeName(this.table(model));6};1BaseSQL.prototype.define = function (descr) { if (!descr.settings) descr.settings = {};1 this._models[descr.model.modelName] = descr;1};1BaseSQL.prototype.defineProperty = function (model, prop, params) { this._models[model].properties[prop] = params;};1BaseSQL.prototype.save = function (model, data, callback) { var sql = 'UPDATE ' + this.tableEscaped(model) + ' SET ' + this.toFields(model, data) + ' WHERE ' + this.escapeName('id') + ' = ' + data.id; this.query(sql, function (err) { callback(err); });};1BaseSQL.prototype.exists = function (model, id, callback) { var sql = 'SELECT 1 FROM ' + this.tableEscaped(model) + ' WHERE ' + this.escapeName('id') + ' = ' + id + ' LIMIT 1'; this.query(sql, function (err, data) { if (err) return callback(err); callback(null, data.length === 1); });};1BaseSQL.prototype.find = function find(model, id, callback) { var sql = 'SELECT * FROM ' + this.tableEscaped(model) + ' WHERE ' + this.escapeName('id') + ' = ' + id + ' LIMIT 1'; this.query(sql, function (err, data) { if (data && data.length === 1) { data[0].id = id; } else { data = [null]; } callback(err, this.fromDatabase(model, data[0])); }.bind(this));};1BaseSQL.prototype.destroy = function destroy(model, id, callback) { var sql = 'DELETE FROM ' + this.tableEscaped(model) + ' WHERE ' + this.escapeName('id') + ' = ' + id; this.command(sql, function (err) { callback(err); });};1BaseSQL.prototype.destroyAll = function destroyAll(model, callback) { this.command('DELETE FROM ' + this.tableEscaped(model), function (err) { if (err) { return callback(err, []); } callback(err); }.bind(this));};1BaseSQL.prototype.count = function count(model, callback, where) { var self = this; var props = this._models[model].properties; this.queryOne('SELECT count(*) as cnt FROM ' + this.tableEscaped(model) + ' ' + buildWhere(where), function (err, res) { if (err) return callback(err); callback(err, res && res.cnt); }); function buildWhere(conds) { var cs = []; Object.keys(conds || {}).forEach(function (key) { var keyEscaped = self.escapeName(key); if (conds[key] === null) { cs.push(keyEscaped + ' IS NULL'); } else { cs.push(keyEscaped + ' = ' + self.toDatabase(props[key], conds[key])); } }); return cs.length ? ' WHERE ' + cs.join(' AND ') : ''; }};1BaseSQL.prototype.updateAttributes = function updateAttrs(model, id, data, cb) { data.id = id; this.save(model, data, cb);};1BaseSQL.prototype.disconnect = function disconnect() { this.client.end();1};1BaseSQL.prototype.automigrate = function (cb) { var self = this;1 var wait = 0;1 Object.keys(this._models).forEach(function (model) { wait += 1;1 self.dropTable(model, function () { // console.log('drop', model); self.createTable(model, function (err) { // console.log('create', model); if (err) console.log(err);1 done();1 });1 });1 });1 if (wait === 0) cb();1 function done() { if (--wait === 0 && cb) { cb();1 } }};1BaseSQL.prototype.dropTable = function (model, cb) { this.command('DROP TABLE IF EXISTS ' + this.tableEscaped(model), cb);1};1BaseSQL.prototype.createTable = function (model, cb) { this.command('CREATE TABLE ' + this.tableEscaped(model) + ' (\n ' + this.propertiesSQL(model) + '\n)', cb);1};1