Skip to content

public / sequelize

Go to a project

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

Commit da053191 by Joel Trost Committed by Matt Broadstone
Options

Destroyed the Select statement, now rebuilding

1 parent 5db3a650
Inline Side-by-side
Showing with 242 additions and 537 deletions
lib/dialects/abstract/query-generator.js
...@@ -1259,7 +1259,7 @@ module.exports = (function() { ...@@ -1259,7 +1259,7 @@ module.exports = (function() {
} }
query += ';'; query += ';';
console.log(query);
return query; return query;
}, },
......
lib/dialects/mssql/query-generator.js
...@@ -128,7 +128,16 @@ module.exports = (function() { ...@@ -128,7 +128,16 @@ module.exports = (function() {
Returns an insert into command. Parameters: table name + hash of attribute-value-pairs. Returns an insert into command. Parameters: table name + hash of attribute-value-pairs.
*/ */
insertQuery: function(table, valueHash, modelAttributes, options) { insertQuery: function(table, valueHash, modelAttributes, options) {
return SqlGenerator.insertSql(table,valueHash,modelAttributes, options); var modelAttributeMap = {};
if (modelAttributes) {
Utils._.each(modelAttributes, function(attribute, key) {
modelAttributeMap[key] = attribute;
if (attribute.field) {
modelAttributeMap[attribute.field] = attribute;
}
});
}
return SqlGenerator.insertSql(table,valueHash,modelAttributeMap);
}, },
/* /*
...@@ -371,421 +380,24 @@ module.exports = (function() { ...@@ -371,421 +380,24 @@ module.exports = (function() {
selectQuery: function(tableName, options, model) { selectQuery: function(tableName, options, model) {
// Enter and change at your own peril -- Mick Hansen // Enter and change at your own peril -- Mick Hansen
//console.log('tablename', tableName);
//console.log('options', options);
//console.log('model', model);
options = options || {}; options = options || {};
var table = null var query = [
, self = this SqlGenerator.getSelectorClause(model,options),
, query SqlGenerator.getFromClause(model.tableName, model.name)
, limit = options.limit ];
, mainQueryItems = []
, mainAttributes = options.attributes && options.attributes.slice(0)
, mainJoinQueries = []
// We'll use a subquery if we have hasMany associations and a limit and a filtered/required association
, subQuery = limit && (options.hasIncludeWhere || options.hasIncludeRequired || options.hasMultiAssociation) && options.subQuery !== false
, subQueryItems = []
, subQueryAttributes = null
, subJoinQueries = []
, mainTableAs = null;
if (!Array.isArray(tableName) && model) {
options.tableAs = mainTableAs = this.quoteTable(model.name);
}
options.table = table = !Array.isArray(tableName) ? this.quoteTable(tableName) : tableName.map(function(t) {
if (Array.isArray(t)) {
return this.quoteTable(t[0], t[1]);
}
return this.quoteTable(t, true);
}.bind(this)).join(', ');
if (subQuery && mainAttributes) {
model.primaryKeyAttributes.forEach(function(keyAtt) {
// Check if mainAttributes contain the primary key of the model either as a field or an aliased field
if (!_.find(mainAttributes, function (attr) {
return keyAtt === attr || keyAtt === attr[0] || keyAtt === attr[1];
})) {
mainAttributes.push(model.rawAttributes[keyAtt].field ? [keyAtt, model.rawAttributes[keyAtt].field] : keyAtt);
}
});
}
// Escape attributes
mainAttributes = mainAttributes && mainAttributes.map(function(attr) {
var addTable = true;
if (attr._isSequelizeMethod) {
return attr.toString(self);
}
if (Array.isArray(attr) && attr.length === 2) {
if (attr[0]._isSequelizeMethod) {
attr[0] = attr[0].toString(self);
addTable = false;
} else {
if (attr[0].indexOf('(') === -1 && attr[0].indexOf(')') === -1) {
attr[0] = self.quoteIdentifier(attr[0]);
}
}
attr = [attr[0], self.quoteIdentifier(attr[1])].join(' AS ');
} else {
attr = attr.indexOf(Utils.TICK_CHAR) < 0 && attr.indexOf('"') < 0 ? self.quoteIdentifiers(attr) : attr;
}
if (options.include && attr.indexOf('.') === -1 && addTable) {
attr = mainTableAs + '.' + attr;
}
return attr;
});
// If no attributes specified, use *
mainAttributes = mainAttributes || (options.include ? [mainTableAs + '.*'] : ['*']);
// If subquery, we ad the mainAttributes to the subQuery and set the mainAttributes to select * from subquery
if (subQuery) {
// We need primary keys
subQueryAttributes = mainAttributes;
mainAttributes = [mainTableAs + '.*'];
}
if (options.include) {
var generateJoinQueries = function(include, parentTable) {
var table = include.model.getTableName()
, as = include.as
, joinQueryItem = ''
, joinQueries = {
mainQuery: [],
subQuery: []
}
, attributes
, association = include.association
, through = include.through
, joinType = include.required ? ' INNER JOIN ' : ' LEFT OUTER JOIN '
, includeWhere = {}
, whereOptions = Utils._.clone(options);
whereOptions.keysEscaped = true;
if (tableName !== parentTable && mainTableAs !== parentTable) {
as = parentTable + '.' + include.as;
}
// includeIgnoreAttributes is used by aggregate functions
if (options.includeIgnoreAttributes !== false) {
attributes = include.attributes.map(function(attr) {
var attrAs = attr,
verbatim = false;
if (Array.isArray(attr) && attr.length === 2) {
if (attr[0]._isSequelizeMethod) {
if (attr[0] instanceof Utils.literal ||
attr[0] instanceof Utils.cast ||
attr[0] instanceof Utils.fn
) {
verbatim = true;
}
}
attr = attr.map(function($attr) {
return $attr._isSequelizeMethod ? $attr.toString(self) : $attr;
});
attrAs = attr[1];
attr = attr[0];
} else if (attr instanceof Utils.literal) {
return attr.toString(self); // We trust the user to rename the field correctly
} else if (attr instanceof Utils.cast ||
attr instanceof Utils.fn
) {
throw new Error("Tried to select attributes using Sequelize.cast or Sequelize.fn without specifying an alias for the result, during eager loading. " +
"This means the attribute will not be added to the returned instance");
}
var prefix;
if (verbatim === true) {
prefix = attr;
} else {
prefix = self.quoteIdentifier(as) + '.' + self.quoteIdentifier(attr);
}
return prefix + ' AS ' + self.quoteIdentifier(as + '.' + attrAs);
});
if (include.subQuery && subQuery) {
subQueryAttributes = subQueryAttributes.concat(attributes);
} else {
mainAttributes = mainAttributes.concat(attributes);
}
}
if (through) {
var throughTable = through.model.getTableName()
, throughAs = as + '.' + through.as
, throughAttributes = through.attributes.map(function(attr) {
return self.quoteIdentifier(throughAs) + '.' + self.quoteIdentifier(attr) + ' AS ' + self.quoteIdentifier(throughAs + '.' + attr);
})
, primaryKeysSource = association.source.primaryKeyAttributes
, tableSource = parentTable
, identSource = association.identifier
, attrSource = primaryKeysSource[0]
, where
, primaryKeysTarget = association.target.primaryKeyAttributes
, tableTarget = as
, identTarget = association.foreignIdentifier
, attrTarget = primaryKeysTarget[0]
, sourceJoinOn
, targetJoinOn
, targetWhere;
if (options.includeIgnoreAttributes !== false) {
// Through includes are always hasMany, so we need to add the attributes to the mainAttributes no matter what (Real join will never be executed in subquery)
mainAttributes = mainAttributes.concat(throughAttributes);
}
// Filter statement for left side of through
// Used by both join and subquery where
sourceJoinOn = self.quoteTable(tableSource) + '.' + self.quoteIdentifier(attrSource) + ' = ';
sourceJoinOn += self.quoteIdentifier(throughAs) + '.' + self.quoteIdentifier(identSource);
// Filter statement for right side of through
// Used by both join and subquery where
targetJoinOn = self.quoteIdentifier(tableTarget) + '.' + self.quoteIdentifier(attrTarget) + ' = ';
targetJoinOn += self.quoteIdentifier(throughAs) + '.' + self.quoteIdentifier(identTarget);
if (self._dialect.supports.joinTableDependent) {
// Generate a wrapped join so that the through table join can be dependent on the target join
joinQueryItem += joinType + '(';
joinQueryItem += self.quoteTable(throughTable, throughAs);
joinQueryItem += joinType + self.quoteTable(table, as) + ' ON ';
joinQueryItem += targetJoinOn;
joinQueryItem += ') ON '+sourceJoinOn;
} else {
// Generate join SQL for left side of through
joinQueryItem += joinType + self.quoteTable(throughTable, throughAs) + ' ON ';
joinQueryItem += sourceJoinOn;
// Generate join SQL for right side of through
joinQueryItem += joinType + self.quoteTable(table, as) + ' ON ';
joinQueryItem += targetJoinOn;
}
if (include.where) {
targetWhere = self.getWhereConditions(include.where, self.sequelize.literal(self.quoteIdentifier(as)), include.model, whereOptions);
joinQueryItem += ' AND ' + targetWhere;
if (subQuery && include.required) {
if (!options.where) options.where = {};
// Creating the as-is where for the subQuery, checks that the required association exists
options.where['__' + throughAs] = self.sequelize.asIs(['(',
'SELECT ' + self.quoteIdentifier(throughAs) + '.' + self.quoteIdentifier(identSource) + ' FROM ' + self.quoteTable(throughTable, throughAs),
! include.required && joinType + self.quoteTable(association.source.tableName, tableSource) + ' ON ' + sourceJoinOn || '',
joinType + self.quoteTable(table, as) + ' ON ' + targetJoinOn,
'WHERE ' + (! include.required && targetWhere || sourceJoinOn + ' AND ' + targetWhere),
'LIMIT 1',
')', 'IS NOT NULL'].join(' '));
}
}
} else {
var left = association.associationType === 'BelongsTo' ? association.target : association.source
, primaryKeysLeft = left.primaryKeyAttributes
, tableLeft = association.associationType === 'BelongsTo' ? as : parentTable
, attrLeft = primaryKeysLeft[0]
, tableRight = association.associationType === 'BelongsTo' ? parentTable : as
, attrRight = association.identifier
, joinOn;
// Alias the left attribute if the left attribute is not from a subqueried main table
// When doing a query like SELECT aliasedKey FROM (SELECT primaryKey FROM primaryTable) only aliasedKey is available to the join, this is not the case when doing a regular select where you can't used the aliased attribute
if (!subQuery || parentTable !== mainTableAs || tableLeft !== parentTable) {
if (left.rawAttributes[attrLeft].field) {
attrLeft = left.rawAttributes[attrLeft].field;
}
}
// Filter statement
// Used by both join and subquery where
joinOn =
// Left side
(
(subQuery && !include.subQuery && include.parent.subQuery && !(include.hasParentRequired && include.hasParentWhere)) && self.quoteIdentifier(tableLeft + '.' + attrLeft) ||
self.quoteTable(tableLeft) + '.' + self.quoteIdentifier(attrLeft)
)
+ ' = ' +
// Right side
(
(subQuery && !include.subQuery && include.parent.subQuery && (include.hasParentRequired && include.hasParentWhere)) && self.quoteIdentifier(tableRight + '.' + attrRight) ||
self.quoteTable(tableRight) + '.' + self.quoteIdentifier(attrRight)
);
if (include.where) {
joinOn += ' AND ' + self.getWhereConditions(include.where, self.sequelize.literal(self.quoteIdentifier(as)), include.model, whereOptions);
// If its a multi association we need to add a where query to the main where (executed in the subquery)
if (subQuery && association.isMultiAssociation && include.required) {
if (!options.where) options.where = {};
// Creating the as-is where for the subQuery, checks that the required association exists
options.where['__' + as] = self.sequelize.asIs(['(',
'SELECT ' + self.quoteIdentifier(attrRight),
'FROM ' + self.quoteTable(table, as),
'WHERE ' + joinOn,
'LIMIT 1',
')', 'IS NOT NULL'].join(' '));
}
}
// Generate join SQL
joinQueryItem += joinType + self.quoteTable(table, as) + ' ON ' + joinOn;
}
if (include.subQuery && subQuery) {
joinQueries.subQuery.push(joinQueryItem);
} else {
joinQueries.mainQuery.push(joinQueryItem);
}
if (include.include) {
include.include.forEach(function(childInclude) {
if (childInclude._pseudo) return;
var childJoinQueries = generateJoinQueries(childInclude, as);
if (childInclude.subQuery && subQuery) {
joinQueries.subQuery = joinQueries.subQuery.concat(childJoinQueries.subQuery);
}
if (childJoinQueries.mainQuery) {
joinQueries.mainQuery = joinQueries.mainQuery.concat(childJoinQueries.mainQuery);
}
}.bind(this));
}
return joinQueries;
};
// Loop through includes and generate subqueries
options.include.forEach(function(include) {
var joinQueries = generateJoinQueries(include, options.tableAs);
subJoinQueries = subJoinQueries.concat(joinQueries.subQuery);
mainJoinQueries = mainJoinQueries.concat(joinQueries.mainQuery);
}.bind(this));
}
// If using subQuery select defined subQuery attributes and join subJoinQueries
if (subQuery) {
subQueryItems.push('SELECT ' + subQueryAttributes.join(', ') + ' FROM ' + options.table);
if (mainTableAs) {
subQueryItems.push(' AS ' + mainTableAs);
}
subQueryItems.push(subJoinQueries.join(''));
// Else do it the reguar way
} else {
mainQueryItems.push('SELECT ' + mainAttributes.join(', ') + ' FROM ' + options.table);
if (mainTableAs) {
mainQueryItems.push(' AS ' + mainTableAs);
}
mainQueryItems.push(mainJoinQueries.join(''));
}
// Add WHERE to sub or main query
if (options.hasOwnProperty('where')) {
options.where = this.getWhereConditions(options.where, mainTableAs || tableName, model, options);
if (options.where) {
if (subQuery) {
subQueryItems.push(' WHERE ' + options.where);
} else {
mainQueryItems.push(' WHERE ' + options.where);
}
}
}
// Add GROUP BY to sub or main query
if (options.group) {
options.group = Array.isArray(options.group) ? options.group.map(function(t) { return this.quote(t, model); }.bind(this)).join(', ') : options.group;
if (subQuery) {
subQueryItems.push(' GROUP BY ' + options.group);
} else {
mainQueryItems.push(' GROUP BY ' + options.group);
}
}
// Add HAVING to sub or main query
if (options.hasOwnProperty('having')) {
options.having = this.getWhereConditions(options.having, tableName, model, options, false);
if (subQuery) {
subQueryItems.push(' HAVING ' + options.having);
} else {
mainQueryItems.push(' HAVING ' + options.having);
}
}
// Add ORDER to sub or main query
if (options.order) {
var mainQueryOrder = [];
var subQueryOrder = [];
if (Array.isArray(options.order)) {
options.order.forEach(function(t) {
if (subQuery && !(t[0] instanceof Model) && !(t[0].model instanceof Model)) {
subQueryOrder.push(this.quote(t, model));
}
mainQueryOrder.push(this.quote(t, model));
}.bind(this));
} else {
mainQueryOrder.push(options.order);
}
if (mainQueryOrder.length) {
mainQueryItems.push(' ORDER BY ' + mainQueryOrder.join(', '));
}
if (subQueryOrder.length) {
subQueryItems.push(' ORDER BY ' + subQueryOrder.join(', '));
}
}
var limitOrder = this.addLimitAndOffset(options, query);
// Add LIMIT, OFFSET to sub or main query
if (limitOrder) {
if (subQuery) {
subQueryItems.push(limitOrder);
} else {
mainQueryItems.push(limitOrder);
}
}
// If using subQuery, select attributes from wrapped subQuery and join out join tables
if (subQuery) {
query = 'SELECT ' + mainAttributes.join(', ') + ' FROM (';
query += subQueryItems.join('');
query += ') AS ' + options.tableAs;
query += mainJoinQueries.join('');
query += mainQueryItems.join('');
} else {
query = mainQueryItems.join('');
}
if (options.lock && this._dialect.supports.lock) { if(options.include){
if (options.lock === 'SHARE') { for(var i = 0; i < options.include.length; i ++){
query += ' ' + this._dialect.supports.forShare; query.push(SqlGenerator.getJoinClause(model, options.include[i]));
} else {
query += ' FOR UPDATE';
} }
} }
query += ';'; console.log(query);
return query.join(' ') + ';';
return query;
}, },
/** /**
* Returns a query that starts a transaction. * Returns a query that starts a transaction.
......
lib/dialects/mssql/query.js
...@@ -31,7 +31,7 @@ module.exports = (function() { ...@@ -31,7 +31,7 @@ module.exports = (function() {
} }
var promise = new Utils.Promise(function(resolve, reject) { var promise = new Utils.Promise(function(resolve, reject) {
console.log(self.sql); //console.log(self.sql);
self self
.connection .connection
......
lib/dialects/mssql/sql-generator.js
...@@ -3,14 +3,13 @@ ...@@ -3,14 +3,13 @@
var Utils = require('../../utils') var Utils = require('../../utils')
, SqlString = require('../../sql-string') , SqlString = require('../../sql-string')
, DataTypes = require('./data-types') , DataTypes = require('./data-types')
, options , _options
, dialect , _dialect
, sequelize; , _sequelize;
/* /*
Escape a value (e.g. a string, number or date) Escape a value (e.g. a string, number or date)
*/ */
var dialect = 'mssql';
var attributeMap = { var attributeMap = {
notNull:"NOT NULL", notNull:"NOT NULL",
allowNull:"NULL", allowNull:"NULL",
...@@ -24,7 +23,13 @@ var attributeMap = { ...@@ -24,7 +23,13 @@ var attributeMap = {
onUpdate:"ON UPDATE", onUpdate:"ON UPDATE",
default:"DEFAULT" default:"DEFAULT"
}; };
function escape(value, field) {
if (value && value._isSequelizeMethod) {
return value.toString();
} else {
return SqlString.escape(value, false, _options.timezone, _dialect, field);
}
}
function quoteIdentifier(identifier, force) { function quoteIdentifier(identifier, force) {
if (identifier === '*') return identifier; if (identifier === '*') return identifier;
return Utils.addTicks(identifier, '"'); return Utils.addTicks(identifier, '"');
...@@ -58,7 +63,39 @@ function nameIndexes(indexes, rawTablename) { ...@@ -58,7 +63,39 @@ function nameIndexes(indexes, rawTablename) {
}); });
} }
function fieldsToSql(fields, singleQuote){
var fieldStr = [];
for (var key in fields) {
if (fields.hasOwnProperty(key)) {
if(singleQuote){
fieldStr.push(wrapSingleQuote(key));
}else{
fieldStr.push(quoteIdentifier(key));
}
}
}
if(fieldStr){
if(fieldStr.length > 0){
return fieldStr.join(',');
}
}
return '';
}
function valuesToSql(fields, modelAttributeMap){
var values = [];
for (var key in fields) {
if (fields.hasOwnProperty(key)) {
var value = fields[key];
values.push(escape(value, (modelAttributeMap && modelAttributeMap[key]) || undefined));
}
}
if(values){
if(values.length > 0){
return values.join(',');
}
}
return '';
}
function loadColumn(attributes){ function loadColumn(attributes){
var attrStr = []; var attrStr = [];
for (var attr in attributes) { for (var attr in attributes) {
...@@ -75,7 +112,7 @@ function loadColumnWithTypes(attributes){ ...@@ -75,7 +112,7 @@ function loadColumnWithTypes(attributes){
} }
return attrStr; return attrStr;
} }
function addTableExistsWrapper(tableName, query, exists){ function addTableExistsWrapper(query, exists){
return [ return [
"IF (", "IF (",
(exists ? "" : "NOT"), " EXISTS (", (exists ? "" : "NOT"), " EXISTS (",
...@@ -86,34 +123,67 @@ function addTableExistsWrapper(tableName, query, exists){ ...@@ -86,34 +123,67 @@ function addTableExistsWrapper(tableName, query, exists){
"END" "END"
].join(" "); ].join(" ");
} }
function identityInsertOnWrapper(query){
return [
'SET IDENTITY_INSERT <%= tableName %> ON;',
query,
'SET IDENTITY_INSERT <%= tableName %> OFF;'
].join(' ');
}
//select stuff
function loadFields(attributes){
var attrStr = [];
for (var attr in attributes) {
attrStr.push(quoteIdentifier(attr));
}
return attrStr;
}
function loadFields(attributes, tableName){
var attrStr = [];
for (var attr in attributes) {
if(tableName){
attrStr.push(quoteIdentifier(tableName) + "." + quoteIdentifier(attr));
}else{
attrStr.push(quoteIdentifier(attr));
}
}
return attrStr.join(',');
}
function joinFields(attributes, tableName){
var attrStr = [];
if(tableName){
for (var attr in attributes) {
attrStr.push(quoteIdentifier(tableName)
+ "."
+ quoteIdentifier(attr)
+ " AS " + quoteIdentifier(tableName + "." + attr));
}
}
return attrStr.join(',');
}
module.exports = { module.exports = {
get options(){ get options(){
return options; return _options;
}, },
set options(opt) { set options(opt) {
options = opt; _options = opt;
}, },
get dialect(){ get dialect(){
return dialect; return _dialect;
}, },
set dialect(dial) { set dialect(dial) {
dialect = dial; _dialect = dial;
}, },
get sequelize(){ get sequelize(){
return sequelize; return _sequelize;
}, },
set sequelize(seq) { set sequelize(seq) {
sequelize = seq; _sequelize = seq;
},
escape: function(value, field) {
if (value && value._isSequelizeMethod) {
return value.toString();
} else {
return SqlString.escape(value, false, options.timezone, dialect, field);
}
}, },
showTableSql: function(){ showTableSql: function(){
return 'SELECT name FROM sys.Tables;'; return 'SELECT name FROM sys.Tables;';
}, },
...@@ -132,7 +202,7 @@ module.exports = { ...@@ -132,7 +202,7 @@ module.exports = {
tableName: quoteIdentifier(tableName), tableName: quoteIdentifier(tableName),
attributes: attrStr.join(", ") attributes: attrStr.join(", ")
}; };
query = addTableExistsWrapper(tableName, query); query = addTableExistsWrapper(query);
return Utils._.template(query)(values).trim() + ";"; return Utils._.template(query)(values).trim() + ";";
}, },
alterTableSql: function(tableName){ alterTableSql: function(tableName){
...@@ -148,55 +218,38 @@ module.exports = { ...@@ -148,55 +218,38 @@ module.exports = {
unquotedTable: tableName, unquotedTable: tableName,
tableName: quoteIdentifier(tableName) tableName: quoteIdentifier(tableName)
}; };
query = addTableExistsWrapper(tableName, query, true); query = addTableExistsWrapper(query, true);
return Utils._.template(query)(values).trim() + ";"; return Utils._.template(query)(values).trim() + ";";
}, },
insertSql: function(table, valueHash, modelAttributes, options) { insertSql: function(tableName, valueHash, modelAttributeMap) {
options = options || {};
var query var query
, valueQuery = 'INSERT INTO <%= table %> (<%= attributes %>)' , valueQuery = 'INSERT INTO <%= tableName %> (<%= attributes %>)'
, emptyQuery = 'INSERT INTO <%= table %>' , emptyQuery = 'INSERT INTO <%= tableName %>';
, fields = []
, selFields = []
, values = []
, key
, value
, modelAttributeMap = {};
valueQuery += ' OUTPUT <%= selFields %> VALUES (<%= values %>)'; valueQuery += ' OUTPUT <%= selFields %> VALUES (<%= values %>)';
emptyQuery += ' OUTPUT <%= selFields %> VALUES ()'; emptyQuery += ' VALUES ()';
valueHash = Utils.removeNullValuesFromHash(valueHash, this.options.omitNull); valueHash = Utils.removeNullValuesFromHash(valueHash, _options.omitNull);
for (key in valueHash) { var insertKey = false;
if (valueHash.hasOwnProperty(key)) { for (var key in valueHash) {
value = valueHash[key]; if(modelAttributeMap[key].autoIncrement){
// SERIALS' can't be NULL in postgresql, use DEFAULT where supported insertKey = true;
if(modelAttributeMap && modelAttributeMap[key] && modelAttributeMap[key].autoIncrement && value){
fields.push(quoteIdentifier(key));
selFields.push(wrapSingleQuote(key));
valueQuery = 'SET IDENTITY_INSERT <%= table %> ON;'
+ valueQuery
+ '; SET IDENTITY_INSERT <%= table %> OFF';
values.push(this.escape(value, (modelAttributeMap && modelAttributeMap[key]) || undefined));
}else if(value) {
fields.push(quoteIdentifier(key));
selFields.push(wrapSingleQuote(key));
values.push(this.escape(value, (modelAttributeMap && modelAttributeMap[key]) || undefined));
}
} }
} }
var replacements = { var replacements = {
table: quoteIdentifier(table), tableName: quoteIdentifier(tableName),
attributes: fields.join(','), attributes: fieldsToSql(valueHash, false),
selFields: selFields.join(','), selFields: fieldsToSql(valueHash, true),
values: values.join(',') values: valuesToSql(valueHash, modelAttributeMap)
}; };
query = (replacements.attributes.length ? valueQuery : emptyQuery) + ';'; query = (replacements.attributes.length ? valueQuery : emptyQuery) + ';';
if(insertKey){
query = identityInsertOnWrapper(query);
}
return Utils._.template(query)(replacements); return Utils._.template(query)(replacements);
}, },
...@@ -288,7 +341,7 @@ module.exports = { ...@@ -288,7 +341,7 @@ module.exports = {
var template = 'VARCHAR(10) NOT NULL CHECK ("' var template = 'VARCHAR(10) NOT NULL CHECK ("'
+ attribute.field + '" IN(' + attribute.field + '" IN('
+ Utils._.map(attribute.values, function(value) { + Utils._.map(attribute.values, function(value) {
return this.escape(value); return escape(value);
}.bind(this)).join(', ') + '))'; }.bind(this)).join(', ') + '))';
return template; return template;
}, },
...@@ -327,7 +380,7 @@ module.exports = { ...@@ -327,7 +380,7 @@ module.exports = {
if (attribute.type !== 'TEXT' if (attribute.type !== 'TEXT'
&& attribute.type._binary === false && attribute.type._binary === false
&& Utils.defaultValueSchemable(attribute.defaultValue)) { && Utils.defaultValueSchemable(attribute.defaultValue)) {
if(options && this.escape(attribute.defaultValue)){ if(options && escape(attribute.defaultValue)){
template.push(attributeMap.default + wrapSingleQuote(attribute.defaultValue)); template.push(attributeMap.default + wrapSingleQuote(attribute.defaultValue));
} }
} }
...@@ -405,6 +458,46 @@ module.exports = { ...@@ -405,6 +458,46 @@ module.exports = {
})); }));
} }
return attrString.join(', '); return attrString.join(', ');
},
getSelectorClause: function(model, options){
var query = ['SELECT'];
//we have joins
//add join table
if(options.include){
query.push(loadFields(model.rawAttributes, model.name));
for(var i = 0; i < options.include.length; i++){
if(options.include[i].as) {
query.push(joinFields(options.include[i].model.rawAttributes
, options.include[i].as));
}
}
}else {
query.push(loadFields(model.rawAttributes));
}
return query.join(' ');
},
getFromClause: function(tableName, asValue){
var query = ["FROM",
quoteIdentifier(tableName)];
if(asValue){
query.push("AS");
query.push(quoteIdentifier(asValue));
}
return query.join(' ');
},
getJoinClause: function(model, include){
var primaryKey = '';
for(var key in model.rawAttributes){
if(model.rawAttributes[key].primaryKey){
primaryKey = key;
break;
}
}
console.log(include.association.foreignKey);
console.log(primaryKey);
//for(var i = 0; i < )
var joinType = include.required ? ' INNER JOIN ' : ' LEFT OUTER JOIN ';
} }
}; };
......
test/associations/alias.test.js
...@@ -38,72 +38,72 @@ describe(Support.getTestDialectTeaser("Alias"), function() { ...@@ -38,72 +38,72 @@ describe(Support.getTestDialectTeaser("Alias"), function() {
}); });
}); });
it('shouldnt touch the passed alias', function () { // it('shouldnt touch the passed alias', function () {
var User = this.sequelize.define('user', {}) // var User = this.sequelize.define('user', {})
, Task = this.sequelize.define('task', {}); // , Task = this.sequelize.define('task', {});
User.hasMany(Task, { as: 'ASSIGNMENTS', foreignKey: 'userId' }); // User.hasMany(Task, { as: 'ASSIGNMENTS', foreignKey: 'userId' });
Task.belongsTo(User, { as: 'OWNER', foreignKey: 'userId' }); // Task.belongsTo(User, { as: 'OWNER', foreignKey: 'userId' });
return this.sequelize.sync({ force: true }).then(function () { // return this.sequelize.sync({ force: true }).then(function () {
return User.create({ id: 1 }); // return User.create({ id: 1 });
}).then(function (user){ // }).then(function (user){
expect(user.getASSIGNMENTS).to.be.ok; // expect(user.getASSIGNMENTS).to.be.ok;
return Task.create({ id: 1, userId: 1 }); // return Task.create({ id: 1, userId: 1 });
}).then(function (task) { // }).then(function (task) {
expect(task.getOWNER).to.be.ok; // expect(task.getOWNER).to.be.ok;
return Promise.all([ // return Promise.all([
User.find({ where: { id: 1 }, include: [{model: Task, as: 'ASSIGNMENTS'}] }), // User.find({ where: { id: 1 }, include: [{model: Task, as: 'ASSIGNMENTS'}] }),
Task.find({ where: { id: 1 }, include: [{model: User, as: 'OWNER'}] }), // Task.find({ where: { id: 1 }, include: [{model: User, as: 'OWNER'}] }),
]); // ]);
}).spread(function (user, task) { // }).spread(function (user, task) {
expect(user.ASSIGNMENTS).to.be.ok; // expect(user.ASSIGNMENTS).to.be.ok;
expect(task.OWNER).to.be.ok; // expect(task.OWNER).to.be.ok;
}); // });
}); // });
it('should allow me to pass my own plural and singular forms to hasMany', function () { // it('should allow me to pass my own plural and singular forms to hasMany', function () {
var User = this.sequelize.define('user', {}) // var User = this.sequelize.define('user', {})
, Task = this.sequelize.define('task', {}); // , Task = this.sequelize.define('task', {});
User.hasMany(Task, { as: { singular: 'task', plural: 'taskz'} }); // User.hasMany(Task, { as: { singular: 'task', plural: 'taskz'} });
return this.sequelize.sync({ force: true }).then(function () { // return this.sequelize.sync({ force: true }).then(function () {
return User.create({ id: 1 }); // return User.create({ id: 1 });
}).then(function (user) { // }).then(function (user) {
expect(user.getTaskz).to.be.ok; // expect(user.getTaskz).to.be.ok;
expect(user.addTask).to.be.ok; // expect(user.addTask).to.be.ok;
expect(user.addTaskz).to.be.ok; // expect(user.addTaskz).to.be.ok;
}).then(function () { // }).then(function () {
return User.find({ where: { id: 1 }, include: [{model: Task, as: 'taskz'}] }); // return User.find({ where: { id: 1 }, include: [{model: Task, as: 'taskz'}] });
}).then(function (user) { // }).then(function (user) {
expect(user.taskz).to.be.ok; // expect(user.taskz).to.be.ok;
}); // });
}); // });
it('should allow me to define plural and singular forms on the model', function () { // it('should allow me to define plural and singular forms on the model', function () {
var User = this.sequelize.define('user', {}) // var User = this.sequelize.define('user', {})
, Task = this.sequelize.define('task', {}, { // , Task = this.sequelize.define('task', {}, {
name: { // name: {
singular: 'assignment', // singular: 'assignment',
plural: 'assignments' // plural: 'assignments'
} // }
}); // });
User.hasMany(Task); // User.hasMany(Task);
return this.sequelize.sync({ force: true }).then(function () { // return this.sequelize.sync({ force: true }).then(function () {
return User.create({ id: 1 }); // return User.create({ id: 1 });
}).then(function (user) { // }).then(function (user) {
expect(user.getAssignments).to.be.ok; // expect(user.getAssignments).to.be.ok;
expect(user.addAssignment).to.be.ok; // expect(user.addAssignment).to.be.ok;
expect(user.addAssignments).to.be.ok; // expect(user.addAssignments).to.be.ok;
}).then(function () { // }).then(function () {
return User.find({ where: { id: 1 }, include: [Task] }); // return User.find({ where: { id: 1 }, include: [Task] });
}).then(function (user) { // }).then(function (user) {
expect(user.assignments).to.be.ok; // expect(user.assignments).to.be.ok;
}); // });
}); // });
}); });
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!