Skip to content

public / sequelize

Go to a project

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

Commit 4383922a by Ali Taheri Moghaddar Committed by Felix Becker
Options

feat(dependency): Support pg version 7 (#7888)

1 parent 85ee83d9
Inline Side-by-side
Showing with 179 additions and 194 deletions
docs/usage.md
...@@ -201,7 +201,7 @@ const sequelize = new Sequelize('sqlite:relativePath/dbname.db') ...@@ -201,7 +201,7 @@ const sequelize = new Sequelize('sqlite:relativePath/dbname.db')
### PostgreSQL ### PostgreSQL
The library for PostgreSQL is`pg@~3.6.0` You'll just need to define the dialect: The library for PostgreSQL is`pg@^5.0.0 || ^6.0.0 || ^7.0.0` You'll just need to define the dialect:
```js ```js
const sequelize = new Sequelize('database', 'username', 'password', { const sequelize = new Sequelize('database', 'username', 'password', {
......
lib/dialects/postgres/connection-manager.js
...@@ -153,25 +153,22 @@ class ConnectionManager extends AbstractConnectionManager { ...@@ -153,25 +153,22 @@ class ConnectionManager extends AbstractConnectionManager {
query += 'SELECT typname, oid, typarray FROM pg_type WHERE typtype = \'b\' AND typname IN (\'hstore\', \'geometry\', \'geography\')'; query += 'SELECT typname, oid, typarray FROM pg_type WHERE typtype = \'b\' AND typname IN (\'hstore\', \'geometry\', \'geography\')';
} }
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => connection.query(query, (error, result) => error ? reject(error) : resolve(result))).then(result => {
connection.query(query) for (const row of result.rows) {
.on('error', err => reject(err)) let type;
.on('row', row => { if (row.typname === 'geometry') {
let type; type = dataTypes.postgres.GEOMETRY;
if (row.typname === 'geometry') { } else if (row.typname === 'hstore') {
type = dataTypes.postgres.GEOMETRY; type = dataTypes.postgres.HSTORE;
} else if (row.typname === 'hstore') { } else if (row.typname === 'geography') {
type = dataTypes.postgres.HSTORE; type = dataTypes.postgres.GEOGRAPHY;
} else if (row.typname === 'geography') { }
type = dataTypes.postgres.GEOGRAPHY;
}
type.types.postgres.oids.push(row.oid); type.types.postgres.oids.push(row.oid);
type.types.postgres.array_oids.push(row.typarray); type.types.postgres.array_oids.push(row.typarray);
this._refreshTypeParser(type); this._refreshTypeParser(type);
}) }
.on('end', () => resolve());
}); });
}); });
} }
......
lib/dialects/postgres/query.js
...@@ -60,9 +60,9 @@ class Query extends AbstractQuery { ...@@ -60,9 +60,9 @@ class Query extends AbstractQuery {
this.sql = this.sequelize.queryInterface.QueryGenerator.setSearchPath(this.options.searchPath) + sql; this.sql = this.sequelize.queryInterface.QueryGenerator.setSearchPath(this.options.searchPath) + sql;
} }
const query = parameters && parameters.length ? this.client.query(this.sql, parameters) : this.client.query(this.sql); const query = parameters && parameters.length
const rows = []; ? new Promise((resolve, reject) => this.client.query(this.sql, parameters, (error, result) => error ? reject(error) : resolve(result)))
let receivedError = false; : new Promise((resolve, reject) => this.client.query(this.sql, (error, result) => error ? reject(error) : resolve(result)));
//do we need benchmark for this query execution //do we need benchmark for this query execution
const benchmark = this.sequelize.options.benchmark || this.options.benchmark; const benchmark = this.sequelize.options.benchmark || this.options.benchmark;
...@@ -76,207 +76,195 @@ class Query extends AbstractQuery { ...@@ -76,207 +76,195 @@ class Query extends AbstractQuery {
debug(`executing(${this.client.uuid || 'default'}) : ${this.sql}`); debug(`executing(${this.client.uuid || 'default'}) : ${this.sql}`);
return new Promise((resolve, reject) => { return query.catch(err => {
query.on('row', row => { // set the client so that it will be reaped if the connection resets while executing
rows.push(row); if (err.code === 'ECONNRESET') {
}); this.client._invalid = true;
}
query.on('error', err => {
// set the client so that it will be reaped if the connection resets while executing
if (err.code === 'ECONNRESET') {
this.client._invalid = true;
}
receivedError = true;
err.sql = sql;
reject(this.formatError(err));
});
query.on('end', result => {
err.sql = sql;
throw this.formatError(err);
})
.then(queryResult => {
debug(`executed(${this.client.uuid || 'default'}) : ${this.sql}`); debug(`executed(${this.client.uuid || 'default'}) : ${this.sql}`);
if (benchmark) { if (benchmark) {
this.sequelize.log('Executed (' + (this.client.uuid || 'default') + '): ' + this.sql, Date.now() - queryBegin, this.options); this.sequelize.log('Executed (' + (this.client.uuid || 'default') + '): ' + this.sql, Date.now() - queryBegin, this.options);
} }
if (receivedError) { return queryResult;
return; })
.then(queryResult => {
const rows = queryResult.rows;
const rowCount = queryResult.rowCount;
const isTableNameQuery = sql.indexOf('SELECT table_name FROM information_schema.tables') === 0;
const isRelNameQuery = sql.indexOf('SELECT relname FROM pg_class WHERE oid IN') === 0;
if (isRelNameQuery) {
return rows.map(row => ({
name: row.relname,
tableName: row.relname.split('_')[0]
}));
} else if (isTableNameQuery) {
return rows.map(row => _.values(row));
} }
resolve([rows, sql, result]); if (rows[0] && rows[0].sequelize_caught_exception !== undefined) {
}); if (rows[0].sequelize_caught_exception !== null) {
}).spread((rows, sql, result) => { throw this.formatError({
const results = rows; code: '23505',
const isTableNameQuery = sql.indexOf('SELECT table_name FROM information_schema.tables') === 0; detail: rows[0].sequelize_caught_exception
const isRelNameQuery = sql.indexOf('SELECT relname FROM pg_class WHERE oid IN') === 0; });
} else {
if (isRelNameQuery) { for (const row of rows) {
return rows.map(row => ({ delete row.sequelize_caught_exception;
name: row.relname,
tableName: row.relname.split('_')[0]
}));
} else if (isTableNameQuery) {
return rows.map(row => _.values(row));
}
if (rows[0] && rows[0].sequelize_caught_exception !== undefined) {
if (rows[0].sequelize_caught_exception !== null) {
throw this.formatError({
code: '23505',
detail: rows[0].sequelize_caught_exception
});
} else {
rows = rows.map(row => {
delete row.sequelize_caught_exception;
return row;
});
}
}
if (this.isShowIndexesQuery()) {
for (const result of results) {
const attributes = /ON .*? (?:USING .*?\s)?\(([^]*)\)/gi.exec(result.definition)[1].split(',');
// Map column index in table to column name
const columns = _.zipObject(
result.column_indexes,
this.sequelize.queryInterface.QueryGenerator.fromArray(result.column_names)
);
delete result.column_indexes;
delete result.column_names;
let field;
let attribute;
// Indkey is the order of attributes in the index, specified by a string of attribute indexes
result.fields = result.indkey.split(' ').map((indKey, index) => {
field = columns[indKey];
// for functional indices indKey = 0
if (!field) {
return null;
} }
attribute = attributes[index]; }
return {
attribute: field,
collate: attribute.match(/COLLATE "(.*?)"/) ? /COLLATE "(.*?)"/.exec(attribute)[1] : undefined,
order: attribute.indexOf('DESC') !== -1 ? 'DESC' : attribute.indexOf('ASC') !== -1 ? 'ASC': undefined,
length: undefined
};
}).filter(n => n !== null);
delete result.columns;
} }
return results;
} else if (this.isForeignKeysQuery()) { if (this.isShowIndexesQuery()) {
result = []; for (const row of rows) {
for (const row of rows) { const attributes = /ON .*? (?:USING .*?\s)?\(([^]*)\)/gi.exec(row.definition)[1].split(',');
let defParts;
if (row.condef !== undefined && (defParts = row.condef.match(/FOREIGN KEY \((.+)\) REFERENCES (.+)\((.+)\)( ON (UPDATE|DELETE) (CASCADE|RESTRICT))?( ON (UPDATE|DELETE) (CASCADE|RESTRICT))?/))) { // Map column index in table to column name
row.id = row.constraint_name; const columns = _.zipObject(
row.table = defParts[2]; row.column_indexes,
row.from = defParts[1]; this.sequelize.queryInterface.QueryGenerator.fromArray(row.column_names)
row.to = defParts[3]; );
let i; delete row.column_indexes;
for (i=5;i<=8;i+=3) { delete row.column_names;
if (/(UPDATE|DELETE)/.test(defParts[i])) {
row['on_'+defParts[i].toLowerCase()] = defParts[i+1]; let field;
let attribute;
// Indkey is the order of attributes in the index, specified by a string of attribute indexes
row.fields = row.indkey.split(' ').map((indKey, index) => {
field = columns[indKey];
// for functional indices indKey = 0
if (!field) {
return null;
} }
} attribute = attributes[index];
return {
attribute: field,
collate: attribute.match(/COLLATE "(.*?)"/) ? /COLLATE "(.*?)"/.exec(attribute)[1] : undefined,
order: attribute.indexOf('DESC') !== -1 ? 'DESC' : attribute.indexOf('ASC') !== -1 ? 'ASC': undefined,
length: undefined
};
}).filter(n => n !== null);
delete row.columns;
} }
result.push(row); return rows;
} } else if (this.isForeignKeysQuery()) {
return result; const result = [];
} else if (this.isSelectQuery()) { for (const row of rows) {
// Postgres will treat tables as case-insensitive, so fix the case let defParts;
// of the returned values to match attributes if (row.condef !== undefined && (defParts = row.condef.match(/FOREIGN KEY \((.+)\) REFERENCES (.+)\((.+)\)( ON (UPDATE|DELETE) (CASCADE|RESTRICT))?( ON (UPDATE|DELETE) (CASCADE|RESTRICT))?/))) {
if (this.options.raw === false && this.sequelize.options.quoteIdentifiers === false) { row.id = row.constraint_name;
const attrsMap = _.reduce(this.model.attributes, (m, v, k) => { row.table = defParts[2];
m[k.toLowerCase()] = k; row.from = defParts[1];
return m; row.to = defParts[3];
}, {}); let i;
rows = _.map(rows, row=> { for (i=5;i<=8;i+=3) {
return _.mapKeys(row, (value, key)=> { if (/(UPDATE|DELETE)/.test(defParts[i])) {
const targetAttr = attrsMap[key]; row['on_'+defParts[i].toLowerCase()] = defParts[i+1];
if (typeof targetAttr === 'string' && targetAttr !== key) { }
return targetAttr;
} else {
return key;
} }
});
});
}
return this.handleSelectQuery(rows);
} else if (QueryTypes.DESCRIBE === this.options.type) {
result = {};
for (const _result of rows) {
result[_result.Field] = {
type: _result.Type.toUpperCase(),
allowNull: _result.Null === 'YES',
defaultValue: _result.Default,
special: _result.special ? this.sequelize.queryInterface.QueryGenerator.fromArray(_result.special) : [],
primaryKey: _result.Constraint === 'PRIMARY KEY'
};
if (result[_result.Field].type === 'BOOLEAN') {
result[_result.Field].defaultValue = { 'false': false, 'true': true }[result[_result.Field].defaultValue];
if (result[_result.Field].defaultValue === undefined) {
result[_result.Field].defaultValue = null;
} }
result.push(row);
} }
return result;
} else if (this.isSelectQuery()) {
let result = rows;
// Postgres will treat tables as case-insensitive, so fix the case
// of the returned values to match attributes
if (this.options.raw === false && this.sequelize.options.quoteIdentifiers === false) {
const attrsMap = _.reduce(this.model.attributes, (m, v, k) => {
m[k.toLowerCase()] = k;
return m;
}, {});
result = _.map(rows, row=> {
return _.mapKeys(row, (value, key)=> {
const targetAttr = attrsMap[key];
if (typeof targetAttr === 'string' && targetAttr !== key) {
return targetAttr;
} else {
return key;
}
});
});
}
return this.handleSelectQuery(result);
} else if (QueryTypes.DESCRIBE === this.options.type) {
const result = {};
for (const row of rows) {
result[row.Field] = {
type: row.Type.toUpperCase(),
allowNull: row.Null === 'YES',
defaultValue: row.Default,
special: row.special ? this.sequelize.queryInterface.QueryGenerator.fromArray(row.special) : [],
primaryKey: row.Constraint === 'PRIMARY KEY'
};
if (typeof result[_result.Field].defaultValue === 'string') { if (result[row.Field].type === 'BOOLEAN') {
result[_result.Field].defaultValue = result[_result.Field].defaultValue.replace(/'/g, ''); result[row.Field].defaultValue = { 'false': false, 'true': true }[result[row.Field].defaultValue];
if (result[_result.Field].defaultValue.indexOf('::') > -1) { if (result[row.Field].defaultValue === undefined) {
const split = result[_result.Field].defaultValue.split('::'); result[row.Field].defaultValue = null;
if (split[1].toLowerCase() !== 'regclass)') { }
result[_result.Field].defaultValue = split[0]; }
if (typeof result[row.Field].defaultValue === 'string') {
result[row.Field].defaultValue = result[row.Field].defaultValue.replace(/'/g, '');
if (result[row.Field].defaultValue.indexOf('::') > -1) {
const split = result[row.Field].defaultValue.split('::');
if (split[1].toLowerCase() !== 'regclass)') {
result[row.Field].defaultValue = split[0];
}
} }
} }
} }
}
return result; return result;
} else if (this.isVersionQuery()) { } else if (this.isVersionQuery()) {
return results[0].server_version; return rows[0].server_version;
} else if (this.isShowOrDescribeQuery()) { } else if (this.isShowOrDescribeQuery()) {
return results; return rows;
} else if (QueryTypes.BULKUPDATE === this.options.type) { } else if (QueryTypes.BULKUPDATE === this.options.type) {
if (!this.options.returning) { if (!this.options.returning) {
return parseInt(result.rowCount, 10); return parseInt(rowCount, 10);
} }
return this.handleSelectQuery(rows); return this.handleSelectQuery(rows);
} else if (QueryTypes.BULKDELETE === this.options.type) { } else if (QueryTypes.BULKDELETE === this.options.type) {
return parseInt(result.rowCount, 10); return parseInt(rowCount, 10);
} else if (this.isUpsertQuery()) { } else if (this.isUpsertQuery()) {
return rows[0].sequelize_upsert; return rows[0].sequelize_upsert;
} else if (this.isInsertQuery() || this.isUpdateQuery()) { } else if (this.isInsertQuery() || this.isUpdateQuery()) {
if (this.instance && this.instance.dataValues) { if (this.instance && this.instance.dataValues) {
for (const key in rows[0]) { for (const key in rows[0]) {
if (rows[0].hasOwnProperty(key)) { if (rows[0].hasOwnProperty(key)) {
const record = rows[0][key]; const record = rows[0][key];
const attr = _.find(this.model.rawAttributes, attribute => attribute.fieldName === key || attribute.field === key); const attr = _.find(this.model.rawAttributes, attribute => attribute.fieldName === key || attribute.field === key);
this.instance.dataValues[attr && attr.fieldName || key] = record; this.instance.dataValues[attr && attr.fieldName || key] = record;
}
} }
} }
}
return [ return [
this.instance || rows && (this.options.plain && rows[0] || rows) || undefined, this.instance || rows && (this.options.plain && rows[0] || rows) || undefined,
result.rowCount rowCount
]; ];
} else if (this.isRawQuery()) { } else if (this.isRawQuery()) {
return [rows, result]; return [rows, queryResult];
} else { } else {
return results; return rows;
} }
}); });
} }
formatError(err) { formatError(err) {
......
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!