DISTINCT solves #119

Author: Lars-Erik Roald

src/client/index.js

@@ -212,6 +212,7 @@ function rdbClient(options = {}) {
 			count,
 			getMany,
 			aggregate: groupBy,
+			distinct,
 			getAll,
 			getOne,
 			getById,
@@ -267,9 +268,17 @@ function rdbClient(options = {}) {
 		}
 
 		async function groupBy(strategy) {
+			return executeGroupBy('aggregate', strategy);
+		}
+
+		async function distinct(strategy) {
+			return executeGroupBy('distinct', strategy);
+		}
+
+		async function executeGroupBy(path, strategy) {
 			let args = negotiateGroupBy(null, strategy);
 			let body = stringify({
-				path: 'aggregate',
+				path,
 				args
 			});
 			let adapter = netAdapter(url, tableName, { axios: axiosInterceptor, tableOptions });

src/getManyDto/query/newSingleQuery.js

@@ -4,17 +4,18 @@ var newJoinSql = require('../../table/query/singleQuery/newJoinSql');
 var newParameterized = require('../../table/query/newParameterized');
 var getSessionSingleton = require('../../table/getSessionSingleton');
 
-function _new(context,table,filter,span, alias,orderBy,limit,offset) {
+function _new(context,table,filter,span, alias,orderBy,limit,offset,distinct = false) {
 	var quote = getSessionSingleton(context, 'quote');
 	var name = quote(table._dbName);
 	var columnSql = newColumnSql(context,table,span,alias,true);
 	var joinSql = newJoinSql(context, span, alias);
 	var whereSql = newWhereSql(context,table,filter,alias);
 	if (limit)
 		limit = limit + ' ';
+	const selectClause = distinct ? 'select distinct ' : 'select ';
 
-	return newParameterized('select ' + limit + columnSql + ' from ' + name + ' ' + quote(alias)).append(joinSql).append(whereSql).append(orderBy + offset);
+	return newParameterized(selectClause + limit + columnSql + ' from ' + name + ' ' + quote(alias)).append(joinSql).append(whereSql).append(orderBy + offset);
 
 }
 
-module.exports = _new;
+module.exports = _new;

src/hostExpress/executePath.js

@@ -76,7 +76,7 @@ function _executePath(context, ...rest) {
 
 	async function executePath({ table, JSONFilter, baseFilter, customFilters = {}, request, response, readonly, disableBulkDeletes, isHttp, client }) {
 		let allowedOps = { ..._allowedOps, insert: !readonly, ...extractRelations(getMeta(table)) };
-		let ops = { ..._ops, ...getCustomFilterPaths(customFilters), getManyDto, getMany, aggregate, count, delete: _delete, cascadeDelete, update, replace };
+		let ops = { ..._ops, ...getCustomFilterPaths(customFilters), getManyDto, getMany, aggregate, distinct, count, delete: _delete, cascadeDelete, update, replace };
 
 		let res = await parseFilter(JSONFilter, table);
 		if (res === undefined)
@@ -372,6 +372,17 @@ function _executePath(context, ...rest) {
 			return table.aggregate.apply(null, args);
 		}
 
+		async function distinct(filter, strategy) {
+			validateStrategy(table, strategy);
+			filter = negotiateFilter(filter);
+			const _baseFilter = await invokeBaseFilter();
+			if (_baseFilter)
+				filter = filter.and(context, _baseFilter);
+			let args = [context, filter].concat(Array.prototype.slice.call(arguments).slice(1));
+			await negotiateWhereAndAggregate(strategy);
+			return table.distinct.apply(null, args);
+		}
+
 
 
 		async function negotiateWhereAndAggregate(strategy) {

src/hostLocal.js

@@ -5,7 +5,7 @@ let executeQuery = require('./query');
 let executeSqliteFunction = require('./sqliteFunction');
 let hostExpress = require('./hostExpress');
 let hostHono = require('./hostHono');
-const readonlyOps = ['getManyDto', 'getMany', 'aggregate', 'count'];
+const readonlyOps = ['getManyDto', 'getMany', 'aggregate', 'distinct', 'count'];
 // { db, table, defaultConcurrency,
 // 	concurrency,
 // 	customFilters,

src/map2.d.ts

@@ -696,6 +696,7 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
 
   // Aggregate methods - return plain objects (no active record methods)
   aggregate<strategy extends AggregateStrategy<M, K>>(strategy: strategy): Promise<Array<DeepExpand<AggregateCustomSelectorProperties<M, K, strategy>>>>;
+  distinct<strategy extends AggregateStrategy<M, K>>(strategy: strategy): Promise<Array<DeepExpand<AggregateCustomSelectorProperties<M, K, strategy>>>>;
 
   // Single item methods - return individual objects with individual active record methods
   getOne<strategy extends FetchStrategy<M, K>>(

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];

src/table/groupBy.js

@@ -3,7 +3,7 @@ const negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
 const strategyToSpan = require('./strategyToSpan');
 const executeQueries = require('./executeQueries');
 
-async function groupBy(context, table, filter, strategy) {
+async function groupBy(context, table, filter, strategy, options) {
 	filter = negotiateRawSqlFilter(context, filter, table);
 	if (strategy && strategy.where) {
 		let arg = typeof strategy.where === 'function' ? strategy.where(table) : strategy.where;
@@ -15,7 +15,7 @@ async function groupBy(context, table, filter, strategy) {
 
 	let alias = table._dbName;
 
-	const query = newQuery(context, table, filter, span, alias);
+	const query = newQuery(context, table, filter, span, alias, options);
 	const res = await executeQueries(context, [query]);
 	return decode(context, span, await res[0]);
 }
@@ -62,4 +62,4 @@ async function decode(context, span, rows, keys = rows.length > 0 ? Object.keys(
 	return outRows;
 }
 
-module.exports = groupBy;
+module.exports = groupBy;

src/table/groupBy/newQuery.js

@@ -4,13 +4,17 @@ var extractLimit = require('../query/extractLimit');
 var newParameterized = require('../query/newParameterized');
 var extractOffset = require('../query/extractOffset');
 
-function newQuery(context, table,filter,span,alias) {
+function newQuery(context, table,filter,span,alias,options = {}) {
 	filter = extractFilter(filter);
 	var orderBy = '';
 	var limit = extractLimit(context, span);
 	var offset = extractOffset(context, span);
+	const useDistinct = options.distinct && canUseDistinct(span);
+
+	var query = newSingleQuery(context, table,filter,span,alias,orderBy,limit,offset,useDistinct);
+	if (useDistinct)
+		return query;
 
-	var query = newSingleQuery(context, table,filter,span,alias,orderBy,limit,offset);
 	const groupClause = groupBy(span);
 	return newParameterized(query.sql(), query.parameters).append(groupClause);
 }
@@ -22,4 +26,9 @@ function groupBy(span) {
 	return ' GROUP BY ' + keys.map(key => span.aggregates[key].groupBy).join(',');
 }
 
-module.exports = newQuery;
+function canUseDistinct(span) {
+	const keys = Object.keys(span.aggregates);
+	return keys.every(key => !!span.aggregates[key].column);
+}
+
+module.exports = newQuery;

tests/aggregate.test.js

@@ -209,6 +209,63 @@ describe('count empty primary key array', () => {
 	}
 });
 
+describe('distinct', () => {
+	test('pg', async () => await verify('pg'));
+	test('pglite', async () => await verify('pglite'));
+	test('oracle', async () => await verify('oracle'));
+	test('mssql', async () => await verify('mssql'));
+	if (major === 18)
+		test('mssqlNative', async () => await verify('mssqlNative'));
+	test('mysql', async () => await verify('mysql'));
+	test('sqlite', async () => await verify('sqlite'));
+	test('sap', async () => await verify('sap'));
+	test('http', async () => await verify('http'));
+
+	async function verify(dbName) {
+		const { db } = getDb(dbName);
+
+		const rows = await db.orderLine.distinct({
+			orderId: x => x.orderId,
+		});
+
+		rows.sort((a, b) => a.orderId - b.orderId);
+
+		expect(rows).toEqual([
+			{ orderId: 1 },
+			{ orderId: 2 }
+		]);
+	}
+});
+
+describe('distinct fallback group by', () => {
+	test('pg', async () => await verify('pg'));
+	test('pglite', async () => await verify('pglite'));
+	test('oracle', async () => await verify('oracle'));
+	test('mssql', async () => await verify('mssql'));
+	if (major === 18)
+		test('mssqlNative', async () => await verify('mssqlNative'));
+	test('mysql', async () => await verify('mysql'));
+	test('sqlite', async () => await verify('sqlite'));
+	test('sap', async () => await verify('sap'));
+	test('http', async () => await verify('http'));
+
+	async function verify(dbName) {
+		const { db } = getDb(dbName);
+
+		const rows = await db.orderLine.distinct({
+			orderId: x => x.orderId,
+			count: x => x.count(x => x.id),
+		});
+
+		rows.sort((a, b) => a.orderId - b.orderId);
+
+		expect(rows).toEqual([
+			{ orderId: 1, count: 2 },
+			{ orderId: 2, count: 1 }
+		]);
+	}
+});
+
 const pathSegments = __filename.split('/');
 const lastSegment = pathSegments[pathSegments.length - 1];
 const fileNameWithoutExtension = lastSegment.split('.')[0];