orange-orm 3.10.2

package/src/table/oneRelation/getRelatives.js

@@ -0,0 +1,45 @@
+let emptyFilter = require('../../emptyFilter');
+let newForeignKeyFilter = require('../relation/newForeignKeyFilter');
+let negotiateExpandInverse = require('../negotiateExpandInverse');
+
+function getRelatives(parent, relation) {
+	let queryContext = parent.queryContext;
+	let strategy = queryContext && queryContext.strategy[relation.joinRelation.rightAlias];
+
+
+	let filter;
+	let parentTable = relation.joinRelation.childTable;
+
+	if (parentTable._primaryColumns.length === 1)
+		filter = createInFilter();
+	else
+		filter = createCompositeFilter();
+
+
+	function createInFilter() {
+		let parentAlias = parentTable._primaryColumns[0].alias;
+		let ids = queryContext.rows.map(function(row) {
+			return row[parentAlias];
+		});
+		let column = relation.joinRelation.columns[0];
+		return column.in(ids);
+	}
+
+	function createCompositeFilter() {
+		let filters = queryContext.rows.map(function(row) {
+			return newForeignKeyFilter(relation.joinRelation, row);
+		});
+		return emptyFilter.or.apply(emptyFilter, filters);
+	}
+
+	return relation.childTable.getMany(filter, strategy).then(onRows);
+
+	function onRows(rows) {
+		queryContext.expand(relation);
+		negotiateExpandInverse(parent, relation, rows);
+		return rows;
+	}
+
+}
+
+module.exports = getRelatives;

package/src/table/popChanges.js

@@ -0,0 +1,19 @@
+var getChangeSet = require('./commands/getChangeSet');
+var compressChanges = require('./commands/compressChanges');
+
+function popChanges() {
+	var changeSet = getChangeSet();
+	var length = changeSet.length;
+	if (length > 0) {
+		var lastCmd = changeSet[length-1];
+		if (lastCmd.endEdit)
+			lastCmd.endEdit();
+		var compressed = compressChanges(changeSet);
+		changeSet.length = 0;
+		return compressed;
+	}
+	return changeSet;
+
+}
+
+module.exports = popChanges;

package/src/table/promise.js

@@ -0,0 +1,14 @@
+var promise = require('promise/domains');
+var deferred = require('deferred');
+let promisify = require('util').promisify;
+
+
+function newPromise(func) {
+	if (!func)
+		return deferred.resolve.apply(deferred, arguments);
+	return new promise(func);
+}
+
+newPromise.all = Promise.all;
+newPromise.denodeify = promisify || promise.denodeify;
+module.exports = newPromise;

package/src/table/purifyStrategy.js

@@ -0,0 +1,49 @@
+function purifyStrategy(table, strategy, columns = new Map()) {
+	strategy = { ...strategy };
+	for (let p in strategy) {
+		if (strategy[p] === null)
+			strategy[p] = true;
+	}
+
+	let hasIncludedColumns;
+	for (let name in strategy) {
+		if (table._relations[name] && !strategy[name])
+			continue;
+		else if (table._relations[name])
+			strategy[name] = addLeg(table._relations[name], strategy[name], columns);
+		else if (table[name] && table[name].eq ) {
+			if (!columns.has(table[name]))
+				columns.set(table[name], strategy[name]);
+			hasIncludedColumns = hasIncludedColumns || strategy[name];
+		}
+	}
+	for (let i = 0; i < table._columns.length; i++) {
+		let column = table._columns[i];
+		strategy[column.alias] = !hasIncludedColumns;
+	}
+
+	table._primaryColumns.forEach(column => {
+		strategy[column.alias] = true;
+	});
+	columns.forEach((value, key) => strategy[key.alias] = value);
+
+	return strategy;
+
+}
+
+function addLeg(relation, strategy, columns) {
+	let nextColumns = new Map();
+	if (!relation.joinRelation)
+		for (let i = 0; i < relation.columns.length; i++) {
+			columns.set(relation.columns[i], true);
+		}
+	else {
+		relation.joinRelation.columns.forEach(column => {
+			nextColumns.set(column, true);
+		});
+	}
+	let childTable = relation.childTable;
+	return purifyStrategy(childTable, strategy, nextColumns);
+}
+
+module.exports = purifyStrategy;

package/src/table/query/extractFilter.js

@@ -0,0 +1,9 @@
+var emptyFilter = require('../../emptyFilter');
+
+function extract(filter) {
+	if (filter)
+		return filter;
+	return emptyFilter;
+}
+
+module.exports = extract;

package/src/table/query/extractLimit.js

@@ -0,0 +1,11 @@
+var getSessionContext = require('../getSessionContext');
+
+function extractLimit(span) {
+	let limit = getSessionContext().limit;
+	if (limit)
+		return limit(span);
+	else
+		return '';
+}
+
+module.exports = extractLimit;

package/src/table/query/extractLimitQuery.js

@@ -0,0 +1,23 @@
+var newWhereSql = require('./singleQuery/newWhereSql');
+var negotiateLimit = require('./singleQuery/negotiateLimit');
+var newParameterized = require('./newParameterized');
+var getSessionContext = require('../getSessionContext');
+
+function _new(table, filter, span, alias, orderBy, limit) {
+	//unused ?
+
+	if (!limit)
+		return;
+	var whereSql = newWhereSql(table, filter, alias);
+	var safeLimit = negotiateLimit(limit);
+	var sql;
+	if (getSessionContext().limit === 'TOP') {
+		safeLimit = safeLimit.replace('limit', 'top');
+		sql = 'select ' + safeLimit + ' * from ' + table._dbName + ' ' + alias + whereSql + orderBy;
+	}
+	sql = 'select * from ' + table._dbName + ' ' + alias + whereSql + orderBy + safeLimit;
+
+	return newParameterized(sql, filter.parameters);
+}
+
+module.exports = _new;

package/src/table/query/extractOffset.js

@@ -0,0 +1,11 @@
+var getSessionContext = require('../getSessionContext');
+
+function extractOffset(span) {
+	let {limitAndOffset} = getSessionContext();
+	if (limitAndOffset)
+		return limitAndOffset(span);
+	else
+		return '';
+}
+
+module.exports = extractOffset;

package/src/table/query/extractOrderBy.js

@@ -0,0 +1,57 @@
+function extractOrderBy(table, alias, orderBy, originalOrderBy) {
+	var dbNames = [];
+	var i;
+	if (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 {
+		if(originalOrderBy)
+			return originalOrderBy;
+
+		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/query/extractSql.js

@@ -0,0 +1,10 @@
+function extract(sql) {
+	if (sql && typeof(sql) === 'function')
+		return sql();
+	else if (sql === undefined)
+		return '';
+	else
+		return sql;
+}
+
+module.exports = extract;

package/src/table/query/newParameterized.js

@@ -0,0 +1,38 @@
+var extractSql = require('./extractSql');
+var extractParameters = require('./parameterized/extractParameters');
+
+var nextParameterized = function(text, params) {
+	nextParameterized = require('../query/newParameterized');
+	return nextParameterized(text, params);
+};
+
+function Parameterized(text, parameters) {
+	this._text = text;
+	this.parameters = parameters;
+}
+
+Parameterized.prototype.sql = function() {
+	return this._text;
+};
+
+Parameterized.prototype.prepend = function(other) {
+	if (other.sql) {
+		var params = other.parameters.concat(this.parameters);
+		return nextParameterized(other.sql() + this._text, params);
+	} else
+		return nextParameterized(other + this._text, this.parameters);
+};
+
+Parameterized.prototype.append = function(other) {
+	if (other.sql) {
+		var params = this.parameters.concat(other.parameters);
+		return nextParameterized(this._text + other.sql(), params);
+	} else
+		return nextParameterized(this._text + other, this.parameters);
+};
+
+module.exports = function(text, parameters) {
+	text = extractSql(text);
+	parameters = extractParameters(parameters);
+	return new Parameterized(text, parameters);
+};

package/src/table/query/newSingleQuery.js

@@ -0,0 +1,23 @@
+var newColumnSql = require('./singleQuery/newColumnSql');
+var newJoinSql = require('./singleQuery/newJoinSql');
+var newWhereSql = require('./singleQuery/newWhereSql');
+var negotiateLimit = require('./singleQuery/negotiateLimit');
+var negotiateExclusive = require('./singleQuery/negotiateExclusive');
+var newParameterized = require('../../table/query/newParameterized');
+
+function _new(table,filter,span,alias,innerJoin,orderBy,limit,offset,exclusive) {
+
+	var name = table._dbName;
+	var columnSql = newColumnSql(table,span,alias);
+	var joinSql = newJoinSql(span,alias);
+	var whereSql = newWhereSql(table,filter,alias);
+	var safeLimit = negotiateLimit(limit);
+	var exclusiveClause = negotiateExclusive(table,alias,exclusive);
+	return newParameterized('select' + safeLimit + ' ' + columnSql + ' from ' + name + ' ' + alias)
+		.append(innerJoin)
+		.append(joinSql)
+		.append(whereSql)
+		.append(orderBy + offset + exclusiveClause);
+}
+
+module.exports = _new;

package/src/table/query/parameterized/extractParameters.js

@@ -0,0 +1,8 @@
+function extract(parameters) {
+	if (parameters) {
+		return parameters.slice(0);
+	}
+	return [];
+}
+
+module.exports = extract;

package/src/table/query/singleQuery/columnSql/joinLegToColumnSql.js

@@ -0,0 +1,16 @@
+var newShallowColumnSql = require('./newShallowColumnSql');
+var newJoinedColumnSql = _initJoinedColumnSql;
+
+function sql(leg,alias,ignoreNull) {
+	var span = leg.span;
+	var shallowColumnSql = newShallowColumnSql(span.table,alias, span, ignoreNull);
+	var joinedColumnSql = newJoinedColumnSql(span,alias,ignoreNull);
+	return ',' + shallowColumnSql + joinedColumnSql;
+}
+
+function _initJoinedColumnSql(span,alias,ignoreNull) {
+	newJoinedColumnSql = require('./newJoinedColumnSql');
+	return newJoinedColumnSql(span,alias,ignoreNull);
+}
+
+module.exports = sql;

package/src/table/query/singleQuery/columnSql/newJoinedColumnSql.js

@@ -0,0 +1,27 @@
+var joinLegToColumnSql = require('./joinLegToColumnSql');
+
+module.exports = function(span, alias, ignoreNull) {
+	var c = {};
+	var sql = '';
+
+	c.visitJoin = function(leg) {
+		var joinSql = joinLegToColumnSql(leg, alias + leg.name, ignoreNull);
+		sql = sql + joinSql;
+	};
+
+	c.visitOne = function(leg) {
+		c.visitJoin(leg);
+	};
+
+	c.visitMany = function() {
+	};
+
+
+	span.legs.forEach(onEach);
+
+	function onEach(leg) {
+		leg.accept(c);
+	}
+
+	return sql;
+};

package/src/table/query/singleQuery/columnSql/newShallowColumnSql.js

@@ -0,0 +1,37 @@
+function _new(table, alias, span, ignoreNulls) {
+	let columnsMap = span.columns;
+	var columns = table._columns;
+	var sql = '';
+	var separator = '';
+
+	for (let i = 0; i < columns.length; i++) {
+		var column = columns[i];
+		if (!columnsMap || (columnsMap.get(column))) {
+			sql = sql + separator + formatColumn(column) + ' as s' + alias + i;
+			separator = ',';
+		}
+		else if (!ignoreNulls) {
+			sql = sql + separator + 'null as s' + alias + i;
+			separator = ',';
+		}
+	}
+
+	for (let name in span.aggregates || {}) {
+		sql = sql + separator + span.aggregates[name].expression(name);
+		separator = ',';
+	}
+
+	return sql;
+
+	function formatColumn(column) {
+		const formatted = column.formatOut ? column.formatOut(alias) : alias + '.' + column._dbName;
+		if (column.dbNull === null)
+			return formatted;
+		else {
+			const encoded = column.encode.unsafe(column.dbNull);
+			return `CASE WHEN ${formatted}=${encoded} THEN null ELSE ${formatted} END`;
+		}
+	}
+}
+
+module.exports = _new;

package/src/table/query/singleQuery/joinSql/joinLegToJoinSql.js

@@ -0,0 +1,13 @@
+var joinLegToShallowJoinSql = require('./joinLegToShallowJoinSql');
+var newJoinSql = _newJoinSql;
+
+function toJoinSql(leg,alias,childAlias) {
+	return joinLegToShallowJoinSql(leg,alias,childAlias).append(newJoinSql(leg.span,childAlias));
+}
+
+function _newJoinSql() {
+	newJoinSql = require('../newJoinSql');
+	return newJoinSql.apply(null,arguments);
+}
+
+module.exports = toJoinSql;

package/src/table/query/singleQuery/joinSql/joinLegToShallowJoinSql.js

@@ -0,0 +1,9 @@
+var newShallowJoinSql = require('./newShallowJoinSql');
+
+function toJoinSql(leg,alias,childAlias) {
+	var columns = leg.columns;
+	var childTable = leg.span.table;
+	return newShallowJoinSql(childTable,columns,childTable._primaryColumns,alias,childAlias,leg.span.where).prepend(' LEFT');
+}
+
+module.exports = toJoinSql;

package/src/table/query/singleQuery/joinSql/newDiscriminatorSql.js

@@ -0,0 +1,11 @@
+var newDiscriminatorSqlCore = require('../newDiscriminatorSql');
+
+function newDiscriminatorSql(table, alias) {
+	var result = newDiscriminatorSqlCore(table,alias);
+	if (result)
+		return ' AND' + result;
+	return result;
+
+}
+
+module.exports = newDiscriminatorSql;

package/src/table/query/singleQuery/joinSql/newShallowJoinSql.js

@@ -0,0 +1,9 @@
+var newJoinCore = require('./newShallowJoinSqlCore');
+
+function _new(rightTable,leftColumns,rightColumns,leftAlias,rightAlias, filter) {
+	var sql = ' JOIN ' + rightTable._dbName + ' ' +  rightAlias + ' ON (';
+	var joinCore = newJoinCore(rightTable,leftColumns,rightColumns,leftAlias,rightAlias,filter);
+	return joinCore.prepend(sql).append(')');
+}
+
+module.exports = _new;

package/src/table/query/singleQuery/joinSql/newShallowJoinSqlCore.js

@@ -0,0 +1,25 @@
+var newDiscriminatorSql = require('./newDiscriminatorSql');
+var newParameterized = require('../../newParameterized');
+
+function _new(rightTable,leftColumns,rightColumns,leftAlias,rightAlias,filter) {
+	var sql = '';
+	var delimiter = '';
+	for (var i = 0; i < leftColumns.length; i++) {
+		addColumn(i);
+		delimiter = ' AND ';
+	}
+
+	function addColumn(index) {
+		var leftColumn = leftColumns[index];
+		var rightColumn = rightColumns[index];
+		sql += delimiter + leftAlias + '.' + leftColumn._dbName + '=' + rightAlias + '.' + rightColumn._dbName;
+	}
+
+	sql += newDiscriminatorSql(rightTable,rightAlias);
+	var result = newParameterized(sql);
+	if (filter)
+		result = result.append(delimiter).append(filter);
+	return result;
+}
+
+module.exports = _new;

package/src/table/query/singleQuery/joinSql/oneLegToJoinSql.js

@@ -0,0 +1,13 @@
+var oneLegToShallowJoinSql = require('./oneLegToShallowJoinSql');
+var newJoinSql = _newJoinSql;
+
+function toJoinSql(leg,alias,childAlias) {
+	return oneLegToShallowJoinSql(leg,alias,childAlias).append(newJoinSql(leg.span,childAlias));
+}
+
+function _newJoinSql() {
+	newJoinSql = require('../newJoinSql');
+	return newJoinSql.apply(null,arguments);
+}
+
+module.exports = toJoinSql;

package/src/table/query/singleQuery/joinSql/oneLegToShallowJoinSql.js

@@ -0,0 +1,10 @@
+var newShallowJoinSql = require('./newShallowJoinSql');
+
+function toJoinSql(leg,alias,childAlias) {
+	var parentTable = leg.table;
+	var columns = leg.columns;
+	var childTable = leg.span.table;
+	return newShallowJoinSql(childTable,parentTable._primaryColumns,columns,alias,childAlias, leg.span.where).prepend(' LEFT');
+}
+
+module.exports = toJoinSql;

package/src/table/query/singleQuery/negotiateExclusive.js

@@ -0,0 +1,11 @@
+var getSessionSingleton = require('../../getSessionSingleton');
+
+function negotiateExclusive(table, alias, _exclusive) {
+	if (table._exclusive || _exclusive) {
+		var encode =  getSessionSingleton('selectForUpdateSql');
+		return encode(alias);
+	}
+	return '';
+}
+
+module.exports = negotiateExclusive;

package/src/table/query/singleQuery/negotiateLimit.js

@@ -0,0 +1,10 @@
+function negotiateLimit(limit) {
+	if(!limit)
+		return ' ';
+
+	if(limit.charAt(0) !== ' ')
+		return ' ' + limit;
+	return limit;
+}
+
+module.exports = negotiateLimit;

package/src/table/query/singleQuery/newColumnSql.js

@@ -0,0 +1,8 @@
+var newShallowColumnSql = require('./columnSql/newShallowColumnSql');
+var newJoinedColumnSql = require('./columnSql/newJoinedColumnSql');
+
+module.exports = function(table,span,alias,ignoreNull) {
+	var shallowColumnSql = newShallowColumnSql(table,alias, span, ignoreNull);
+	var joinedColumnSql = newJoinedColumnSql(span,alias, ignoreNull);
+	return shallowColumnSql + joinedColumnSql;
+};

package/src/table/query/singleQuery/newDiscriminatorSql.js

@@ -0,0 +1,33 @@
+function newDiscriminatorSql(table, alias) {
+	var result = '';
+	var formulaDiscriminators = table._formulaDiscriminators;
+	var columnDiscriminators = table._columnDiscriminators;
+	addFormula();
+	addColumn();
+	return result;
+
+	function addFormula() {
+		for (var i = 0; i<formulaDiscriminators.length; i++) {
+			var current = formulaDiscriminators[i].replace('@this',alias);
+			and();
+			result += '(' + current + ')';
+		}
+	}
+
+	function addColumn() {
+		for (var i = 0; i< columnDiscriminators.length; i++) {
+			var current = columnDiscriminators[i];
+			and();
+			result += alias + '.' + current;
+		}
+	}
+
+	function and() {
+		if(result)
+			result += ' AND ';
+		else
+			result = ' ';
+	}
+}
+
+module.exports = newDiscriminatorSql;

package/src/table/query/singleQuery/newJoinSql.js

@@ -0,0 +1,41 @@
+var joinLegToJoinSql = require('./joinSql/joinLegToJoinSql');
+var oneLegToJoinSql = require('./joinSql/oneLegToJoinSql');
+var newParameterized = require('../newParameterized');
+
+function _new(span,alias = '') {
+	var sql = newParameterized('');
+	var childAlias;
+
+	var c = {};
+	c.visitJoin = function(leg) {
+		sql = joinLegToJoinSql(leg,alias,childAlias).prepend(sql);
+	};
+
+	c.visitOne = function(leg) {
+		sql = oneLegToJoinSql(leg,alias,childAlias).prepend(sql);
+	};
+
+	c.visitMany = function() {};
+
+	function onEachLeg(leg) {
+		childAlias = alias + leg.name;
+		leg.accept(c);
+	}
+
+	span.legs.forEach(onEachLeg);
+
+	const set = new Set();
+	for(let key in span.aggregates) {
+		const agg = span.aggregates[key];
+		for(let join of agg.joins) {
+			if (!set.has(join)) {
+				sql = sql.append(join);
+				set.add(join);
+			}
+		}
+	}
+
+	return sql;
+}
+
+module.exports = _new;

package/src/table/query/singleQuery/newQueryContext.js

@@ -0,0 +1,20 @@
+function newQueryContext() {
+	var rows = [];
+
+	var c = {};
+	c.rows = rows;
+
+	c.expand = function(relation) {
+		rows.forEach(function(row) {
+			relation.expand(row);
+		});
+	};
+
+	c.add = function(row) {
+		rows.push(row);
+	};
+
+	return c;
+}
+
+module.exports = newQueryContext;

package/src/table/query/singleQuery/newWhereSql.js

@@ -0,0 +1,19 @@
+var newDiscriminatorSql = require('./newDiscriminatorSql');
+var newParameterized = require('../../../table/query/newParameterized');
+
+function newWhereSql(table,filter,alias) {
+	var separator = ' where';
+	var result = newParameterized('');
+	var sql = filter.sql();
+	var discriminator = newDiscriminatorSql(table, alias);
+	if (sql) {
+		result = filter.prepend(separator + ' ');
+		separator = ' AND';
+	}
+	if(discriminator)
+		result = result.append(separator + discriminator);
+
+	return result;
+}
+
+module.exports = newWhereSql;