Skip to content

public / sequelize

Go to a project

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

Commit c05b57d8 by Shawn Woodtke Committed by sdepold
Options

Add 'postgres' dialect to support PostgreSQL. 

- The basic functionality seems to be working
- The DAO and DAO factory tests all pass.
1 parent 0d35560a
Inline Side-by-side
Showing with 558 additions and 31 deletions
.gitignore
test*.js test*.js
*.swp
.idea .idea
.DS_STORE .DS_STORE
node_modules node_modules
......
lib/dialects/postgres/connector-manager.js 0 → 100644
var Query = require("./query")
, Utils = require("../../utils")
, without = function(arr, elem) { return arr.filter(function(e) { return e != elem }) }
module.exports = (function() {
var ConnectorManager = function(sequelize, config) {
this.sequelize = sequelize
this.client = null
this.config = config || {}
this.disconnectTimeoutId = null
this.pendingQueries = 0
this.maxConcurrentQueries = (this.config.maxConcurrentQueries || 50)
}
Utils._.extend(ConnectorManager.prototype, require("../connector-manager").prototype)
var isConnecting = false
var isConnected = false
ConnectorManager.prototype.query = function(sql, callee, options) {
var self = this
if (this.client == null) this.connect()
var query = new Query(this.client, callee, options || {})
self.pendingQueries += 1
return query.run(sql)
.success(function() { self.endQuery.call(self) })
.error(function() { self.endQuery.call(self) })
}
ConnectorManager.prototype.endQuery = function() {
var self = this
self.pendingQueries -= 1
if (self.pendingQueries == 0) {
setTimeout(function() {
self.pendingQueries == 0 && self.disconnect.call(self)
}, 100)
}
}
ConnectorManager.prototype.connect = function() {
var self = this
// in case database is slow to connect, prevent orphaning the client
if (this.isConnecting) return
this.isConnecting = true
this.isConnected = false
var conStr = 'tcp://<%= user %>:<%= password %>@<%= host %>:<%= port %>/<%= database %>'
conStr = Utils._.template(conStr)({
user: this.config.username,
password: this.config.password,
database: this.config.database,
host: this.config.host,
port: this.config.port
})
var pg = require("pg")
this.client = new pg.Client(conStr)
this.client.connect(function(err, client) {
self.isConnecting = false
if (!err && client) {
self.isConnected = true
this.client = client
} else {
this.client = null
}
})
}
ConnectorManager.prototype.disconnect = function() {
var self = this
if (this.client) this.client.end()
this.client = null
this.isConnecting = false
this.isConnected = false
}
return ConnectorManager
})()
lib/dialects/postgres/query-generator.js 0 → 100644
var Utils = require("../../utils")
, util = require("util")
tables = {}
function pgEscape(s) {
s = Utils.escape(s)
if (typeof s == 'string') s = s.replace(/\\"/g, '"')
return s
}
module.exports = (function() {
var QueryGenerator = {
createTableQuery: function(tableName, attributes, options) {
options = Utils._.extend({
}, options || {})
tables[tableName] = {}
var query = "CREATE TABLE IF NOT EXISTS <%= table %> (<%= attributes%>)"
, primaryKeys = []
, attrStr = Utils._.map(attributes, function(dataType, attr) {
if (Utils._.includes(dataType, 'PRIMARY KEY')) {
primaryKeys.push(attr)
dataType = dataType.replace(/PRIMARY KEY/, '')
}
if (Utils._.includes(dataType, 'DATETIME')) {
dataType = dataType.replace(/DATETIME/, 'TIMESTAMP')
}
if (Utils._.includes(dataType, 'TINYINT(1)')) {
dataType = dataType.replace(/TINYINT\(1\)/, 'BOOLEAN')
}
if (Utils._.includes(dataType, 'DATETIME')) {
dataType = dataType.replace(/DATETIME/, 'TIMESTAMP')
}
if (Utils._.includes(dataType, 'SERIAL')) {
dataType = dataType.replace(/INTEGER/, '')
dataType = dataType.replace(/NOT NULL/, '')
tables[tableName][attr] = 'serial'
}
return attr + " " + dataType
}).join(", ")
, values = {
table: tableName,
attributes: attrStr,
engine: options.engine,
charset: (options.charset ? "DEFAULT CHARSET=" + options.charset : "")
}
, pkString = primaryKeys.map(function(pk) {return pk}).join(", ")
if(pkString.length > 0) values.attributes += ", PRIMARY KEY (" + pkString + ")"
return Utils._.template(query)(values).trim() + ";"
},
dropTableQuery: function(tableName, options) {
options = options || {}
var query = "DROP TABLE IF EXISTS <%= table %>;"
return Utils._.template(query)({table: tableName})
},
renameTableQuery: function(before, after) {
var query = "ALTER TABLE <%= before %> RENAME TO <%= after %>;"
return Utils._.template(query)({ before: before, after: after })
},
showTablesQuery: function() {
return "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';"
},
addColumnQuery: function(tableName, attributes) {
var query = "ALTER TABLE <%= tableName %> ADD COLUMN <%= attributes %>;"
, attrString = Utils._.map(attributes, function(definition, attributeName) {
return Utils._.template('<%= attributeName %> <%= definition %>')({
attributeName: attributeName,
definition: definition
})
}).join(', ')
return Utils._.template(query)({ tableName: tableName, attributes: attrString })
},
removeColumnQuery: function(tableName, attributeName) {
var query = "ALTER TABLE <%= tableName %> DROP COLUMN <%= attributeName %>;"
return Utils._.template(query)({ tableName: tableName, attributeName: attributeName })
},
changeColumnQuery: function(tableName, attributes) {
var query = "ALTER TABLE <%= tableName %> ALTER COLUMN <%= attributes %>;"
var attrString = Utils._.map(attributes, function(definition, attributeName) {
return Utils._.template('<%= attributeName %> <%= attributeName %> <%= definition %>')({
attributeName: attributeName,
definition: definition
})
}).join(', ')
return Utils._.template(query)({ tableName: tableName, attributes: attrString })
},
renameColumnQuery: function(tableName, attrBefore, attributes) {
var query = "ALTER TABLE <%= tableName %> RENAME COLUMN <%= attributes %>;"
var attrString = Utils._.map(attributes, function(definition, attributeName) {
return Utils._.template('<%= before %> TO <%= after %>')({
before: attrBefore,
after: attributeName,
})
}).join(', ')
return Utils._.template(query)({ tableName: tableName, attributes: attrString })
},
selectQuery: function(tableName, options) {
options = options || {}
options.table = Array.isArray(tableName) ? tableName.map(function(tbl){return tbl}).join(", ") : tableName
options.attributes = options.attributes && options.attributes.map(function(attr){
if(Array.isArray(attr) && attr.length == 2)
return [attr[0], attr[1]].join(' as ')
else
return attr.indexOf(Utils.TICK_CHAR)<0 ? attr : attr
}).join(", ")
options.attributes = options.attributes || '*'
var query = "SELECT <%= attributes %> FROM <%= table %>"
if(options.where) {
options.where = QueryGenerator.getWhereConditions(options.where)
query += " WHERE <%= where %>"
}
if(options.order) query += " ORDER BY <%= order %>"
if(options.group) {
options.group = options.group
query += " GROUP BY <%= group %>"
}
if(options.limit) query += " LIMIT <%= limit %>"
if(options.offset) query += " OFFSET <%= offset %>"
query += ";"
return Utils._.template(query)(options)
},
insertQuery: function(tableName, attrValueHash) {
var query = "INSERT INTO <%= table %> (<%= attributes %>) VALUES (<%= values %>) RETURNING *;"
returning = []
Utils._.forEach(attrValueHash, function(value, key, hash) {
if (tables[tableName] && tables[tableName][key]) {
switch (tables[tableName][key]) {
case 'serial':
delete hash[key]
returning.push(key)
break
}
}
});
var replacements = {
table: tableName,
attributes: Utils._.keys(attrValueHash).map(function(attr){return attr}).join(","),
values: Utils._.values(attrValueHash).map(function(value){
return pgEscape((value instanceof Date) ? Utils.toSqlDate(value) : value)
}).join(",")
}
return Utils._.template(query)(replacements)
},
updateQuery: function(tableName, values, where) {
var query = "UPDATE <%= table %> SET <%= values %> WHERE <%= where %>"
var replacements = {
table: tableName,
values: Utils._.map(values, function(value, key){
return key + "=" + pgEscape((value instanceof Date) ? Utils.toSqlDate(value) : value)
}).join(","),
where: QueryGenerator.getWhereConditions(where)
}
return Utils._.template(query)(replacements)
},
deleteQuery: function(tableName, where, options) {
options = options || {}
options.limit = options.limit || 1
var query = "DELETE FROM <%= table %> WHERE <%= where %>"
var replacements = {
table: tableName,
where: QueryGenerator.getWhereConditions(where),
limit: pgEscape(options.limit)
}
return Utils._.template(query)(replacements)
},
addIndexQuery: function(tableName, attributes, options) {
var transformedAttributes = attributes.map(function(attribute) {
if(typeof attribute == 'string')
return attribute
else {
var result = ""
if(!attribute.attribute)
throw new Error('The following index attribute has no attribute: ' + util.inspect(attribute))
result += attribute.attribute
if(attribute.length)
result += '(' + attribute.length + ')'
if(attribute.order)
result += ' ' + attribute.order
return result
}
})
var onlyAttributeNames = attributes.map(function(attribute) {
return (typeof attribute == 'string') ? attribute : attribute.attribute
})
options = Utils._.extend({
indicesType: null,
indexName: Utils._.underscored(tableName + '_' + onlyAttributeNames.join('_')),
parser: null
}, options || {})
return Utils._.compact([
"CREATE", options.indicesType, "INDEX", options.indexName,
(options.indexType ? ('USING ' + options.indexType) : undefined),
"ON", tableName, '(' + transformedAttributes.join(', ') + ')',
(options.parser ? "WITH PARSER " + options.parser : undefined)
]).join(' ')
},
showIndexQuery: function(tableName, options) {
var sql = "SHOW INDEX FROM <%= tableName %><%= options %>"
return Utils._.template(sql)({
tableName: tableName,
options: (options || {}).database ? ' FROM ' + options.database : ''
})
},
removeIndexQuery: function(tableName, indexNameOrAttributes) {
var sql = "DROP INDEX <%= indexName %> ON <%= tableName %>"
, indexName = indexNameOrAttributes
if(typeof indexName != 'string')
indexName = Utils._.underscored(tableName + '_' + indexNameOrAttributes.join('_'))
return Utils._.template(sql)({ tableName: tableName, indexName: indexName })
},
getWhereConditions: function(smth) {
var result = null
if(Utils.isHash(smth))
result = QueryGenerator.hashToWhereConditions(smth)
else if(typeof smth == 'number')
result = 'id' + "=" + pgEscape(smth)
else if(typeof smth == "string")
result = smth
else if(Array.isArray(smth))
result = Utils.format(smth)
return result
},
hashToWhereConditions: function(hash) {
return Utils._.map(hash, function(value, key) {
//handle qualified key names
var _key = key.split('.').map(function(col){return col}).join(".")
, _value = null
if(Array.isArray(value)) {
_value = "(" + Utils._.map(value, function(subvalue) {
return pgEscape(subvalue);
}).join(',') + ")"
return [_key, _value].join(" IN ")
}
else if ((value) && (typeof value == 'object')) {
//using as sentinel for join column => value
_value = value.join.split('.').map(function(col){return col}).join(".")
return [_key, _value].join("=")
} else {
_value = pgEscape(value)
return (_value == 'NULL') ? _key + " IS NULL" : [_key, _value].join("=")
}
}).join(" AND ")
},
attributesToSQL: function(attributes) {
var result = {}
Utils._.map(attributes, function(dataType, name) {
//console.log(name, 'dataType:', dataType)
if(Utils.isHash(dataType)) {
var template = "<%= type %>"
, replacements = { type: dataType.type }
if(dataType.type == 'TINYINT(1)') dataType.type = 'BOOLEAN'
if(dataType.type == 'DATETIME') dataType.type = 'TIMESTAMP'
if(dataType.hasOwnProperty('allowNull') && (!dataType.allowNull)) template += " NOT NULL"
if(dataType.autoIncrement) template +=" SERIAL"
if(dataType.defaultValue != undefined) {
template += " DEFAULT <%= defaultValue %>"
replacements.defaultValue = pgEscape(dataType.defaultValue)
}
if(dataType.unique) template += " UNIQUE"
if(dataType.primaryKey) template += " PRIMARY KEY"
result[name] = Utils._.template(template)(replacements)
} else {
result[name] = dataType
}
})
return result
},
findAutoIncrementField: function(factory) {
var fields = Utils._.map(factory.attributes, function(definition, name) {
var isAutoIncrementField = (definition && (definition.indexOf('SERIAL') > -1))
return isAutoIncrementField ? name : null
})
return Utils._.compact(fields)
}
}
return Utils._.extend(Utils._.clone(require("../query-generator")), QueryGenerator)
})()
lib/dialects/postgres/query.js 0 → 100644
var Utils = require("../../utils")
module.exports = (function() {
var Query = function(client, callee, options) {
var self = this
this.client = client
this.callee = callee
this.options = Utils._.extend({
logging: true,
plain: false,
raw: false
}, options || {})
}
Utils._.extend(Query.prototype, require("../query").prototype)
Query.prototype.run = function(sql) {
var self = this
this.sql = sql
var results = [];
var receivedError = false;
var query = this.client.query(sql)
query.on('row', function(row) {
if (self.callee && self.sql.indexOf('INSERT INTO') == 0) {
Utils._.forEach(row, function(value, key) {
self.callee[key] = value
})
results.push(self.callee)
}
if (self.sql.indexOf('SELECT table_name FROM information_schema.tables') == 0) {
results.push(Utils._.values(row))
} else if (self.sql.indexOf('SELECT') == 0) {
// transform results into real model instances
// return the first real model instance if options.plain is set (e.g. Model.find)
if (self.options.raw) {
results.push(row);
} else {
results.push(self.callee.build(row, { isNewRecord: false }))
}
} else if((self.sql.indexOf('SHOW') == 0) || (self.sql.indexOf('DESCRIBE') == 0)) {
results.push(row)
}
});
query.on('end', function() {
self.emit('sql', self.sql)
if (receivedError) return;
if (self.sql.indexOf('SELECT') == 0) {
if (self.options.plain) {
self.emit('success', (results.length == 0) ? null : results[0])
} else {
self.emit('success', results)
}
} else if((self.sql.indexOf('SHOW') == 0) || (self.sql.indexOf('DESCRIBE') == 0)) {
self.emit('success', results)
} else if (self.sql.indexOf('INSERT INTO') == 0) {
self.emit('success', results[0])
} else if (self.sql.indexOf('UPDATE') == 0) {
self.emit('success', self.callee)
} else {
self.emit('success', results)
}
});
query.on('error', function(err) {
receivedError = true
self.emit('failure', err, self.callee)
});
return this
}
return Query
})()
package.json
...@@ -20,6 +20,7 @@ ...@@ -20,6 +20,7 @@
"devDependencies": { "devDependencies": {
"jasmine-node": "1.0.22", "jasmine-node": "1.0.22",
"sqlite3": ">=2.0.0", "sqlite3": ">=2.0.0",
"pg": "0.6.x",
"buster": "0.4.x" "buster": "0.4.x"
}, },
"keywords": ["mysql", "orm", "nodejs", "object relational mapper"], "keywords": ["mysql", "orm", "nodejs", "object relational mapper"],
......
spec-jasmine/associations/belongs-to.spec.js
var config = require("../config/config") var config = require("../config/config")
, Sequelize = require("../../index") , Sequelize = require("../../index")
, sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
, Helpers = new (require("../config/helpers"))(sequelize) , Helpers = new (require("../config/helpers"))(sequelize)
describe('BelongsTo', function() { describe('BelongsTo', function() {
......
spec-jasmine/associations/has-many.spec.js
var config = require("../config/config") var config = require("../config/config")
, Sequelize = require("../../index") , Sequelize = require("../../index")
, sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
, Helpers = new (require("../config/helpers"))(sequelize) , Helpers = new (require("../config/helpers"))(sequelize)
describe('HasMany', function() { describe('HasMany', function() {
...@@ -10,7 +10,7 @@ describe('HasMany', function() { ...@@ -10,7 +10,7 @@ describe('HasMany', function() {
, Helpers = null , Helpers = null
var setup = function() { var setup = function() {
sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
Helpers = new (require("../config/helpers"))(sequelize) Helpers = new (require("../config/helpers"))(sequelize)
Helpers.dropAllTables() Helpers.dropAllTables()
......
spec-jasmine/associations/has-one.spec.js
var config = require("../config/config") var config = require("../config/config")
, Sequelize = require("../../index") , Sequelize = require("../../index")
, sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
, Helpers = new (require("../config/helpers"))(sequelize) , Helpers = new (require("../config/helpers"))(sequelize)
describe('HasOne', function() { describe('HasOne', function() {
......
spec-jasmine/config/config.js
module.exports = { module.exports = {
username: "root",
password: null,
database: 'sequelize_test',
host: '127.0.0.1',
rand: function() { rand: function() {
return parseInt(Math.random() * 999) return parseInt(Math.random() * 999)
},
mysql: {
username: "root",
password: null,
database: 'sequelize_test',
host: '127.0.0.1',
port: 3306
},
sqlite: {
},
postgres: {
database: 'sequelize_test',
port: 5432
} }
} }
spec-jasmine/dao-factory.spec.js
var config = require("./config/config") var config = require("./config/config")
, Sequelize = require("../index") , Sequelize = require("../index")
, dialects = ['sqlite', 'mysql'] , dialects = ['sqlite', 'mysql', 'postgres']
describe('DAOFactory', function() { describe('DAOFactory', function() {
dialects.forEach(function(dialect) { dialects.forEach(function(dialect) {
describe('with dialect "' + dialect + '"', function() { describe('with dialect "' + dialect + '"', function() {
var User = null var User = null
, sequelize = new Sequelize(config.database, config.username, config.password, { , sequelize = new Sequelize(
logging: false, config[dialect].database,
dialect: dialect config[dialect].username,
}) config[dialect].password,
{
logging: false,
dialect: dialect,
port: config[dialect].port
}
)
, Helpers = new (require("./config/helpers"))(sequelize) , Helpers = new (require("./config/helpers"))(sequelize)
var setup = function(options) { var setup = function(options) {
...@@ -109,7 +115,8 @@ describe('DAOFactory', function() { ...@@ -109,7 +115,8 @@ describe('DAOFactory', function() {
checkMatchForDialects(err.message, { checkMatchForDialects(err.message, {
sqlite: /.*SQLITE_CONSTRAINT.*/, sqlite: /.*SQLITE_CONSTRAINT.*/,
mysql: /.*Duplicate\ entry.*/ mysql: /.*Duplicate\ entry.*/,
postgres: /.*duplicate\ key\ value.*/
}) })
done() done()
...@@ -130,7 +137,8 @@ describe('DAOFactory', function() { ...@@ -130,7 +137,8 @@ describe('DAOFactory', function() {
checkMatchForDialects(err.message, { checkMatchForDialects(err.message, {
sqlite: /.*SQLITE_CONSTRAINT.*/, sqlite: /.*SQLITE_CONSTRAINT.*/,
mysql: "Column 'smth' cannot be null" mysql: "Column 'smth' cannot be null",
postgres: /.*column "smth" violates not-null.*/
}) })
User.create({username: 'foo', smth: 'foo'}).success(function() { User.create({username: 'foo', smth: 'foo'}).success(function() {
...@@ -139,7 +147,8 @@ describe('DAOFactory', function() { ...@@ -139,7 +147,8 @@ describe('DAOFactory', function() {
checkMatchForDialects(err.message, { checkMatchForDialects(err.message, {
sqlite: /.*SQLITE_CONSTRAINT.*/, sqlite: /.*SQLITE_CONSTRAINT.*/,
mysql: "Duplicate entry 'foo' for key 'username'" mysql: "Duplicate entry 'foo' for key 'username'",
postgres: /.*duplicate key value violates unique constraint.*/
}) })
done() done()
......
spec-jasmine/dao.spec.js
var config = require("./config/config") var config = require("./config/config")
, Sequelize = require("../index") , Sequelize = require("../index")
, dialects = ['sqlite', 'mysql'] , dialects = ['sqlite', 'mysql', 'postgres']
describe('DAO', function() { describe('DAO', function() {
dialects.forEach(function(dialect) { dialects.forEach(function(dialect) {
describe('with dialect "' + dialect + '"', function() { describe('with dialect "' + dialect + '"', function() {
var User = null var User = null
, sequelize = new Sequelize(config.database, config.username, config.password, { , sequelize = new Sequelize(
logging: false, config[dialect].database,
dialect: dialect config[dialect].username,
}) config[dialect].password,
{
logging: false,
dialect: dialect,
port: config[dialect].port
}
)
, Helpers = new (require("./config/helpers"))(sequelize) , Helpers = new (require("./config/helpers"))(sequelize)
var setup = function() { var setup = function() {
...@@ -471,7 +477,7 @@ describe('DAO', function() { ...@@ -471,7 +477,7 @@ describe('DAO', function() {
}).success(function(user) { }).success(function(user) {
var emitter = user.updateAttributes({name: 'foobar'}) var emitter = user.updateAttributes({name: 'foobar'})
emitter.success(function() { emitter.success(function() {
expect(emitter.query.sql).toMatch(/WHERE `identifier`..identifier./) expect(emitter.query.sql).toMatch(/WHERE `?identifier`?..identifier./)
done() done()
}) })
}) })
......
spec-jasmine/migration.spec.js
var config = require("./config/config") var config = require("./config/config")
, Sequelize = require("../index") , Sequelize = require("../index")
, sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
, Helpers = new (require("./config/helpers"))(sequelize) , Helpers = new (require("./config/helpers"))(sequelize)
, Migrator = require("../lib/migrator") , Migrator = require("../lib/migrator")
, Migration = require("../lib/migration") , Migration = require("../lib/migration")
......
spec-jasmine/migrator.spec.js
var config = require("./config/config") var config = require("./config/config")
, Sequelize = require("../index") , Sequelize = require("../index")
, sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
, Helpers = new (require("./config/helpers"))(sequelize) , Helpers = new (require("./config/helpers"))(sequelize)
, Migrator = require("../lib/migrator") , Migrator = require("../lib/migrator")
, _ = Sequelize.Utils._ , _ = Sequelize.Utils._
......
spec-jasmine/mysql/associations.has-many.spec.js
var config = require("../config/config") var config = require("../config/config")
, Sequelize = require("../../index") , Sequelize = require("../../index")
, sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
, Helpers = new (require("../config/helpers"))(sequelize) , Helpers = new (require("../config/helpers"))(sequelize)
describe('HasMany', function() { describe('HasMany', function() {
......
spec-jasmine/mysql/associations.spec.js
var config = require("../config/config") var config = require("../config/config")
, Sequelize = require("../../index") , Sequelize = require("../../index")
, sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
, Helpers = new (require("../config/helpers"))(sequelize) , Helpers = new (require("../config/helpers"))(sequelize)
describe('Associations', function() { describe('Associations', function() {
......
spec-jasmine/mysql/connector-manager.spec.js
var config = require("../config/config") var config = require("../config/config")
, Sequelize = require("../../index") , Sequelize = require("../../index")
, sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
, Helpers = new (require("../config/helpers"))(sequelize) , Helpers = new (require("../config/helpers"))(sequelize)
describe('ConnectorManager', function() { describe('ConnectorManager', function() {
......
spec-jasmine/mysql/dao-factory.spec.js
var config = require("../config/config") var config = require("../config/config")
, Sequelize = require("../../index") , Sequelize = require("../../index")
, sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
, Helpers = new (require("../config/helpers"))(sequelize) , Helpers = new (require("../config/helpers"))(sequelize)
describe('DAOFactory', function() { describe('DAOFactory', function() {
......
spec-jasmine/mysql/query-generator.spec.js
var config = require("../config/config") var config = require("../config/config")
, Sequelize = require("../../index") , Sequelize = require("../../index")
, sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
, Helpers = new (require("../config/helpers"))(sequelize) , Helpers = new (require("../config/helpers"))(sequelize)
, QueryGenerator = require("../../lib/dialects/mysql/query-generator") , QueryGenerator = require("../../lib/dialects/mysql/query-generator")
, util = require("util") , util = require("util")
......
spec-jasmine/query-interface.spec.js
var config = require("./config/config") var config = require("./config/config")
, Sequelize = require("../index") , Sequelize = require("../index")
, sequelize = new Sequelize(config.database, config.username, config.password, { logging: false }) , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
, Helpers = new (require("./config/helpers"))(sequelize) , Helpers = new (require("./config/helpers"))(sequelize)
, QueryInterface = require("../lib/query-interface") , QueryInterface = require("../lib/query-interface")
......
spec-jasmine/sequelize.spec.js
...@@ -9,7 +9,7 @@ describe('Sequelize', function() { ...@@ -9,7 +9,7 @@ describe('Sequelize', function() {
var setup = function(options) { var setup = function(options) {
options = options || {logging: false} options = options || {logging: false}
sequelize = new Sequelize(config.database, config.username, config.password, options) sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, options)
Helpers = new (require("./config/helpers"))(sequelize) Helpers = new (require("./config/helpers"))(sequelize)
return options return options
......
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!