orange-orm 3.10.2

package/src/table/readStream/extractLimit.js

@@ -0,0 +1,7 @@
+function extractLimit(span) {
+	if (span.limit)
+		return ' limit ' + span.limit;
+	return '';
+}
+
+module.exports = extractLimit;

package/src/table/readStream/extractOrderBy.js

@@ -0,0 +1,55 @@
+function extractOrderBy(alias, span) {
+	var table = span.table;
+	var dbNames = [];
+	var orderBy = span.orderBy;
+	var i;
+	if (span.orderBy) {
+		if (typeof orderBy === 'string')
+			orderBy = [orderBy];
+		for (i = 0; i < orderBy.length; i++) {
+			var nameAndDirection = extractNameAndDirection(orderBy[i]);
+			pushColumn(nameAndDirection.name, nameAndDirection.direction);
+		}
+	} else
+		for (i = 0; i < table._primaryColumns.length; i++) {
+			pushColumn(table._primaryColumns[i].alias);
+		}
+
+	function extractNameAndDirection(orderBy) {
+		var elements = orderBy.split(' ');
+		var direction = '';
+		if (elements.length > 1) {
+			direction = ' ' + elements[1];
+		}
+		return {
+			name: elements[0],
+			direction: direction
+		};
+	}
+
+	function pushColumn(property, direction) {
+		direction = direction || '';
+		var column = getTableColumn(property);
+		var jsonQuery = getJsonQuery(property, column.alias);
+
+		dbNames.push(alias + '.' + column._dbName + jsonQuery + direction);
+	}
+	function getTableColumn(property) {
+		var column = table[property] || table[property.split(/(-|#)>+/g)[0]];
+		if(!column){
+			throw new Error(`Unable to get column on orderBy '${property}'. If jsonb query, only #>, #>>, -> and ->> allowed. Only use ' ' to seperate between query and direction. Does currently not support casting.`);
+		}
+		return column;
+	}
+	function getJsonQuery(property, column) {
+		let containsJson = (/(-|#)>+/g).test(property);
+		if(!containsJson){
+			return '';
+		}
+		return property.replace(column, '');
+	}
+
+	return ' order by ' + dbNames.join(',');
+}
+
+module.exports = extractOrderBy;

package/src/table/readStream/mySql/newQuery.js

@@ -0,0 +1,16 @@
+var newSingleQuery = require('./query/newSingleQuery');
+var newSubQueries = require('./query/newSubQueries');
+var extractFilter = require('../../query/extractFilter');
+var extractOrderBy = require('../extractOrderBy');
+var extractLimit = require('../extractLimit');
+
+function newQuery(table,filter,span,alias) {
+	filter = extractFilter(filter);
+	var orderBy = extractOrderBy(alias,span);
+	var limit = extractLimit(span);
+
+	var subQueries = newSubQueries(table,span,alias);
+	return newSingleQuery(table,filter,alias,subQueries,orderBy,limit);
+}
+
+module.exports = newQuery;

package/src/table/readStream/mySql/query/newSingleQuery.js

@@ -0,0 +1,21 @@
+var newColumnSql = require('./singleQuery/newShallowColumnSql');
+var newWhereSql = require('../../../query/singleQuery/newWhereSql');
+var template = 'select json_object(%s%s) as result from %s %s%s%s%s';
+var util = require('util');
+
+function _new(table,filter,alias,subQueries,orderBy,limit) {
+	var c = {};
+
+	c.sql = function() {
+		var name = table._dbName;
+		var columnSql = newColumnSql(table,alias);
+		var whereSql = newWhereSql(table,filter,alias);
+		return util.format(template, columnSql, subQueries, name, alias, whereSql, orderBy, limit);
+	};
+
+	c.parameters = filter.parameters;
+
+	return c;
+}
+
+module.exports = _new;

package/src/table/readStream/mySql/query/newSubQueries/joinLegToQuery.js

@@ -0,0 +1,19 @@
+var newShallowJoinSql = require('../../../../query/singleQuery/joinSql/newShallowJoinSqlCore');
+var newQuery = require('./newQueryCore');
+var util = require('util');
+
+function joinLegToQuery(parentAlias,leg,legNo) {
+	var childAlias = parentAlias + 'x' + legNo;
+	var span = leg.span;
+	var childTable = span.table;
+	var parentTable = leg.table;
+	var childColumns = span.table._primaryColumns;
+	var parentColumns = leg.columns;
+
+	var shallowJoin  = newShallowJoinSql(parentTable,childColumns,parentColumns,childAlias,parentAlias);
+	var query = newQuery(childTable,span,childAlias);
+
+	return util.format(',\'%s\',(select %s from %s %s where %s)', leg.name, query.sql(), childTable._dbName, childAlias, shallowJoin);
+}
+
+module.exports = joinLegToQuery;

package/src/table/readStream/mySql/query/newSubQueries/manyLegToQuery.js

@@ -0,0 +1,22 @@
+var newShallowJoinSql = require('../../../../query/singleQuery/joinSql/newShallowJoinSqlCore');
+var extractOrderBy = require('../../../extractOrderBy');
+var newQuery = require('./newQueryCore');
+var util = require('util');
+
+function manyLegToQuery(rightAlias,leg,legNo) {
+	var leftAlias = rightAlias + 'x' + legNo;
+	var span = leg.span;
+	var rightTable = leg.table;
+	var rightColumns = rightTable._primaryColumns;
+	var leftColumns = leg.columns;
+	var orderBy = extractOrderBy(leftAlias, span);
+
+	var shallowJoin  = newShallowJoinSql(rightTable,leftColumns,rightColumns,leftAlias,rightAlias);
+	var query = newQuery(span.table,span,leftAlias);
+
+
+	return util.format(',\'%s\',(select cast(concat(\'[\',ifnull(group_concat(%s%s),\'\'),\']\') as json) from %s %s where %s)',
+		leg.name, query.sql(), orderBy, span.table._dbName, leftAlias, shallowJoin);
+}
+
+module.exports = manyLegToQuery;

package/src/table/readStream/mySql/query/newSubQueries/newQueryCore.js

@@ -0,0 +1,9 @@
+var newSingleQuery = require('./newSingleQueryCore');
+var newSubQueries = require('../newSubQueries');
+
+function newQueryCore(table,span,alias) {
+	var subQueries = newSubQueries(table,span,alias);
+	return newSingleQuery(table,alias,subQueries);
+}
+
+module.exports = newQueryCore;

package/src/table/readStream/mySql/query/newSubQueries/newSingleQueryCore.js

@@ -0,0 +1,18 @@
+var newColumnSql = require('../singleQuery/newShallowColumnSql');
+var template = 'json_object(%s%s)';
+var util = require('util');
+
+function _new(table,alias,subQueries) {
+	var c = {};
+
+	c.sql = function() {
+		var columnSql = newColumnSql(table,alias);
+		return util.format(template, columnSql, subQueries);
+	};
+
+	c.parameters = [];
+
+	return c;
+}
+
+module.exports = _new;

package/src/table/readStream/mySql/query/newSubQueries/oneLegToQuery.js

@@ -0,0 +1,22 @@
+var newShallowJoinSql = require('../../../../query/singleQuery/joinSql/newShallowJoinSqlCore');
+var newQuery = require('./newQueryCore');
+var extractOrderBy = require('../../../../query/extractOrderBy');
+var util = require('util');
+
+function manyLegToQuery(rightAlias,leg,legNo) {
+	var leftAlias = rightAlias + 'x' + legNo;
+	var span = leg.span;
+	var rightTable = leg.table;
+	var rightColumns = rightTable._primaryColumns;
+	var leftColumns = leg.columns;
+	var orderBy = extractOrderBy(rightTable,rightAlias);
+
+	var shallowJoin  = newShallowJoinSql(rightTable,leftColumns,rightColumns,leftAlias,rightAlias);
+	var query = newQuery(span.table,span,leftAlias);
+
+
+	return util.format(',\'%s\',(select %s from %s %s where %s%s LIMIT 1)',
+		leg.name, query.sql(), span.table._dbName, leftAlias, shallowJoin, orderBy);
+}
+
+module.exports = manyLegToQuery;

package/src/table/readStream/mySql/query/newSubQueries.js

@@ -0,0 +1,47 @@
+var joinLegToQuery = _joinLegToQuery;
+var oneLegToQuery = _oneLegToQuery;
+var manyLegToQuery = _manyLegToQuery;
+
+function newSubQueries(table,span,alias) {
+	var result = [];
+	var c = {};
+	var _legNo;
+
+	c.visitJoin = function(leg) {
+		result.push(joinLegToQuery( alias,leg,_legNo));
+	};
+	c.visitOne = function(leg) {
+		result.push(oneLegToQuery( alias,leg,_legNo));
+	};
+	c.visitMany = function(leg) {
+		result.push(manyLegToQuery( alias,leg,_legNo));
+	};
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg,legNo) {
+		_legNo = legNo;
+		leg.accept(c);
+	}
+
+	return result.join('');
+}
+
+function _joinLegToQuery() {
+	joinLegToQuery = require('./newSubQueries/joinLegToQuery');
+	return joinLegToQuery.apply(null,arguments);
+}
+
+function _oneLegToQuery() {
+	oneLegToQuery = require('./newSubQueries/oneLegToQuery');
+	return oneLegToQuery.apply(null,arguments);
+}
+
+function _manyLegToQuery() {
+	manyLegToQuery = require('./newSubQueries/manyLegToQuery');
+	return manyLegToQuery.apply(null,arguments);
+}
+
+
+
+module.exports = newSubQueries;

package/src/table/readStream/mySql/query/singleQuery/newShallowColumnSql.js

@@ -0,0 +1,17 @@
+var util = require('util');
+
+function _new(table,alias) {
+	var columnFormat = '\'%s\',%s.%s';
+	var columns = table._columns;
+	var sql = '';
+	var separator = '';
+	for (var i = 0; i < columns.length; i++) {
+		var column = columns[i];
+		if (!('serializable' in column && !column.serializable))
+			sql = sql + separator + util.format(columnFormat, column.alias, alias, column._dbName);
+		separator = ',';
+	}
+	return sql;
+}
+
+module.exports = _new;

package/src/table/readStream/newQuery.js

@@ -0,0 +1,32 @@
+var newMySqlQuery = require('./mySql/newQuery');
+var newPgQuery = require('./pg/newQuery');
+
+function newQuery(db) {
+	var c = {};
+	var _newQuery;
+
+	c.visitPg = function() {
+		_newQuery = newPgQuery;
+	};
+	c.visitMySql = function() {
+		_newQuery = newMySqlQuery;
+	};
+
+	c.visitSqlite = function() {
+		throw new Error('Sqlite not supported');
+	};
+
+	c.visitSap = function() {
+		throw new Error('Sap not supported');
+	};
+
+	db.accept(c);
+
+	var args = [];
+	for (var i = 1; i < arguments.length; i++) {
+		args.push(arguments[i]);
+	}
+	return _newQuery.apply(null, args);
+}
+
+module.exports = newQuery;

package/src/table/readStream/newQueryStream.js

@@ -0,0 +1,8 @@
+var getSessionSingleton = require('../getSessionSingleton');
+
+function newQueryStream(query, options) {
+	var dbClient = getSessionSingleton('dbClient');
+	return dbClient.streamQuery(query, options);
+}
+
+module.exports = newQueryStream;

package/src/table/readStream/pg/newQuery.js

@@ -0,0 +1,8 @@
+var newQueryCore = require('./newQueryCore');
+
+function newQuery() {
+	var query = newQueryCore.apply(null, arguments);
+	return query.prepend('select row_to_json(r)::text as result from (').append(') r');
+}
+
+module.exports = newQuery;

package/src/table/readStream/pg/newQueryCore.js

@@ -0,0 +1,17 @@
+var newSingleQuery = require('./query/newSingleQuery');
+var newSubQueries = require('./query/newSubQueries');
+var extractFilter = require('../../query/extractFilter');
+var extractOrderBy = require('../extractOrderBy');
+var extractLimit = require('../extractLimit');
+var newParameterized = require('../../query/newParameterized');
+
+function newQuery(table,filter,span,alias) {
+	filter = extractFilter(filter);
+	var orderBy = extractOrderBy(alias,span);
+	var limit = extractLimit(span);
+	var subQueries = newSubQueries(table,span,alias);
+	var query = newSingleQuery(table,filter,span,alias,subQueries,orderBy,limit);
+	return newParameterized(query.sql(), query.parameters);
+}
+
+module.exports = newQuery;

package/src/table/readStream/pg/query/newSingleQuery.js

@@ -0,0 +1,19 @@
+var newColumnSql = require('./singleQuery/newShallowColumnSql');
+var newWhereSql = require('../../../query/singleQuery/newWhereSql');
+
+function _new(table,filter,span, alias,subQueries,orderBy,limit) {
+	var c = {};
+
+	c.sql = function() {
+		var name = table._dbName;
+		var columnSql = newColumnSql(table,alias,span);
+		var whereSql = newWhereSql(table,filter,alias);
+		return 'select ' + columnSql + subQueries + ' from ' + name + ' ' + alias + whereSql + orderBy + limit;
+	};
+
+	c.parameters = filter.parameters;
+
+	return c;
+}
+
+module.exports = _new;

package/src/table/readStream/pg/query/newSubQueries/joinLegToQuery.js

@@ -0,0 +1,19 @@
+var newShallowJoinSql = require('../../../../query/singleQuery/joinSql/newShallowJoinSqlCore');
+var newQuery = require('../../newQueryCore');
+var newParameterized = require('../../../../query/newParameterized');
+var util = require('util');
+
+function joinLegToQuery(parentAlias,leg,legNo) {
+	var childAlias = parentAlias + 'x' + legNo;
+	var span = leg.span;
+	var parentTable = leg.table;
+	var childColumns = span.table._primaryColumns;
+	var parentColumns = leg.columns;
+
+	var shallowJoin  = newShallowJoinSql(parentTable,childColumns,parentColumns,childAlias,parentAlias);
+	var filter = newParameterized(shallowJoin);
+	var query = newQuery(span.table,filter,span,childAlias);
+	return util.format(',(select row_to_json(r) from (%s limit 1) r) "%s"', query.sql(), leg.name );
+}
+
+module.exports = joinLegToQuery;

package/src/table/readStream/pg/query/newSubQueries/manyLegToQuery.js

@@ -0,0 +1,22 @@
+var newShallowJoinSql = require('../../../../query/singleQuery/joinSql/newShallowJoinSqlCore');
+var newQuery = require('../../newQueryCore');
+var newParameterized = require('../../../../query/newParameterized');
+var extractOrderBy = require('../../../../query/extractOrderBy');
+var util = require('util');
+
+function manyLegToQuery(rightAlias, leg, legNo) {
+	var leftAlias = rightAlias + 'x' + legNo;
+	var span = leg.span;
+	var rightTable = leg.table;
+	var rightColumns = rightTable._primaryColumns;
+	var leftColumns = leg.columns;
+	var orderBy = extractOrderBy(rightTable, rightAlias);
+
+	var shallowJoin = newShallowJoinSql(rightTable, leftColumns, rightColumns, leftAlias, rightAlias);
+	var filter = newParameterized(shallowJoin);
+	var query = newQuery(span.table, filter, span, leftAlias, orderBy);
+	return util.format(',(select coalesce(json_agg(row_to_json(r)),\'[]\') from (%s) r ) "%s"', query.sql(), leg.name);
+
+}
+
+module.exports = manyLegToQuery;

package/src/table/readStream/pg/query/newSubQueries/oneLegToQuery.js

@@ -0,0 +1,19 @@
+var newShallowJoinSql = require('../../../../query/singleQuery/joinSql/newShallowJoinSqlCore');
+var newQuery = require('../../newQueryCore');
+var newParameterized = require('../../../../query/newParameterized');
+var util = require('util');
+
+function oneLegToQuery(rightAlias,leg,legNo) {
+	var leftAlias = rightAlias + 'x' + legNo;
+	var span = leg.span;
+	var rightTable = leg.table;
+	var rightColumns = rightTable._primaryColumns;
+	var leftColumns = leg.columns;
+
+	var shallowJoin  = newShallowJoinSql(rightTable,leftColumns,rightColumns,leftAlias,rightAlias);
+	var filter = newParameterized(shallowJoin);
+	var query = newQuery(span.table,filter,span,leftAlias);
+	return util.format(',(select row_to_json(r) from (%s limit 1) r) "%s"', query.sql(), leg.name );
+}
+
+module.exports = oneLegToQuery;

package/src/table/readStream/pg/query/newSubQueries.js

@@ -0,0 +1,47 @@
+var joinLegToQuery = _joinLegToQuery;
+var oneLegToQuery = _oneLegToQuery;
+var manyLegToQuery = _manyLegToQuery;
+
+function newSubQueries(table,span,alias) {
+	var result = [];
+	var c = {};
+	var _legNo;
+
+	c.visitJoin = function(leg) {
+		result.push(joinLegToQuery( alias,leg,_legNo));
+	};
+	c.visitOne = function(leg) {
+		result.push(oneLegToQuery( alias,leg,_legNo));
+	};
+	c.visitMany = function(leg) {
+		result.push(manyLegToQuery( alias,leg,_legNo));
+	};
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg,legNo) {
+		_legNo = legNo;
+		leg.accept(c);
+	}
+
+	return result.join('');
+}
+
+function _joinLegToQuery() {
+	joinLegToQuery = require('./newSubQueries/joinLegToQuery');
+	return joinLegToQuery.apply(null,arguments);
+}
+
+function _oneLegToQuery() {
+	oneLegToQuery = require('./newSubQueries/oneLegToQuery');
+	return oneLegToQuery.apply(null,arguments);
+}
+
+function _manyLegToQuery() {
+	manyLegToQuery = require('./newSubQueries/manyLegToQuery');
+	return manyLegToQuery.apply(null,arguments);
+}
+
+
+
+module.exports = newSubQueries;

package/src/table/readStream/pg/query/singleQuery/newShallowColumnSql.js

@@ -0,0 +1,19 @@
+var util = require('util');
+
+function _new(table,alias,span) {
+	let columnsMap = span.columns;
+	var columnFormat = '%s as "%s"';
+	var columns = table._columns;
+	var sql = '';
+	var separator = alias + '.';
+	for (var i = 0; i < columns.length; i++) {
+		var column = columns[i];
+		if (!('serializable' in column && !column.serializable) && (!columnsMap || (columnsMap.get(column)))) {
+			sql = sql + separator + util.format(columnFormat, column._dbName, column.alias);
+			separator = ',' + alias + '.';
+		}
+	}
+	return sql;
+}
+
+module.exports = _new;

package/src/table/readStreamDefault/createBatchFilter.js

@@ -0,0 +1,39 @@
+var emptyFilter = require('../../emptyFilter');
+
+function createBatchFilter(table, filter, strategy, lastDto) {
+	if (!lastDto) {
+		return filter;
+	}
+
+	var orderBy = strategy.orderBy;
+
+	for (var i = 0; i < strategy.orderBy.length; i++) {
+		var subFilter = createSubFilter(i);
+		filter = filter.or(subFilter);
+	}
+
+	function createSubFilter(index) {
+		var subFilter = emptyFilter;
+		for (var i = 0; i < index + 1; i++) {
+			var order = orderBy[i];
+			var elements = order.split(' ');
+			var name = elements[0];
+			var direction = elements[1] || 'asc';
+			var value = lastDto[name];
+			if (index === i) {
+				if (direction === 'asc')
+					subFilter = subFilter.and(table[name].greaterThan(value));
+				else
+					subFilter = subFilter.and(table[name].lessThan(value));
+			} else
+				subFilter = subFilter.and(table[name].eq(value));
+		}
+		return subFilter;
+	}
+
+	return filter;
+}
+
+
+
+module.exports = createBatchFilter;

package/src/table/relatedTable/aggregate/aggregateJoinSql.js

@@ -0,0 +1,37 @@
+var newShallowJoinSql = require('../../query/singleQuery/joinSql/newShallowJoinSqlCore');
+
+function newAggregateJoinSql(relations, prefix) {
+	let relation = relations[0];
+	var c = {};
+	var sql;
+
+	c.visitJoin = function(relation) {
+		var table = relation.childTable;
+		var alias = relation.parentTable._rootAlias || relation.parentTable._dbName;
+		var leftColumns = relation.columns;
+		var rightColumns = table._primaryColumns;
+		joinSql(alias, leftColumns, rightColumns);
+	};
+
+	c.visitOne = function(relation) {
+		var joinRelation = relation.joinRelation;
+		var rightColumns = joinRelation.columns;
+		var childTable = joinRelation.childTable;
+		var leftColumns = childTable._primaryColumns;
+		var alias = childTable._rootAlias || childTable._dbName;
+		joinSql(alias, leftColumns, rightColumns);
+	};
+
+	c.visitMany = c.visitOne;
+
+	function joinSql(alias, leftColumns, rightColumns) {
+		var table = relation.childTable;
+		var joinCore = newShallowJoinSql(table, leftColumns, rightColumns, alias, prefix + 1);
+		sql = joinCore;
+	}
+
+	relation.accept(c);
+	return sql;
+}
+
+module.exports = newAggregateJoinSql;

package/src/table/relatedTable/aggregate/joinSql.js

@@ -0,0 +1,38 @@
+var newShallowJoinSql = require('../../query/singleQuery/joinSql/newShallowJoinSql');
+
+function newJoinSql(relations, prefix) {
+	var leftAlias,
+		rightAlias;
+	var relation;
+	var c = {};
+	var sql = '';
+
+	c.visitJoin = function(relation) {
+		sql = newShallowJoinSql(relation.childTable,relation.columns,relation.parentTable._primaryColumns,leftAlias,rightAlias).prepend(' LEFT').prepend(sql);
+	};
+
+	c.visitOne = function(relation) {
+		innerJoin(relation);
+	};
+
+	c.visitMany = c.visitOne;
+
+	function innerJoin(relation) {
+		var joinRelation = relation.joinRelation;
+		var table = joinRelation.parentTable;
+		var leftColumns = table._primaryColumns;
+		var rightColumns = joinRelation.columns;
+
+		sql = newShallowJoinSql(table,leftColumns,rightColumns,leftAlias,rightAlias).prepend(' LEFT').prepend(sql);
+	}
+
+	for (let i = 0; i < relations.length; i++) {
+		leftAlias = i === 0 ? relations[i].parentTable._rootAlias || relations[i].parentTable._dbName: prefix + i;
+		rightAlias = prefix + i;
+		relation = relations[i];
+		relation.accept(c);
+	}
+	return sql;
+}
+
+module.exports = newJoinSql;

package/src/table/relatedTable/aggregate.js

@@ -0,0 +1,48 @@
+let newRelatedTable = _newRelatedTable;
+let tryGetSessionContext = require('../tryGetSessionContext');
+
+function newAggregate(_relations) {
+
+	function aggregate(fn) {
+		const includeMany = tryGetSessionContext()?.engine === 'mssql';
+		let { relations, alias } = extract(includeMany, _relations);
+		const table = relations[relations.length - 1].childTable;
+		if (!relations[0].isMany || includeMany)
+			table._rootAlias = alias;
+
+		try {
+			const query = fn(table);
+			delete table._rootAlias;
+			return query;
+		}
+		catch (e) {
+			delete table._rootAlias;
+			throw e;
+		}
+	}
+	return aggregate;
+
+	function extract(includeMany, relations) {
+		let alias = relations[0].toLeg().table._dbName;
+		let result = [];
+		for (let i = 0; i < relations.length; i++) {
+			if (relations[i].isMany && !includeMany) {
+				result = [relations[i]];
+				alias = relations[i].toLeg().table._dbName;
+			}
+			else {
+				result.push(relations[i]);
+				alias += relations[i].toLeg().name;
+			}
+		}
+		return { relations: result, alias };
+	}
+
+}
+
+function _newRelatedTable() {
+	newRelatedTable = require('../newRelatedTable');
+	return newRelatedTable.apply(null, arguments);
+}
+
+module.exports = newAggregate;