orange-orm 3.10.2

package/src/table/relatedTable/all.js

@@ -0,0 +1,24 @@
+let newRelatedTable = _newRelatedTable;
+const negotiateRawSqlFilter = require('../column/negotiateRawSqlFilter');
+let subFilter = require('./subFilter');
+let isShallow = true;
+
+function newAll(relations, depth) {
+
+	function all(fn) {
+		let relatedTable = newRelatedTable(relations, isShallow, depth + 1);
+		let arg = typeof fn === 'function' ? fn(relatedTable) : fn;
+		let anyFilter = negotiateRawSqlFilter(arg);
+		let anySubFilter = subFilter(relations, anyFilter, depth);
+		let notFilter = subFilter(relations, anyFilter.not(), depth).not();
+		return anySubFilter.and(notFilter);
+	}
+	return all;
+}
+
+function _newRelatedTable() {
+	newRelatedTable = require('../newRelatedTable');
+	return newRelatedTable.apply(null, arguments);
+}
+
+module.exports = newAll;

package/src/table/relatedTable/any.js

@@ -0,0 +1,70 @@
+let newRelatedTable = _newRelatedTable;
+const negotiateRawSqlFilter = require('../column/negotiateRawSqlFilter');
+// let subFilter = require('./subFilterAny');
+let subFilter = require('./subFilter');
+let isShallow = true;
+
+function newAny(relations, depth) {
+
+	function any(fn) {
+		let relatedTable = newRelatedTable(relations, isShallow, depth + 1);
+		let arg = typeof fn === 'function' ? fn(relatedTable) : fn;
+		let filter = negotiateRawSqlFilter(arg);
+		let sub =  subFilter(relations, filter, depth);
+		return sub;
+	}
+	return any;
+}
+
+function _newRelatedTable() {
+	newRelatedTable = require('../newRelatedTable');
+	return newRelatedTable.apply(null, arguments);
+}
+
+module.exports = newAny;
+
+//
+// let newRelatedTable = _newRelatedTable;
+// let negotiateRawSqlFilter = require('../column/negotiateRawSqlFilter');
+// let newSelect = require('./selectSql');
+// let newJoin = require('./joinSql');
+// let newWhere = require('./whereSql');
+// let subFilter = require('./subFilter');
+// let isShallow = true;
+
+// function newAny(relations, depth) {
+
+// 	function any(fn) {
+// 		let relationCount = relations.length;
+// 		let alias = 'x' + (depth);
+// 		// let alias = 'x' + relationCount;
+// 		let table = relations[relationCount - 1].childTable;
+// 		let exists = newSelect(table, alias).prepend('EXISTS (');
+// 		let join = newJoin(relations, depth);
+
+// 		let relatedTable = newRelatedTable(relations.slice(-1), isShallow, depth+1);
+// 		let arg = typeof fn === 'function' ? fn(relatedTable) : fn; //we need inner joins from here
+// 		let filter = negotiateRawSqlFilter(arg);
+// 		let where = newWhere(relations[0],filter, depth);
+// 		return exists.append(join).append(where).append(')');
+
+
+// 		// let innerJoin = newJoinSql(relations);
+// 		// let relatedTable = newRelatedTable(relations.slice(-1), isShallow);
+// 		// //relations is missing anything below any(..)
+// 		// let arg = typeof fn === 'function' ? fn(relatedTable) : fn; //we need inner joins from here
+// 		// let filter = negotiateRawSqlFilter(arg);
+// 		// let sqlFilter = filter.sql();
+// 		// //_3.id is not null
+// 		// return subFilter(relations.slice(-1), filter);
+// 	}
+// 	return any;
+// 	// db.order.lines.any(x => x.order.deliveryAddress.id.notEqual(null));
+// }
+
+// function _newRelatedTable() {
+// 	newRelatedTable = require('../newRelatedTable');
+// 	return newRelatedTable.apply(null, arguments);
+// }
+
+// module.exports = newAny;

package/src/table/relatedTable/childColumn.js

@@ -0,0 +1,61 @@
+var newJoin = require('./joinSql');
+var getSessionContext = require('../getSessionContext');
+var newJoinCore = require('../query/singleQuery/joinSql/newShallowJoinSqlCore');
+
+function childColumn(column, relations) {
+	const context = getSessionContext();
+	const outerAlias = 'y' + context.aggregateCount++;
+	const alias = 'x' + relations.length;
+	const foreignKeys = getForeignKeys(relations[0]);
+	const select = ` LEFT JOIN (SELECT ${foreignKeys},${alias}.${column._dbName} as prop`;
+	const innerJoin = relations.length > 1 ? newJoin(relations).sql() : '';
+	const onClause = createOnClause(relations[0], outerAlias);
+	const from = ` FROM ${relations.at(-1).childTable._dbName} ${alias} ${innerJoin}) ${outerAlias} ON (${onClause})`;
+	const join = select  + from ;
+
+	return {
+		expression: (alias) => `${outerAlias}.prop ${alias}`,
+		joins: [join],
+		column,
+		groupBy:  `${outerAlias}.prop`,
+	};
+}
+
+function createOnClause(relation, rightAlias) {
+	var c = {};
+	var sql = '';
+	let leftAlias = relation.parentTable._rootAlias || relation.parentTable._dbName;
+
+	c.visitJoin = function(relation) {
+		sql = newJoinCore(relation.childTable,relation.columns,relation.childTable._primaryColumns,leftAlias,rightAlias).sql();
+	};
+
+	c.visitOne = function(relation) {
+		innerJoin(relation);
+	};
+
+	c.visitMany = c.visitOne;
+
+	function innerJoin(relation) {
+		var joinRelation = relation.joinRelation;
+		var childTable = relation.childTable;
+		var parentTable = relation.parentTable;
+		var columns = joinRelation.columns;
+
+		sql = newJoinCore(childTable,parentTable._primaryColumns,columns,leftAlias, rightAlias).sql();
+	}
+	relation.accept(c);
+	return sql;
+}
+
+function getForeignKeys(relation) {
+	let columns;
+	let alias = 'x1';
+	if (relation.joinRelation)
+		columns = relation.joinRelation.columns;
+	else
+		columns = relation.childTable._primaryColumns;
+	return columns.map(x => `${alias}.${x._dbName}`).join(',');
+}
+
+module.exports = childColumn;

package/src/table/relatedTable/columnAggregate.js

@@ -0,0 +1,16 @@
+var newJoinArray = require('./joinSqlArray');
+
+function columnAggregate(operator, column, relations, coalesce = true) {
+
+	const tableAlias = relations.reduce((prev,relation) => {
+		return prev + relation.toLeg().name;
+	}, 'z');
+
+	return {
+		expression: (alias) => coalesce ? `COALESCE(${operator}(${tableAlias}.${column._dbName}), 0) as ${alias}` : `${operator}(${tableAlias}.${column._dbName}) as ${alias}`,
+
+		joins: newJoinArray(relations)
+	};
+}
+
+module.exports = columnAggregate;

package/src/table/relatedTable/columnAggregateGroup.js

@@ -0,0 +1,59 @@
+var newJoin = require('./joinSql');
+var getSessionContext = require('../getSessionContext');
+var newJoinCore = require('../query/singleQuery/joinSql/newShallowJoinSqlCore');
+
+function columnAggregate(operator, column, relations, coalesce = true) {
+	const context = getSessionContext();
+	const outerAlias = 'y' + context.aggregateCount++;
+	const alias = 'x' + relations.length;
+	const foreignKeys = getForeignKeys(relations[0]);
+	const select = ` LEFT JOIN (SELECT ${foreignKeys},${operator}(${alias}.${column._dbName}) as amount`;
+	const innerJoin = relations.length > 1 ? newJoin(relations).sql() : '';
+	const onClause = createOnClause(relations[0], outerAlias);
+	const from = ` FROM ${relations.at(-1).childTable._dbName} ${alias} ${innerJoin} GROUP BY ${foreignKeys}) ${outerAlias} ON (${onClause})`;
+	const join = select  + from ;
+
+	return {
+		expression: (alias) => coalesce? `COALESCE(${outerAlias}.amount, 0) as ${alias}` : `${outerAlias}.amount as ${alias}`,
+		joins: [join]
+	};
+}
+
+function createOnClause(relation, rightAlias) {
+	var c = {};
+	var sql = '';
+	let leftAlias = relation.parentTable._rootAlias || relation.parentTable._dbName;
+
+	c.visitJoin = function(relation) {
+		sql = newJoinCore(relation.childTable,relation.columns,relation.childTable._primaryColumns,leftAlias,rightAlias).sql();
+	};
+
+	c.visitOne = function(relation) {
+		innerJoin(relation);
+	};
+
+	c.visitMany = c.visitOne;
+
+	function innerJoin(relation) {
+		var joinRelation = relation.joinRelation;
+		var childTable = relation.childTable;
+		var parentTable = relation.parentTable;
+		var columns = joinRelation.columns;
+
+		sql = newJoinCore(childTable,parentTable._primaryColumns,columns,leftAlias, rightAlias).sql();
+	}
+	relation.accept(c);
+	return sql;
+}
+
+function getForeignKeys(relation) {
+	let columns;
+	let alias = 'x1';
+	if (relation.joinRelation)
+		columns = relation.joinRelation.columns;
+	else
+		columns = relation.childTable._primaryColumns;
+	return columns.map(x => `${alias}.${x._dbName}`).join(',');
+}
+
+module.exports = columnAggregate;

package/src/table/relatedTable/joinSql.js

@@ -0,0 +1,40 @@
+var newShallowJoinSql = require('../query/singleQuery/joinSql/newShallowJoinSql');
+var newParameterized = require('../query/newParameterized');
+
+function newJoinSql(relations, depth = 0) {
+	var leftAlias,
+		rightAlias;
+	var relation;
+	var c = {};
+	var sql = newParameterized('');
+
+	c.visitJoin = function(relation) {
+		//todo fix discriminators on childTable
+		sql = newShallowJoinSql(relation.parentTable,relation.childTable._primaryColumns,relation.columns,leftAlias,rightAlias).prepend(' INNER').prepend(sql);
+	};
+
+	c.visitOne = function(relation) {
+		innerJoin(relation);
+	};
+
+	c.visitMany = c.visitOne;
+
+	function innerJoin(relation) {
+		var joinRelation = relation.joinRelation;
+		var table = joinRelation.childTable;
+		var rightColumns = table._primaryColumns;
+		var leftColumns = joinRelation.columns;
+
+		sql = newShallowJoinSql(table,leftColumns,rightColumns,leftAlias,rightAlias).prepend(' INNER').prepend(sql);
+	}
+
+	for (let i = relations.length-1; i > depth; i--) {
+		leftAlias = 'x' + (i+1);
+		rightAlias = 'x' + i;
+		relation = relations[i];
+		relation.accept(c);
+	}
+	return sql;
+}
+
+module.exports = newJoinSql;

package/src/table/relatedTable/joinSqlArray.js

@@ -0,0 +1,32 @@
+const newShallowJoinSql = require('../query/singleQuery/joinSql/newShallowJoinSql');
+
+function _new(relations) {
+
+	let result = [];
+	let leftAlias =  relations[0].parentTable._dbName;
+	let rightAlias = 'z';
+	let sql;
+
+
+	let c = {};
+	c.visitJoin = function(relation) {
+		sql = newShallowJoinSql(relation.childTable,relation.columns,relation.childTable._primaryColumns,leftAlias,rightAlias).prepend(' LEFT').sql();
+	};
+
+	c.visitOne = function(relation) {
+		sql = newShallowJoinSql(relation.childTable,relation.parentTable._primaryColumns,relation.joinRelation.columns,leftAlias,rightAlias).prepend(' LEFT').sql();
+	};
+
+	c.visitMany = c.visitOne;
+
+	for (let i = 0; i < relations.length; i++) {
+		rightAlias = rightAlias + relations[i].toLeg().name;
+		relations[i].accept(c);
+		result.push(sql);
+		leftAlias = rightAlias;
+	}
+
+	return result;
+}
+
+module.exports = _new;

package/src/table/relatedTable/none.js

@@ -0,0 +1,22 @@
+let newRelatedTable = _newRelatedTable;
+const negotiateRawSqlFilter = require('../column/negotiateRawSqlFilter');
+let subFilter = require('./subFilter');
+let isShallow = true;
+
+function newNone(relations, depth) {
+
+	function none(fn) {
+		let relatedTable = newRelatedTable(relations, isShallow, depth + 1);
+		let arg = typeof fn === 'function' ? fn(relatedTable) : fn;
+		let filter = negotiateRawSqlFilter(arg);
+		return subFilter(relations, filter, depth).not();
+	}
+	return none;
+}
+
+function _newRelatedTable() {
+	newRelatedTable = require('../newRelatedTable');
+	return newRelatedTable.apply(null, arguments);
+}
+
+module.exports = newNone;

package/src/table/relatedTable/relatedColumn.js

@@ -0,0 +1,49 @@
+var newSubFilter = require('./subFilter');
+var aggregateGroup = require('./columnAggregateGroup');
+var aggregate = require('./columnAggregate');
+var childColumn = require('./childColumn');
+
+function newRelatedColumn(column, relations, isShallow, depth) {
+	var c = {};
+
+	var alias = 'x' + relations.length;
+	for (var propName in column) {
+		var prop = column[propName];
+		if (prop instanceof Function)
+
+			c[propName] = wrapFilter(prop);
+	}
+
+	c.groupSum = aggregateGroup.bind(null, 'sum', column, relations);
+	c.groupAvg = aggregateGroup.bind(null, 'avg', column, relations);
+	c.groupMin = aggregateGroup.bind(null, 'min', column, relations);
+	c.groupMax = aggregateGroup.bind(null, 'max', column, relations);
+	c.groupCount = aggregateGroup.bind(null, 'count', column, relations, false);
+	c.sum = aggregate.bind(null, 'sum', column, relations);
+	c.avg = aggregate.bind(null, 'avg', column, relations);
+	c.min = aggregate.bind(null, 'min', column, relations);
+	c.max = aggregate.bind(null, 'max', column, relations);
+	c.count = aggregate.bind(null, 'count', column, relations, false);
+	c.self = childColumn.bind(null, column, relations);
+
+	return c;
+
+	function wrapFilter(filter) {
+		return runFilter;
+
+		function runFilter() {
+			var args = [];
+			for (var i = 0; i < arguments.length; i++) {
+				args.push(arguments[i]);
+			}
+			args.push(alias);
+			var shallowFilter = filter.apply(null, args);
+			if (isShallow)
+				return shallowFilter;
+			return newSubFilter(relations, shallowFilter, depth);
+		}
+	}
+
+}
+
+module.exports = newRelatedColumn;

package/src/table/relatedTable/relationFilter.js

@@ -0,0 +1,16 @@
+var newSelect = require('./selectSql');
+var newJoin = require('./joinSql');
+var newWhere = require('./whereSql');
+
+function relationFilter(relations, shallowFilter, depth) {
+	var relationCount = relations.length;
+	var alias = 'x' + relationCount;
+	var table = relations[relationCount-1].childTable;
+	var exists = newSelect(table,alias).prepend('EXISTS (');
+	var join = newJoin(relations, depth);
+	var where = newWhere(relations,shallowFilter, depth);
+	return exists.append(join).append(where).append(')');
+
+}
+
+module.exports = relationFilter;

package/src/table/relatedTable/selectSql.js

@@ -0,0 +1,11 @@
+var newParameterized = require('../query/newParameterized');
+var newBoolean = require('../column/newBoolean');
+
+function newSelectSql(table, alias) {
+	var colName = table._primaryColumns[0]._dbName;
+	var sql = 'SELECT ' + alias + '.' + colName + ' FROM ' + table._dbName + ' ' + alias;
+	sql = newParameterized(sql);
+	return newBoolean(sql);
+}
+
+module.exports = newSelectSql;

package/src/table/relatedTable/subFilter.js

@@ -0,0 +1,16 @@
+var newSelect = require('./selectSql');
+var newJoin = require('./joinSql');
+var newWhere = require('./whereSql');
+
+function newSubFilter(relations, shallowFilter, depth) {
+	var relationCount = relations.length;
+	var alias = 'x' + relationCount;
+	var table = relations[relationCount-1].childTable;
+	var exists = newSelect(table,alias).prepend('EXISTS (');
+	var join = newJoin(relations, depth);
+	var where = newWhere(relations,shallowFilter, depth);
+	return exists.append(join).append(where).append(')');
+
+}
+
+module.exports = newSubFilter;

package/src/table/relatedTable/where.js

@@ -0,0 +1,50 @@
+let newRelatedTable = _newRelatedTable;
+const negotiateRawSqlFilter = require('../column/negotiateRawSqlFilter');
+let tryGetSessionContext = require('../tryGetSessionContext');
+
+function newWhere(_relations, _depth) {
+
+	function where(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 {
+			let arg = typeof fn === 'function' ? fn(table) : fn;
+			let anyFilter = negotiateRawSqlFilter(arg);
+			delete table._rootAlias;
+			return anyFilter;
+		}
+		catch (e) {
+			delete table._rootAlias;
+			throw e;
+		}
+	}
+	return where;
+
+	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 = newWhere;

package/src/table/relatedTable/whereSql.js

@@ -0,0 +1,41 @@
+var newShallowJoinSql = require('../query/singleQuery/joinSql/newShallowJoinSqlCore');
+
+function newWhereSql(relations, shallowFilter, depth = 0) {
+	let relation = relations[depth];
+	var c = {};
+	var sql;
+
+	c.visitJoin = function(relation) {
+		var table = relation.childTable;
+		var alias = depth === 0 ? (relation.parentTable._rootAlias || relation.parentTable._dbName) : 'x' + depth;
+		var leftColumns = relation.columns;
+		var rightColumns = table._primaryColumns;
+		where(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 = depth === 0 ? (childTable._rootAlias || childTable._dbName) : 'x' + depth;
+		where(alias, leftColumns, rightColumns);
+	};
+
+	c.visitMany = c.visitOne;
+
+	function where(alias, leftColumns, rightColumns) {
+		var table = relation.childTable;
+		var joinCore = newShallowJoinSql(table, leftColumns, rightColumns, alias, 'x' + (depth + 1));
+		if (shallowFilter && shallowFilter.sql()) {
+			sql = joinCore.prepend(' WHERE ').append(' AND ').append(shallowFilter);
+		}
+		else
+			sql = joinCore.prepend(' WHERE ');
+	}
+
+	relation.accept(c);
+	return sql;
+}
+
+module.exports = newWhereSql;

package/src/table/relation/manyCache/extractParentKey.js

@@ -0,0 +1,17 @@
+function extractParentKey(joinRelation, child) {
+
+	var childTable = joinRelation.childTable;
+	var primaryColumns = childTable._primaryColumns;
+	var parent = {};
+
+	joinRelation.columns.forEach(addKeyToParent);
+
+	function addKeyToParent(childPk, index) {
+		var primaryColumn = primaryColumns[index];
+		parent[primaryColumn.alias] = child[childPk.alias];
+	}
+
+	return parent;
+}
+
+module.exports = extractParentKey;

package/src/table/relation/manyCache/synchronizeAdded.js

@@ -0,0 +1,13 @@
+var extractParentKey = require('./extractParentKey');
+
+function synchronizeAdded(action, joinRelation) {
+	var cache = joinRelation.parentTable._cache;
+	cache.subscribeAdded(onAdded);
+
+	function onAdded(child) {
+		var parent = extractParentKey(joinRelation, child);
+		action(parent, child);
+	}
+}
+
+module.exports = synchronizeAdded;

package/src/table/relation/manyCache/synchronizeChanged.js

@@ -0,0 +1,31 @@
+var extractParentKey = require('./extractParentKey');
+
+function synchronizeChanged(manyCache, joinRelation, parent, child) {
+	var columns = joinRelation.columns;
+	columns.forEach(subscribeColumn);
+	child = null;
+
+	function subscribeColumn(column) {
+		child.subscribeChanged(onChanged, column.alias);
+	}
+
+	function unsubscribe(child) {
+		columns.forEach(unsubscribeColumn);
+
+		function unsubscribeColumn(column) {
+			child.unsubscribeChanged(onChanged, column.alias);
+		}
+	}
+
+	function onChanged(child) {
+		unsubscribe(child);
+		manyCache.tryRemove(parent, child);
+		var newParent = extractParentKey(joinRelation, child);
+		manyCache.tryAdd(newParent, child);
+	}
+
+
+
+}
+
+module.exports = synchronizeChanged;

package/src/table/relation/manyCache/synchronizeRemoved.js

@@ -0,0 +1,13 @@
+var extractParentKey = require('./extractParentKey');
+
+function synchronizeRemoved(action, joinRelation) {
+	var cache = joinRelation.parentTable._cache;
+	cache.subscribeRemoved(onRemoved);
+
+	function onRemoved(child) {
+		var parent = extractParentKey(joinRelation, child);
+		action(parent, child);
+	}
+}
+
+module.exports = synchronizeRemoved;

package/src/table/relation/newExpanderCache.js

@@ -0,0 +1,7 @@
+var newRowCache = require('../newRowCache');
+
+function newExpanderCache(joinRelation) {
+	return newRowCache(joinRelation.childTable);
+}
+
+module.exports = newExpanderCache;

package/src/table/relation/newForeignKeyFilter.js

@@ -0,0 +1,20 @@
+function newForeignKeyFilter(joinRelation, parentRow) {
+	var columns = joinRelation.columns;
+	var rightTable = joinRelation.childTable;
+
+	var filter = getNextFilterPart(0);
+
+	for (var i = 1; i < columns.length; i++) {
+
+		filter = filter.and(getNextFilterPart(i));
+	}
+
+	function getNextFilterPart(index) {
+		var column = columns[index];
+		var pk = rightTable._primaryColumns[index];
+		return column.eq(parentRow[pk.alias]);
+	}
+	return filter;
+}
+
+module.exports = newForeignKeyFilter;

package/src/table/relation/newJoinLeg.js

@@ -0,0 +1,23 @@
+var newCollection = require('../../newCollection');
+var newQueryContext = require('../query/singleQuery/newQueryContext');
+
+function newLeg(relation) {
+	var c = {};
+	var span = {};
+	span.table = relation.childTable;
+	span.legs = newCollection();
+	span.queryContext = newQueryContext();
+	c.span = span;
+	c.name = relation.leftAlias;
+	c.table = relation.parentTable;
+	c.columns = relation.columns;
+	c.expand = relation.expand;
+
+	c.accept = function(visitor) {
+		visitor.visitJoin(c);
+	};
+
+	return c;
+}
+
+module.exports = newLeg;