verdnatura-mirror
/
loopback-connector
mirror of https://github.com/loopbackio/loopback-connector.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add support native SQL join

This commit is contained in:
Nattaphat Laoharawee 2023-09-05 16:34:16 +07:00
parent 7cbb5e4640
commit d6a584d81e
4 changed files with 3615 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
lib/sql.js
View File

@ -1112,11 +1112,16 @@ SQLConnector.prototype._buildWhere = function(model, where) {
return new ParameterizedSQL('');
}
const self = this;
const props = self.getModelDefinition(model).properties;
const modelDef = self.getModelDefinition(model);
const props = modelDef.properties;
const relations = modelDef.model.relations;
const whereStmts = [];
for (const key in where) {
const stmt = new ParameterizedSQL('', []);
if (relations && key in relations) {
// relationships are handled on joins
continue;
}
// Handle and/or operators
if (key === 'and' || key === 'or') {
const branches = [];
@ -1239,10 +1244,24 @@ SQLConnector.prototype.buildOrderBy = function(model, order) {
const clauses = [];
for (let i = 0, n = order.length; i < n; i++) {
const t = order[i].split(/[\s,]+/);
if (t.length === 1) {
clauses.push(self.columnEscaped(model, order[i]));
let colName;
if (t[0].indexOf('.') < 0) {
colName = self.columnEscaped(model, t[0]);
} else {
clauses.push(self.columnEscaped(model, t[0]) + ' ' + t[1]);
// Column name is in the format: relationName.columnName
const colSplit = t[0].split('.');
// Find the name of the relation's model ...
const modelDef = this.getModelDefinition(model);
const relation = modelDef.model.relations[colSplit[0]];
const colModel = relation.modelTo.definition.name;
// ... and escape them
colName = self.columnEscaped(colModel, colSplit[1]);
}
if (t.length === 1) {
clauses.push(colName);
} else {
clauses.push(colName + ' ' + t[1]);
}
}
return 'ORDER BY ' + clauses.join(',');
@ -1432,6 +1451,7 @@ SQLConnector.prototype.buildColumnNames = function(model, filter) {
* @returns {ParameterizedSQL} Statement object {sql: ..., params: ...}
*/
SQLConnector.prototype.buildSelect = function(model, filter, options) {
options = options || {};
if (!filter.order) {
const idNames = this.idNames(model);
if (idNames && idNames.length) {
@ -1439,10 +1459,16 @@ SQLConnector.prototype.buildSelect = function(model, filter, options) {
}
}
let selectStmt = new ParameterizedSQL('SELECT ' +
const haveRelationFilters = this.hasRelationClause(model, filter.where);
const distinct = haveRelationFilters ? 'DISTINCT ' : '';
let selectStmt = new ParameterizedSQL('SELECT ' + distinct +
this.buildColumnNames(model, filter) +
' FROM ' + this.tableEscaped(model));
if (haveRelationFilters) {
const joinsStmts = this.buildJoins(model, filter.where);
selectStmt.merge(joinsStmts);
}
if (filter) {
if (filter.where) {
const whereStmt = this.buildWhere(model, filter.where);
@ -1459,6 +1485,9 @@ SQLConnector.prototype.buildSelect = function(model, filter, options) {
);
}
}
if (options.skipParameterize === true) {
return selectStmt;
}
return this.parameterize(selectStmt);
};
@ -1582,10 +1611,7 @@ SQLConnector.prototype.count = function(model, where, options, cb) {
where = tmp;
}
let stmt = new ParameterizedSQL('SELECT count(*) as "cnt" FROM ' +
this.tableEscaped(model));
stmt = stmt.merge(this.buildWhere(model, where));
stmt = this.parameterize(stmt);
const stmt = this.buildCount(model, where, options);
this.execute(stmt.sql, stmt.params, options,
function(err, res) {
if (err) {
@ -2143,3 +2169,133 @@ SQLConnector.prototype.setNullableProperty = function(property) {
throw new Error(g.f('{{setNullableProperty}} must be implemented by' +
'the connector'));
};
/**
* Get the escaped qualified column name (table.column for join)
* @param {String} model The model name
* @param {String} property The property name
* @returns {String} The escaped column name
*/
SQLConnector.prototype.qualifiedColumnEscaped = function(model, property) {
let table = this.tableEscaped(model);
const index = table.indexOf('.');
if (index !== -1) {
// Remove the schema name
table = table.substring(index);
}
return table + '.' + this.escapeName(this.column(model, property));
};
/**
* Build the SQL INNER JOIN clauses
* @param {string} model Model name
* @param {object} where An object for the where conditions
* @returns {ParameterizedSQL} The SQL INNER JOIN clauses
*/
SQLConnector.prototype.buildJoins = function(model, where) {
const modelDef = this.getModelDefinition(model);
const relations = modelDef.model.relations;
const stmt = new ParameterizedSQL('', []);
const self = this;
const buildOneToMany = function buildOneToMany(
modelFrom, keyFrom, modelTo, keyTo, filter,
) {
const ds1 = self.getDataSource(modelFrom);
const ds2 = self.getDataSource(modelTo);
assert(ds1 === ds2, 'Model ' + modelFrom + ' and ' + modelTo +
' must be attached to the same datasource');
const modelToEscaped = self.tableEscaped(modelTo);
const innerFilter = Object.assign({}, filter);
const innerIdField = {};
innerIdField[keyTo] = true;
innerFilter.fields = Object.assign({}, innerFilter.fields, innerIdField);
const condition = self.qualifiedColumnEscaped(modelFrom, keyFrom) + '=' +
self.qualifiedColumnEscaped(modelTo, keyTo);
const innerSelect = self.buildSelect(modelTo, innerFilter, {
skipParameterize: true,
});
return new ParameterizedSQL('INNER JOIN (', [])
.merge(innerSelect)
.merge(') AS ' + modelToEscaped)
.merge('ON ' + condition);
};
for (const key in where) {
if (!(key in relations)) continue;
const rel = relations[key];
const keyFrom = rel.keyFrom;
const modelTo = rel.modelTo.definition.name;
const keyTo = rel.keyTo;
let join;
if (!rel.modelThrough) {
// 1:n relation
join = buildOneToMany(model, keyFrom, modelTo, keyTo, where[key]);
} else {
// n:m relation
const modelThrough = rel.modelThrough.definition.name;
const keyThrough = rel.keyThrough;
const modelToKey = rel.modelTo.definition.idName();
const innerFilter = {fields: {}};
innerFilter.fields[keyThrough] = true;
const joinInner = buildOneToMany(model, keyFrom, modelThrough, keyTo, innerFilter);
join = buildOneToMany(modelThrough, keyThrough, modelTo, modelToKey, where[key]);
join = joinInner.merge(join);
}
stmt.merge(join);
}
return stmt;
};
/**
* Check if the where statement contains relations
* @param model
* @param where
* @returns {boolean}
*/
SQLConnector.prototype.hasRelationClause = function(model, where) {
let found = false;
if (where) {
const relations = this.getModelDefinition(model).model.relations;
if (relations) {
for (const key in where) {
if (key in relations) {
found = true;
break;
}
}
}
}
return found;
};
/**
* Build a SQL SELECT statement to count rows
* @param {String} model Model name
* @param {Object} where Where object
* @param {Object} options Options object
* @returns {ParameterizedSQL} Statement object {sql: ..., params: [...]}
*/
SQLConnector.prototype.buildCount = function(model, where, options) {
const haveRelationFilters = this.hasRelationClause(model, where);
let count = 'count(*)';
if (haveRelationFilters) {
const idColumn = this.columnEscaped(model, this.idColumn(model));
count = 'count(DISTINCT ' + idColumn + ')';
}
let stmt = new ParameterizedSQL('SELECT ' + count +
' as "cnt" FROM ' + this.tableEscaped(model));
if (haveRelationFilters) {
const joinsStmts = this.buildJoins(model, where);
stmt = stmt.merge(joinsStmts);
}
stmt = stmt.merge(this.buildWhere(model, where));
return this.parameterize(stmt);
};

2
package.json
View File

@ -21,7 +21,7 @@
"lint:fix": "eslint . --fix",
"posttest": "npm run lint",
"test": "npm run test:ci",
"test:ci": "nyc --reporter=lcov mocha"
"test:ci": "nyc --reporter=lcov mocha --debug-brk"
},
"license": "MIT",
"dependencies": {

140
test/sql.test.js
View File

@ -18,6 +18,7 @@ const ds = new juggler.DataSource({
let connector;
let Customer;
let Order;
let Store;
/* eslint-enable one-var */
describe('sql connector', function() {
@ -82,9 +83,31 @@ describe('sql connector', function() {
testdb: {
column: 'description',
},
}, date: {
type: Date,
},
},
{testdb: {table: 'ORDER'}});
Store = ds.createModel('store',
{
id: {
id: true,
type: String,
},
state: String,
});
Customer.hasMany(Order, {as: 'orders', foreignKey: 'customer_name'});
Order.belongsTo(Customer, {as: 'customer', foreignKey: 'customer_name'});
Order.belongsTo(Store, {as: 'store', foreignKey: 'store_id'});
Store.hasMany(Order, {as: 'orders', foreignKey: 'store_id'});
Store.hasMany(Customer, {
as: 'customers',
through: Order,
foreignKey: 'store_id',
keyThrough: 'customer_name',
});
Customer.belongsTo(Store, {as: 'favorite_store', foreignKey: 'favorite_store'});
Store.hasMany(Customer, {as: 'customers_fav', foreignKey: 'favorite_store'});
});
// tests for column names mapping are moved to name-mapping.test.js
@ -328,7 +351,7 @@ describe('sql connector', function() {
it('builds column names for SELECT', function() {
const cols = connector.buildColumnNames('customer');
expect(cols).to.eql('`NAME`,`middle_name`,`LASTNAME`,`VIP`,' +
'`primary_address`,`TOKEN`,`ADDRESS`');
'`primary_address`,`TOKEN`,`ADDRESS`,`FAVORITE_STORE`');
});
it('builds column names with true fields filter for SELECT', function() {
@ -346,7 +369,7 @@ describe('sql connector', function() {
middleName: false,
},
});
expect(cols).to.eql('`VIP`,`ADDRESS`');
expect(cols).to.eql('`VIP`,`ADDRESS`,`FAVORITE_STORE`');
});
it('builds column names with array fields filter for SELECT', function() {
@ -379,7 +402,8 @@ describe('sql connector', function() {
expect(sql.toJSON()).to.eql({
sql:
'SELECT `NAME`,`middle_name`,`LASTNAME`,`VIP`,`primary_address`,' +
'`TOKEN`,`ADDRESS` FROM `CUSTOMER` WHERE ((`NAME`=$1) OR (`ADDRESS`=$2)) ' +
'`TOKEN`,`ADDRESS`,`FAVORITE_STORE` ' +
'FROM `CUSTOMER` WHERE ((`NAME`=$1) OR (`ADDRESS`=$2)) ' +
'AND `VIP`=$3 ORDER BY `NAME` LIMIT 5',
params: ['Top Cat', 'Trash can', true],
});
@ -390,7 +414,7 @@ describe('sql connector', function() {
{order: 'name', limit: 5, where: {name: 'John'}});
expect(sql.toJSON()).to.eql({
sql: 'SELECT `NAME`,`middle_name`,`LASTNAME`,`VIP`,`primary_address`,`TOKEN`,' +
'`ADDRESS` FROM `CUSTOMER`' +
'`ADDRESS`,`FAVORITE_STORE` FROM `CUSTOMER`' +
' WHERE `NAME`=$1 ORDER BY `NAME` LIMIT 5',
params: ['John'],
});
@ -565,6 +589,56 @@ describe('sql connector', function() {
// eslint-disable-next-line no-unused-expressions
expect(sql).to.be.null;
});
it('builds INNER JOIN', function() {
const sql = connector.buildJoins('customer', {orders: {where: {id: 10}}});
expect(sql.toJSON()).to.eql({
sql: 'INNER JOIN ( SELECT `CUSTOMER_NAME` FROM `ORDER` WHERE ' +
'`orderId`=? ORDER BY `orderId` ) AS `ORDER` ON ' +
'`CUSTOMER`.`NAME`=`ORDER`.`CUSTOMER_NAME`',
params: [10],
});
});
it('builds SELECT with INNER JOIN (1:n relation)', function() {
const sql = connector.buildSelect('customer', {
where: {
orders: {
where: {
date: {between: ['2015-01-01', '2015-01-31']},
},
},
},
});
expect(sql.toJSON()).to.eql({
sql: 'SELECT DISTINCT `NAME`,`middle_name`,`LASTNAME`,`VIP`,' +
'`primary_address`,`TOKEN`,`ADDRESS`,`FAVORITE_STORE` FROM `CUSTOMER` ' +
'INNER JOIN ( SELECT `CUSTOMER_NAME` FROM `ORDER` WHERE ' +
'`DATE` BETWEEN $1 AND $2 ORDER BY `orderId` ) AS `ORDER` ' +
'ON `CUSTOMER`.`NAME`=`ORDER`.`CUSTOMER_NAME` ORDER BY `NAME`',
params: ['2015-01-01', '2015-01-31'],
});
});
it('builds SELECT with INNER JOIN (n:n relation)', function() {
const sql = connector.buildSelect('store', {
where: {
customers: {
where: {
vip: true,
},
},
},
});
expect(sql.toJSON()).to.eql({
sql: 'SELECT DISTINCT `ID`,`STATE` FROM `STORE` INNER JOIN' +
' ( SELECT `CUSTOMER_NAME`,`STORE_ID` FROM `ORDER` ' +
'ORDER BY `orderId` ) AS `ORDER` ON `STORE`.`ID`=`ORDER`.`STORE_ID` ' +
'INNER JOIN ( SELECT `NAME` FROM `CUSTOMER` WHERE ' +
'`VIP`=$1 ORDER BY `NAME` ) AS `CUSTOMER` ON ' +
'`ORDER`.`CUSTOMER_NAME`=`CUSTOMER`.`NAME` ORDER BY `ID`',
params: [true],
});
});
context('when multiInsertSupported is true', function() {
beforeEach(function() {
@ -583,6 +657,64 @@ describe('sql connector', function() {
params: ['Adam', 'abc', true, 'Test', null, false],
});
});
it('builds nested SELECTs', function() {
const sql = connector.buildSelect('customer', {
where: {
orders: {
where: {
store: {
where: {
state: 'NY',
},
},
},
},
},
});
expect(sql.toJSON()).to.eql({
sql: 'SELECT DISTINCT `NAME`,`middle_name`,`LASTNAME`,`VIP`,`primary_address`,' +
'`TOKEN`,`ADDRESS`,`FAVORITE_STORE` FROM `CUSTOMER` ' +
'INNER JOIN ( SELECT DISTINCT `CUSTOMER_NAME` FROM `ORDER` ' +
'INNER JOIN ( SELECT `ID` FROM `STORE` WHERE `STATE`=$1 ' +
'ORDER BY `ID` ) AS `STORE` ON `ORDER`.`STORE_ID`=`STORE`.`ID` ' +
'ORDER BY `orderId` ) AS `ORDER` ON `CUSTOMER`.`NAME`=`ORDER`.' +
'`CUSTOMER_NAME` ORDER BY `NAME`',
params: ['NY'],
});
});
it('builds count', function() {
const sql = connector.buildCount('customer');
expect(sql.toJSON()).to.eql({
sql: 'SELECT count(*) as "cnt" FROM `CUSTOMER` ',
params: [],
});
});
it('builds count with WHERE', function() {
const sql = connector.buildCount('customer', {name: 'John'});
expect(sql.toJSON()).to.eql({
sql: 'SELECT count(*) as "cnt" FROM `CUSTOMER` WHERE `NAME`=$1',
params: ['John'],
});
});
it('builds count with WHERE and JOIN', function() {
const sql = connector.buildCount('customer', {
name: 'John',
orders: {
where: {
date: {between: ['2015-01-01', '2015-01-31']},
},
},
});
expect(sql.toJSON()).to.eql({
sql: 'SELECT count(DISTINCT `NAME`) as "cnt" FROM `CUSTOMER` ' +
'INNER JOIN ( SELECT `CUSTOMER_NAME` FROM `ORDER` WHERE ' +
'`DATE` BETWEEN $1 AND $2 ORDER BY `orderId` ) AS `ORDER` ' +
'ON `CUSTOMER`.`NAME`=`ORDER`.`CUSTOMER_NAME` WHERE `NAME`=$3',
params: ['2015-01-01', '2015-01-31', 'John'],
});
});
context('getInsertedDataArray', function() {
context('when id column is auto-generated', function() {

3311
yarn.lock Normal file
View File

File diff suppressed because it is too large Load Diff