orange-orm 5.1.0 → 5.2.0

package/src/table/relatedTable/count.js

@@ -0,0 +1,139 @@
+const negotiateRawSqlFilter = require('../column/negotiateRawSqlFilter');
+const newJoin = require('./joinSql');
+const newWhere = require('./whereSql');
+const getSessionSingleton = require('../getSessionSingleton');
+const newParameterized = require('../query/newParameterized');
+const newBoolean = require('../column/newBoolean');
+
+const nullOperator = ' is ';
+const notNullOperator = ' is not ';
+const isShallow = true;
+
+function newCount(newRelatedTable, relations, depth) {
+
+	function count(context, fn) {
+		let shallowFilter;
+
+		if (fn !== undefined) {
+			let relatedTable = newRelatedTable(relations, isShallow, depth + 1);
+			let arg = typeof fn === 'function' ? fn(relatedTable) : fn;
+			shallowFilter = negotiateRawSqlFilter(context, arg);
+		}
+
+		const subQuery = newCountSubQuery(context, relations, shallowFilter, depth);
+		return newCountFilter(subQuery);
+	}
+
+	return count;
+}
+
+function newCountSubQuery(context, relations, shallowFilter, depth) {
+	const quote = getSessionSingleton(context, 'quote');
+	const relationCount = relations.length;
+	const alias = 'x' + relationCount;
+	const table = relations[relationCount - 1].childTable;
+	const select = newParameterized(`SELECT COUNT(*) FROM ${quote(table._dbName)} ${quote(alias)}`);
+	const join = newJoin(context, relations, depth);
+	const where = newWhere(context, relations, shallowFilter, depth);
+
+	return select.append(join).append(where);
+}
+
+function newCountFilter(subQuery) {
+	let c = {};
+
+	c.equal = function(context, arg) {
+		return compare(context, '=', arg);
+	};
+
+	c.notEqual = function(context, arg) {
+		return compare(context, '<>', arg);
+	};
+
+	c.lessThan = function(context, arg) {
+		return compare(context, '<', arg);
+	};
+
+	c.lessThanOrEqual = function(context, arg) {
+		return compare(context, '<=', arg);
+	};
+
+	c.greaterThan = function(context, arg) {
+		return compare(context, '>', arg);
+	};
+
+	c.greaterThanOrEqual = function(context, arg) {
+		return compare(context, '>=', arg);
+	};
+
+	c.between = function(context, from, to) {
+		from = c.greaterThanOrEqual(context, from);
+		to = c.lessThanOrEqual(context, to);
+		return from.and(context, to);
+	};
+
+	c.in = function(context, values) {
+		if (values.length === 0)
+			return newBoolean(newParameterized('1=2'));
+
+		let sqlParts = new Array(values.length);
+		let params = [];
+		for (let i = 0; i < values.length; i++) {
+			const encoded = encodeArg(context, values[i]);
+			sqlParts[i] = encoded.sql();
+			params = params.concat(encoded.parameters);
+		}
+
+		const sql = toSubQuery().sql() + ' in (' + sqlParts.join(',') + ')';
+		const allParams = toSubQuery().parameters.concat(params);
+		return newBoolean(newParameterized(sql, allParams));
+	};
+
+	c.notIn = function(context, values) {
+		return c.in(context, values).not(context);
+	};
+
+	c.eq = c.equal;
+	c.EQ = c.eq;
+	c.ne = c.notEqual;
+	c.NE = c.ne;
+	c.gt = c.greaterThan;
+	c.GT = c.gt;
+	c.ge = c.greaterThanOrEqual;
+	c.GE = c.ge;
+	c.lt = c.lessThan;
+	c.LT = c.lt;
+	c.le = c.lessThanOrEqual;
+	c.LE = c.le;
+	c.IN = c.in;
+
+	return c;
+
+	function compare(context, operator, arg) {
+		let encoded = encodeArg(context, arg);
+		let operatorSql = ' ' + operator + ' ';
+		if (encoded.sql() === 'null') {
+			if (operator === '=')
+				operatorSql = nullOperator;
+			else if (operator === '<>')
+				operatorSql = notNullOperator;
+		}
+
+		let sql = toSubQuery().append(operatorSql).append(encoded);
+		return newBoolean(sql);
+	}
+
+	function encodeArg(context, arg) {
+		if (arg && typeof arg._toFilterArg === 'function')
+			return arg._toFilterArg(context);
+		if (arg == null)
+			return newParameterized('null');
+		return newParameterized('?', [arg]);
+	}
+
+	function toSubQuery() {
+		return subQuery.prepend('(').append(')');
+	}
+}
+
+module.exports = newCount;

package/src/table/relatedTable/newFilterArg.js

@@ -0,0 +1,20 @@
+var newJoin = require('./joinSql');
+var newWhere = require('./whereSql');
+var newParameterized = require('../query/newParameterized');
+var quote = require('../quote');
+
+function newFilterArg(context, column, relations, depth = 0) {
+	var relationCount = relations.length;
+	var alias = 'x' + relationCount;
+	var table = relations[relationCount - 1].childTable;
+
+	var quotedAlias = quote(context, alias);
+	var quotedColumn = quote(context, column._dbName);
+	var quotedTable = quote(context, table._dbName);
+	var select = newParameterized(`(SELECT ${quotedAlias}.${quotedColumn} FROM ${quotedTable} ${quotedAlias}`);
+	var join = newJoin(context, relations, depth);
+	var where = newWhere(context, relations, null, depth);
+	return select.append(join).append(where).append(')');
+}
+
+module.exports = newFilterArg;

package/src/table/relatedTable/relatedColumn.js

@@ -2,6 +2,7 @@ var newSubFilter = require('./subFilter');
 var aggregateGroup = require('./columnAggregateGroup');
 var aggregate = require('./columnAggregate');
 var childColumn = require('./childColumn');
+var newFilterArg = require('./newFilterArg');
 
 function newRelatedColumn(column, relations, isShallow, depth) {
 	var c = {};
@@ -25,9 +26,18 @@ function newRelatedColumn(column, relations, isShallow, depth) {
 	c.max = (context, ...rest) => aggregate.apply(null, [context, 'max', column, relations, false, ...rest]);
 	c.count = (context, ...rest) => aggregate.apply(null, [context, 'count', column, relations, false, ...rest]);
 	c.self = (context, ...rest) => childColumn.apply(null, [context, column, relations, ...rest]);
+	Object.defineProperty(c, '_toFilterArg', {
+		value: toFilterArg,
+		enumerable: false,
+		writable: false
+	});
 
 	return c;
 
+	function toFilterArg(context) {
+		return newFilterArg(context, column, relations, depth);
+	}
+
 	function wrapFilter(filter) {
 		return runFilter;
 
@@ -46,4 +56,4 @@ function newRelatedColumn(column, relations, isShallow, depth) {
 
 }
 
-module.exports = newRelatedColumn;
+module.exports = newRelatedColumn;

package/src/table.js

@@ -79,6 +79,10 @@ function _new(tableName) {
 		const args = [context, table, ...rest];
 		return groupBy.apply(null, args);
 	};
+	table.distinct = function(context, ...rest) {
+		const args = [context, table, ...rest, { distinct: true }];
+		return groupBy.apply(null, args);
+	};
 
 	table.getMany.exclusive = function(context, ...rest) {
 		const args = [context, table, ...rest];