orange-orm 4.5.0-beta.0 → 4.5.0-beta.2

package/src/table/rollback.js

@@ -5,27 +5,37 @@ const popChanges = require('./popChanges');
 const newThrow = require('./newThrow');
 const resultToPromise = require('./resultToPromise');
 const conflictId = '12345678-1234-1234-1234-123456789012';
+const getSessionSingleton = require('./getSessionSingleton');
 
-function rollback(e) {
-	var executeRollback = executeQuery.bind(null, rollbackCommand);
+function _rollback(context, e) {
 	var chain = resultToPromise()
-		.then(popChanges)
+		.then(() => popChanges(context))
 		.then(executeRollback)
-		.then(releaseDbClient);
+		.then(() => releaseDbClient(context));
+
+
+	function executeRollback() {
+		const transactionLess =  getSessionSingleton(context, 'transactionLess');
+		if (transactionLess)
+			return Promise.resolve();
+		return executeQuery(context, rollbackCommand);
+	}
 
 	if (e) {
-		if (e.message.indexOf('ORA-01476: divisor is equal to zero') > -1)
-			return newThrow(new Error('Conflict when updating a column'), chain);
+		if (e.message?.indexOf('ORA-01476: divisor is equal to zero') > -1)
+			return newThrow(context, new Error('Conflict when updating a column'), chain);
 		let errors = e.message && e.message.split(conflictId) || [];
 		if (errors.length > 1) {
-			return newThrow(new Error(errors[1]), chain);
+			return newThrow(context, new Error(errors[1]), chain);
 		}
 		else
-			return newThrow(e, chain);
+			return newThrow(context, e, chain);
 	}
 	return chain;
 }
 
-module.exports = function(e) {
-	return Promise.resolve().then(() => rollback(e));
-};
+function rollback(context, e) {
+	return Promise.resolve().then(() => _rollback(context, e));
+}
+
+module.exports = rollback;

package/src/table/rowArray/negotiateNextTick.js

@@ -1,10 +1,9 @@
-var promise = require('promise/domains');
 
 function negotiateNextTick(i) {
 	if (i === 0)
 		return;
 	if (i % 1000 === 0)
-		return promise.resolve();
+		return Promise.resolve();
 	return;
 }
 

package/src/table/setSessionSingleton.js

@@ -1,5 +1,8 @@
 var getSessionContext = require('./getSessionContext');
 
-module.exports = function(name, value) {
-	getSessionContext()[name] = value;
-};
+function setSessionSingleton(context, name, value) {
+	const rdb = getSessionContext(context);
+	rdb[name] = value;
+}
+
+module.exports = setSessionSingleton;

package/src/table/tryGetFirstFromDb.js

@@ -1,8 +1,8 @@
 var getMany = require('./getMany');
 
-function tryGet(table, filter, strategy) {
+function tryGet(context, table, filter, strategy) {
 	strategy = setLimit(strategy);
-	return getMany(table, filter, strategy).then(filterRows);
+	return getMany(context, table, filter, strategy).then(filterRows);
 }
 
 function filterRows(rows) {
@@ -11,9 +11,9 @@ function filterRows(rows) {
 	return null;
 }
 
-tryGet.exclusive = function(table, filter, strategy) {
+tryGet.exclusive = function(context, table, filter, strategy) {
 	strategy = setLimit(strategy);
-	return getMany.exclusive(table, filter, strategy).then(filterRows);
+	return getMany.exclusive(context, table, filter, strategy).then(filterRows);
 };
 
 function setLimit(strategy) {

package/src/table/tryGetFromCacheById.js

@@ -1,12 +1,12 @@
-function tryGet(table) {
+function tryGet(context, table) {
 	var fakeRow = {};
 	var args = arguments;
 	table._primaryColumns.forEach(addPkValue);
 
 	function addPkValue(pkColumn, index){
-		fakeRow[pkColumn.alias] = args[index + 1];
+		fakeRow[pkColumn.alias] = args[index + 2];
 	}
 
-	return table._cache.tryGet(fakeRow);
+	return table._cache.tryGet(context, fakeRow);
 }
 module.exports = tryGet;

package/src/table/tryGetFromDbById/extractStrategy.js

@@ -1,6 +1,6 @@
 
-function extract(table) {
-	var lengthWithStrategy = table._primaryColumns.length  + 2;
+function extract(_context, table) {
+	var lengthWithStrategy = table._primaryColumns.length  + 3;
 	if (arguments.length === lengthWithStrategy)
 		return arguments[lengthWithStrategy-1];
 	return;

package/src/table/tryGetFromDbById.js

@@ -2,18 +2,20 @@ var newPrimaryKeyFilter = require('./newPrimaryKeyFilter');
 var tryGetFirstFromDb = require('./tryGetFirstFromDb');
 var extractStrategy = require('./tryGetFromDbById/extractStrategy');
 
-function tryGet() {
+function tryGet(context) {
 	var filter = newPrimaryKeyFilter.apply(null, arguments);
-	var table = arguments[0];
+	var table = arguments[1];
 	var strategy = extractStrategy.apply(null, arguments);
-	return tryGetFirstFromDb(table, filter, strategy);
+	return tryGetFirstFromDb(context, table, filter, strategy);
 }
 
-tryGet.exclusive = function tryGet() {
+tryGet.exclusive = function tryGet(context) {
 	var filter = newPrimaryKeyFilter.apply(null, arguments);
-	var table = arguments[0];
+	var table = arguments[1];
 	var strategy = extractStrategy.apply(null, arguments);
-	return tryGetFirstFromDb.exclusive(table, filter, strategy);
+	return tryGetFirstFromDb.exclusive(context, table, filter, strategy);
+
+
 };
 
 module.exports = tryGet;

package/src/table/tryGetSessionContext.js

@@ -1,16 +1,6 @@
-let useHook = require('../useHook');
-let cls;
-
-
-function tryGetSessionContext() {
-	if (useHook()) {
-		if (!cls)
-			cls = require('node-cls');
-		let context = cls.getContext('rdb');
-		return context && context.rdb;
-	}
-	else
-		return process.domain && process.domain.rdb;
+function tryGetSessionContext(context) {
+	if (context)
+		return context.rdb;
 }
 
 module.exports = tryGetSessionContext;

package/src/table/tryReleaseDbClient.js

@@ -1,8 +1,8 @@
 var release = require('./releaseDbClient');
 
-function tryReleaseDbClient() {
+function tryReleaseDbClient(context) {
 	try {
-		release();
+		release(context);
 	}
 	// eslint-disable-next-line no-empty
 	catch (e) {

package/src/table/updateField.js

@@ -2,11 +2,11 @@ var newUpdateCommand = require('./commands/newUpdateCommand');
 var pushCommand = require('./commands/pushCommand');
 var lastCommandMatches = require('./commands/lastCommandMatches');
 
-function updateField(table, column, row, oldValue) {
-	if (lastCommandMatches(row))
+function updateField(context, table, column, row) {
+	if (lastCommandMatches(context, row))
 		return;
-	var command = newUpdateCommand(table, column, row, oldValue);
-	pushCommand(command);
+	var command = newUpdateCommand(context, table, column, row);
+	pushCommand(context, command);
 }
 
 module.exports = updateField;

package/src/table/where.js

@@ -2,9 +2,9 @@ const negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
 
 function newWhere(table) {
 
-	function where(fn) {
+	function where(context, fn) {
 		let arg = typeof fn === 'function' ? fn(table) : fn;
-		return negotiateRawSqlFilter(arg);
+		return negotiateRawSqlFilter(context, arg);
 	}
 	return where;
 }

package/src/table.js

@@ -14,13 +14,10 @@ const newContext = require('./newObject');
 const insert = require('./table/insert');
 const _delete = require('./table/delete');
 const cascadeDelete = require('./table/cascadeDelete');
-const createReadStream = require('./table/createReadStream');
-const createJSONReadStream = require('./table/createJSONReadStream');
-const getIdArgs = require('./table/getIdArgs');
 const patchTable = require('./patchTable');
 const newEmitEvent = require('./emitEvent');
 const hostLocal = require('./hostLocal');
-const getTSDefinition = require('./getTSDefinition');
+// const getTSDefinition = require('./getTSDefinition'); //todo: unused ?
 const where = require('./table/where');
 const aggregate = require('./table/aggregate');
 const groupBy = require('./table/groupBy');
@@ -62,63 +59,63 @@ function _new(tableName) {
 		return hasOne(joinRelation);
 	};
 
-	table.count = function(filter) {
-		return Promise.resolve().then(() => count(table, filter));
+	table.count = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => count.apply(null, args));
 	};
 
-	table.getMany = function(filter, strategy) {
-		return Promise.resolve().then(() => getMany(table, filter, strategy));
+	table.getMany = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => getMany.apply(null, args));
 	};
-	table.getManyDto = function(filter, strategy) {
-		return Promise.resolve().then(() => getManyDto(table, filter, strategy));
+	table.getManyDto = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => getManyDto.apply(null, args));
 	};
 
-	table.aggregate = function(filter, strategy) {
-		return groupBy(table, filter, strategy);
+	table.aggregate = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return groupBy.apply(null, args);
 	};
 
-	table.getMany.exclusive = function(filter, strategy) {
-		return Promise.resolve().then(() => getMany.exclusive(table, filter, strategy));
+	table.getMany.exclusive = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => getMany.exclusive.apply(null, args));
 	};
 
-	table.tryGetFirst = function(filter, strategy) {
-		return Promise.resolve().then(() => tryGetFirst(table, filter, strategy));
+	table.tryGetFirst = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => tryGetFirst.apply(null, args));
 	};
-	table.tryGetFirst.exclusive = function(filter, strategy) {
-		return Promise.resolve().then(() => tryGetFirst.exclusive(table, filter, strategy));
+	table.tryGetFirst.exclusive = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => tryGetFirst.exclusive.apply(null, args));
 	};
+
 	table.getOne = table.tryGetFirst;
 	table.getOne.exclusive = table.tryGetFirst.exclusive;
 
-	function callAsync(func, args) {
-		return Promise.resolve().then(() => call(func, args));
-	}
-
-	function call(func, args) {
-		var mergedArgs = [table];
-		for (var i = 0; i < args.length; i++) {
-			mergedArgs.push(args[i]);
-		}
-		return func.apply(null, mergedArgs);
-	}
-
-	table.getById = function() {
-		return callAsync(getById, getIdArgs(table, arguments));
+	table.getById = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => getById.apply(null, args));
 	};
 
-	table.getById.exclusive = function() {
-
-		return callAsync(getById.exclusive, getIdArgs(table, arguments));
+	table.getById.exclusive = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => getById.exclusive.apply(null, args));
 	};
 
-	table.tryGetById = function() {
-		return callAsync(tryGetById, getIdArgs(table, arguments));
+	table.tryGetById = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => tryGetById.apply(null, args));
 	};
 
-	table.tryGetById.exclusive = function() {
-		return callAsync(tryGetById.exclusive, getIdArgs(table, arguments));
+	table.tryGetById.exclusive = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => tryGetById.exclusive.apply(null, args));
 	};
 
+
 	table.columnDiscriminators = function() {
 		for (var i = 0; i < arguments.length; i++) {
 			table._columnDiscriminators.push(arguments[i]);
@@ -133,37 +130,43 @@ function _new(tableName) {
 		return table;
 	};
 
-	table.insert = function() {
+	table.insert = function(context, ...rest) {
 		const concurrency = undefined;
-		let args = [{table, concurrency}].concat([].slice.call(arguments));
+		let args = [context, {table, concurrency}, ...rest];
 		return insert.apply(null, args);
 	};
 
-	table.insertWithConcurrency = function(options, ...rows) {
-		let args = [{table, options}].concat([].slice.call(rows));
+	table.insertWithConcurrency = function(context, options, ...rows) {
+		let args = [context, {table, options}].concat([].slice.call(rows));
 		return insert.apply(null, args);
 	};
 
 	table.delete = _delete.bind(null, table);
-	table.cascadeDelete = cascadeDelete.bind(null, table);
-	table.deleteCascade = cascadeDelete.bind(null, table);
-	table.createReadStream = createReadStream.bind(null, table);
-	table.createJSONReadStream = createJSONReadStream.bind(null, table);
+	table.cascadeDelete = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return cascadeDelete.apply(null, args);
+	};
+
+	table.deleteCascade = table.cascadeDelete;
 	table.exclusive = function() {
 		table._exclusive = true;
 		return table;
 	};
-	table.patch = patchTable.bind(null, table);
-	table.subscribeChanged = table._emitChanged.add;
-	table.unsubscribeChanged = table._emitChanged.remove;
+	table.patch = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return patchTable.apply(null, args);
+	};
+
+	// table.subscribeChanged = table._emitChanged.add; //legacy
+	// table.unsubscribeChanged = table._emitChanged.remove; //legacy
 
 	table.hostLocal = function(options) {
 		return hostLocal({table, ...options});
 	};
 
-	table.ts = function(name) {
-		return getTSDefinition(table, {name});
-	};
+	// table.ts = function(name) { //unused ?
+	// 	return getTSDefinition(table, {name});
+	// };
 
 	table.where = where(table);
 	table._aggregate = aggregate(table);

package/src/tedious/deleteFromSql.js

@@ -1,10 +1,10 @@
-var format = 'delete %s from %s as %s%s';
-var util = require('util');
-const quote = require('../table/quote');
+const format = 'delete %s from %s as %s%s';
+const formatString = require('../format');
+const quote = require('./quote');
 
 function deleteFromSql(table, alias, whereSql) {
-	var name = quote(table._dbName);
+	const name = quote(table._dbName);
 	alias = quote(alias);
-	return util.format(format, alias, name, alias, whereSql);
+	return formatString(format, alias, name, alias, whereSql);
 }
 module.exports = deleteFromSql;

package/src/tedious/formatDateOut.js

@@ -1,4 +1,4 @@
-const quote = require('../table/quote');
+const quote = require('./quote');
 
 function formatDateOut(column, alias) {
 	return `CONVERT(VARCHAR, ${alias}.${quote(column._dbName)}, 121)`;

package/src/tedious/getManyDto/newQueryCore.js

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

package/src/tedious/getManyDto/query/newSingleQuery.js

@@ -2,17 +2,17 @@ var newColumnSql = require('./singleQuery/newShallowColumnSql');
 var newWhereSql = require('../../../table/query/singleQuery/newWhereSql');
 var newParameterized = require('../../../table/query/newParameterized');
 
-function _new(table, filter, span, alias, subQueries, orderBy, limit, offset) {
-	var columnSql = newColumnSql(table, alias, span);
-	var whereSql = newWhereSql(table, filter, alias);
+function _new(context, table, filter, span, alias, subQueries, orderBy, limit, offset) {
+	var columnSql = newColumnSql(context, table, alias, span);
+	var whereSql = newWhereSql(context, table, filter, alias);
 	if (limit)
 		limit = limit + ' ';
 
 	let join = '';
 	const set = new Set();
-	for(let key in span.aggregates) {
+	for (let key in span.aggregates) {
 		const agg = span.aggregates[key];
-		for(let sql of agg.joins) {
+		for (let sql of agg.joins) {
 			if (!set.has(sql)) {
 				join = join + sql;
 				set.add(sql);

package/src/tedious/getManyDto/query/newSubQueries/joinLegToQuery.js

@@ -1,15 +1,14 @@
-var newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
-var newQuery = require('../../newQueryCore');
+const newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
 
-function joinLegToQuery(parentAlias,leg,_legNo) {
+function joinLegToQuery(newQuery, context, parentAlias, leg, _legNo) {
 	var childAlias = parentAlias + leg.name;
 	var span = leg.span;
 	var parentTable = leg.table;
 	var childColumns = span.table._primaryColumns;
 	var parentColumns = leg.columns;
 
-	var filter  = newShallowJoinSql(parentTable,childColumns,parentColumns,childAlias,parentAlias,leg.span.where);
-	var query = newQuery(span.table,filter,span,childAlias);
+	var filter = newShallowJoinSql(context, parentTable, childColumns, parentColumns, childAlias, parentAlias, leg.span.where);
+	var query = newQuery(context, span.table, filter, span, childAlias);
 	return query.prepend('JSON_QUERY((').append(` FOR JSON PATH, INCLUDE_NULL_VALUES, WITHOUT_ARRAY_WRAPPER)) "${leg.name}"`);
 }
 

package/src/tedious/getManyDto/query/newSubQueries/manyLegToQuery.js

@@ -1,15 +1,14 @@
-var newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
-var newQuery = require('../../newQueryCore');
+const newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
 
-function manyLegToQuery(rightAlias, leg, _legNo) {
+function manyLegToQuery(newQuery, context, rightAlias, leg, _legNo) {
 	var leftAlias = rightAlias + leg.name;
 	var span = leg.span;
 	var rightTable = leg.table;
 	var rightColumns = rightTable._primaryColumns;
 	var leftColumns = leg.columns;
 
-	var filter = newShallowJoinSql(rightTable, leftColumns, rightColumns, leftAlias, rightAlias, leg.span.where);
-	var query = newQuery(span.table, filter, span, leftAlias);
+	var filter = newShallowJoinSql(context, rightTable, leftColumns, rightColumns, leftAlias, rightAlias, leg.span.where);
+	var query = newQuery(context, span.table, filter, span, leftAlias);
 	return query.prepend('JSON_QUERY( coalesce((').append(` FOR JSON PATH, INCLUDE_NULL_VALUES),'[]')) "${leg.name}"`);
 }
 

package/src/tedious/getManyDto/query/newSubQueries/oneLegToQuery.js

@@ -1,19 +1,18 @@
-var newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
-var newQuery = require('../../newQueryCore');
-var newParameterized = require('../../../../table/query/newParameterized');
-var util = require('util');
+const newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
+const newParameterized = require('../../../../table/query/newParameterized');
+const formatString = require('../../../../format');
 
-function oneLegToQuery(rightAlias,leg,_legNo) {
-	var leftAlias = rightAlias + leg.name;
-	var span = leg.span;
-	var rightTable = leg.table;
-	var rightColumns = rightTable._primaryColumns;
-	var leftColumns = leg.columns;
+function oneLegToQuery(newQuery, context, rightAlias, leg, _legNo) {
+	let leftAlias = rightAlias + leg.name;
+	let span = leg.span;
+	let rightTable = leg.table;
+	let rightColumns = rightTable._primaryColumns;
+	let leftColumns = leg.columns;
 
-	var filter  = newShallowJoinSql(rightTable,leftColumns,rightColumns,leftAlias,rightAlias,leg.span.where);
-	var query = newQuery(span.table,filter,span,leftAlias);
-	var sql = 'SELECT TOP 1' + query.sql().substring(6);
-	return newParameterized(util.format('JSON_QUERY((%s FOR JSON PATH, INCLUDE_NULL_VALUES, WITHOUT_ARRAY_WRAPPER)) "%s"',sql, leg.name ), query.parameters);
+	let filter = newShallowJoinSql(context, rightTable, leftColumns, rightColumns, leftAlias, rightAlias, leg.span.where);
+	let query = newQuery(context, span.table, filter, span, leftAlias);
+	let sql = 'SELECT TOP 1' + query.sql().substring(6);
+	return newParameterized(formatString('JSON_QUERY((%s FOR JSON PATH, INCLUDE_NULL_VALUES, WITHOUT_ARRAY_WRAPPER)) "%s"', sql, leg.name), query.parameters);
 }
 
 module.exports = oneLegToQuery;

package/src/tedious/getManyDto/query/newSubQueries.js

@@ -1,26 +1,26 @@
-var joinLegToQuery = _joinLegToQuery;
-var oneLegToQuery = _oneLegToQuery;
-var manyLegToQuery = _manyLegToQuery;
-var newParameterized = require('../../../table/query/newParameterized');
+const newParameterized = require('../../../table/query/newParameterized');
+const joinLegToQuery = require('./newSubQueries/joinLegToQuery');
+const oneLegToQuery = require('./newSubQueries/oneLegToQuery');
+const manyLegToQuery = require('./newSubQueries/manyLegToQuery');
 
-function newSubQueries(_table,span,alias) {
+function newSubQueries(newQuery, context, _table, span, alias) {
 	var result = newParameterized('', []);
 	var c = {};
 	var _legNo;
 
 	c.visitJoin = function(leg) {
-		result = result.append(',').append(joinLegToQuery( alias,leg,_legNo));
+		result = result.append(',').append(joinLegToQuery(newQuery, context, alias, leg, _legNo));
 	};
 	c.visitOne = function(leg) {
-		result = result.append(',').append(oneLegToQuery( alias,leg,_legNo));
+		result = result.append(',').append(oneLegToQuery(newQuery, context, alias, leg, _legNo));
 	};
 	c.visitMany = function(leg) {
-		result = result.append(',').append(manyLegToQuery( alias,leg,_legNo));
+		result = result.append(',').append(manyLegToQuery(newQuery, context, alias, leg, _legNo));
 	};
 
 	span.legs.forEach(onEachLeg);
 
-	function onEachLeg(leg,legNo) {
+	function onEachLeg(leg, legNo) {
 		_legNo = legNo;
 		leg.accept(c);
 	}
@@ -28,21 +28,4 @@ function newSubQueries(_table,span,alias) {
 	return result;
 }
 
-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/tedious/getManyDto/query/singleQuery/newShallowColumnSql.js

@@ -1,7 +1,6 @@
-const getSessionSingleton = require('../../../../table/getSessionSingleton');
+const quote = require('../../../quote');
 
-function _new(table,alias, span) {
-	const quote = getSessionSingleton('quote');
+function _new(context, table, alias, span) {
 	alias = quote(alias);
 	let columnsMap = span.columns;
 	var columns = table._columns;
@@ -11,7 +10,7 @@ function _new(table,alias, span) {
 	for (var i = 0; i < columns.length; i++) {
 		var column = columns[i];
 		if (!columnsMap || (columnsMap.get(column))) {
-			sql = sql + separator  + formatColumn(column) + ' as ' + quote(column.alias);
+			sql = sql + separator + formatColumn(column) + ' as ' + quote(column.alias);
 			separator = ',';
 		}
 	}
@@ -24,11 +23,11 @@ function _new(table,alias, span) {
 
 	function formatColumn(column) {
 
-		const formatted = column.formatOut && column.tsType !== 'DateColumn' ? column.formatOut(alias) : alias + '.' + quote(column._dbName);
+		const formatted = column.formatOut && column.tsType !== 'DateColumn' ? column.formatOut(context, alias) : alias + '.' + quote(column._dbName);
 		if (column.dbNull === null)
 			return formatted;
 		else {
-			const encoded = column.encode.unsafe(column.dbNull);
+			const encoded = column.encode.unsafe(context, column.dbNull);
 			return `CASE WHEN ${formatted}=${encoded} THEN null ELSE ${formatted} END`;
 		}
 

package/src/tedious/getManyDto.js

@@ -3,17 +3,17 @@ const negotiateRawSqlFilter = require('../table/column/negotiateRawSqlFilter');
 const strategyToSpan = require('../table/strategyToSpan');
 const executeQueries = require('../table/executeQueries');
 
-async function getManyDto(table, filter, strategy) {
-	filter = negotiateRawSqlFilter(filter, table);
+async function getManyDto(context, table, filter, strategy) {
+	filter = negotiateRawSqlFilter(context, filter, table);
 	if (strategy && strategy.where) {
 		let arg = typeof strategy.where === 'function' ? strategy.where(table) : strategy.where;
-		filter = filter.and(arg);
+		filter = filter.and(context, arg);
 	}
-	let span = strategyToSpan(table,strategy);
+	let span = strategyToSpan(table, strategy);
 	let alias = table._dbName;
 
-	const query = newQuery(table, filter, span, alias);
-	const res =  await executeQueries([query]);
+	const query = newQuery(context, table, filter, span, alias);
+	const res = await executeQueries(context, [query]);
 	const rows = await res[0];
 	if (rows.length === 0)
 		return [];