orange-orm 4.4.2 → 4.5.0-beta.1

package/src/table/relatedTable/selectSql.js

@@ -2,8 +2,8 @@ var newParameterized = require('../query/newParameterized');
 var newBoolean = require('../column/newBoolean');
 const getSessionSingleton = require('../getSessionSingleton');
 
-function newSelectSql(table, alias) {
-	const quote = getSessionSingleton('quote');
+function newSelectSql(context, table, alias) {
+	const quote = getSessionSingleton(context, 'quote');
 	const quotedAlias  = quote(alias);
 	const colName = quote(table._primaryColumns[0]._dbName);
 	const sql = 'SELECT ' + quotedAlias + '.' + colName + ' FROM ' + quote(table._dbName) + ' ' + quotedAlias;

package/src/table/relatedTable/subFilter.js

@@ -2,13 +2,13 @@ var newSelect = require('./selectSql');
 var newJoin = require('./joinSql');
 var newWhere = require('./whereSql');
 
-function newSubFilter(relations, shallowFilter, depth) {
+function newSubFilter(context, 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);
+	var exists = newSelect(context, table,alias).prepend('EXISTS (');
+	var join = newJoin(context, relations, depth);
+	var where = newWhere(context, relations,shallowFilter, depth);
 	return exists.append(join).append(where).append(')');
 
 }

package/src/table/relatedTable/where.js

@@ -4,8 +4,8 @@ let tryGetSessionContext = require('../tryGetSessionContext');
 
 function newWhere(_relations, _depth) {
 
-	function where(fn) {
-		const includeMany = tryGetSessionContext()?.engine === 'mssql';
+	function where(context, fn) {
+		const includeMany = tryGetSessionContext(context)?.engine === 'mssql';
 		let { relations, alias } = extract(includeMany, _relations);
 		const table = relations[relations.length - 1].childTable;
 		if (!relations[0].isMany || includeMany)
@@ -13,7 +13,7 @@ function newWhere(_relations, _depth) {
 
 		try {
 			let arg = typeof fn === 'function' ? fn(table) : fn;
-			let anyFilter = negotiateRawSqlFilter(arg);
+			let anyFilter = negotiateRawSqlFilter(context, arg);
 			delete table._rootAlias;
 			return anyFilter;
 		}

package/src/table/relatedTable/whereSql.js

@@ -1,6 +1,6 @@
 var newShallowJoinSql = require('../query/singleQuery/joinSql/newShallowJoinSqlCore');
 
-function newWhereSql(relations, shallowFilter, depth = 0) {
+function newWhereSql(context, relations, shallowFilter, depth = 0) {
 	let relation = relations[depth];
 	var c = {};
 	var sql;
@@ -29,7 +29,7 @@ function newWhereSql(relations, shallowFilter, depth = 0) {
 
 	function where(alias, leftColumns, rightColumns) {
 		var table = relation.childTable;
-		var joinCore = newShallowJoinSql(table, leftColumns, rightColumns, alias, 'x' + (depth + 1));
+		var joinCore = newShallowJoinSql(context, table, leftColumns, rightColumns, alias, 'x' + (depth + 1));
 		if (shallowFilter && shallowFilter.sql()) {
 			sql = joinCore.prepend(' WHERE ').append(' AND ').append(shallowFilter);
 		}

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

@@ -1,8 +1,8 @@
 var extractParentKey = require('./extractParentKey');
 
-function synchronizeAdded(action, joinRelation) {
+function synchronizeAdded(context, action, joinRelation) {
 	var cache = joinRelation.parentTable._cache;
-	cache.subscribeAdded(onAdded);
+	cache.subscribeAdded(context, onAdded);
 
 	function onAdded(child) {
 		var parent = extractParentKey(joinRelation, child);

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

@@ -1,6 +1,6 @@
 var extractParentKey = require('./extractParentKey');
 
-function synchronizeChanged(manyCache, joinRelation, parent, child) {
+function synchronizeChanged(context, manyCache, joinRelation, parent, child) {
 	var columns = joinRelation.columns;
 	columns.forEach(subscribeColumn);
 	child = null;
@@ -19,9 +19,9 @@ function synchronizeChanged(manyCache, joinRelation, parent, child) {
 
 	function onChanged(child) {
 		unsubscribe(child);
-		manyCache.tryRemove(parent, child);
+		manyCache.tryRemove(context, parent, child);
 		var newParent = extractParentKey(joinRelation, child);
-		manyCache.tryAdd(newParent, child);
+		manyCache.tryAdd(context, newParent, child);
 	}
 
 

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

@@ -1,8 +1,8 @@
 var extractParentKey = require('./extractParentKey');
 
-function synchronizeRemoved(action, joinRelation) {
+function synchronizeRemoved(context, action, joinRelation) {
 	var cache = joinRelation.parentTable._cache;
-	cache.subscribeRemoved(onRemoved);
+	cache.subscribeRemoved(context, onRemoved);
 
 	function onRemoved(child) {
 		var parent = extractParentKey(joinRelation, child);

package/src/table/relation/newForeignKeyFilter.js

@@ -1,4 +1,4 @@
-function newForeignKeyFilter(joinRelation, parentRow) {
+function newForeignKeyFilter(context, joinRelation, parentRow) {
 	var columns = joinRelation.columns;
 	var rightTable = joinRelation.childTable;
 
@@ -12,7 +12,7 @@ function newForeignKeyFilter(joinRelation, parentRow) {
 	function getNextFilterPart(index) {
 		var column = columns[index];
 		var pk = rightTable._primaryColumns[index];
-		return column.eq(parentRow[pk.alias]);
+		return column.eq(context, parentRow[pk.alias]);
 	}
 	return filter;
 }

package/src/table/relation/newManyCache.js

@@ -11,41 +11,41 @@ function newManyCache(joinRelation) {
 	var c = {};
 	var key = newId();
 
-	c.tryAdd = function(parent, child) {
-		c.getInnerCache().tryAdd(parent, child);
-		synchronizeChanged(c, joinRelation, parent, child);
+	c.tryAdd = function(context, parent, child) {
+		c.getInnerCache(context).tryAdd(parent, child);
+		synchronizeChanged(context, c, joinRelation, parent, child);
 	};
 
-	c.tryRemove = function(parent, child) {
-		c.getInnerCache().tryRemove(parent, child);
+	c.tryRemove = function(context, parent, child) {
+		c.getInnerCache(context).tryRemove(parent, child);
 	};
 
-	c.tryGet = function(parentRow) {
-		return c.getInnerCache().tryGet(parentRow);
+	c.tryGet = function(context, parentRow) {
+		return c.getInnerCache(context).tryGet(parentRow);
 	};
 
-	c.getInnerCache = function() {
-		var cache = getSessionSingleton(key);
+	c.getInnerCache = function(context) {
+		var cache = getSessionSingleton(context, key);
 		if (!cache) {
 			cache = newCacheCore(joinRelation);
-			setSessionSingleton(key, cache);
-			fillCache();
-			synchronizeAdded(c.tryAdd, joinRelation);
-			synchronizeRemoved(c.tryRemove, joinRelation);
+			setSessionSingleton(context, key, cache);
+			fillCache(context);
+			synchronizeAdded(context, c.tryAdd.bind(null, context), joinRelation);
+			synchronizeRemoved(context, c.tryRemove.bind(null, context), joinRelation);
 		}
 		return cache;
 	};
 
 
-	function fillCache() {
+	function fillCache(context) {
 		var childTable = joinRelation.parentTable;
 		var childCache = childTable._cache;
-		var children = childCache.getAll();
+		var children = childCache.getAll(context);
 		children.forEach(addToCache);
 
 		function addToCache(child) {
 			var parent = extractParentKey(joinRelation, child);
-			c.tryAdd(parent, child);
+			c.tryAdd(context, parent, child);
 		}
 	}
 

package/src/table/relation/newOneCache.js

@@ -4,18 +4,18 @@ function newOneCache(joinRelation) {
 	let c = {};
 	let cache = newManyCache(joinRelation);
 
-	c.tryGet = function(parent) {
-		let res = cache.tryGet(parent);
+	c.tryGet = function(context, parent) {
+		let res = cache.tryGet(context, parent);
 		if (res.length === 0)
 			return null;
 		return res[0];
 	};
 
-	c.getInnerCache = function() {
-		let _cache = cache.getInnerCache();
+	c.getInnerCache = function(context) {
+		let _cache = cache.getInnerCache(context);
 		let _c = {};
-		_c.tryGet = function(parent) {
-			let res = _cache.tryGet(parent);
+		_c.tryGet = function(context, parent) {
+			let res = _cache.tryGet(context, parent);
 			if (res.length === 0)
 				return null;
 			return res[0];

package/src/table/releaseDbClient.js

@@ -1,10 +1,10 @@
 var getSessionSingleton = require('./getSessionSingleton');
 var deleteSessionContext = require('./deleteSessionContext');
 
-function release() {
-	var done = getSessionSingleton('dbClientDone');
-	var pool = getSessionSingleton('pool');
-	deleteSessionContext();
+function release(context) {
+	var done = getSessionSingleton(context, 'dbClientDone');
+	var pool = getSessionSingleton(context, 'pool');
+	deleteSessionContext(context);
 	if (done)
 		done();
 	if (pool)

package/src/table/resultToPromise.js

@@ -1,8 +1,6 @@
 
-var deferred = require('deferred');
-
 function resultToPromise(result) {
-	return deferred.resolve(result);
+	return Promise.resolve(result);
 }
 
 module.exports = resultToPromise;

package/src/table/resultToRows/dbRowToRow.js

@@ -3,11 +3,11 @@ var decodeDbRow = require('./decodeDbRow');
 var nextDbRowToRow = _nextDbRowToRow;
 
 
-function dbRowToRow(span, dbRow) {
+function dbRowToRow(context, span, dbRow) {
 	var table = span.table;
-	var row = decodeDbRow(span, table, dbRow);
+	var row = decodeDbRow(context, span, table, dbRow);
 	var cache = table._cache;
-	if (!cache.tryGet(row)) {
+	if (!cache.tryGet(context, row)) {
 		var queryContext = span.queryContext;
 		negotiateQueryContext(queryContext, row);
 		Object.defineProperty(row, 'queryContext', {
@@ -17,17 +17,17 @@ function dbRowToRow(span, dbRow) {
 		});
 		row.queryContext = queryContext;
 	}
-	row = cache.tryAdd(row);
+	row = cache.tryAdd(context, row);
 
 	var c = {};
 
 	c.visitOne = function(leg) {
-		nextDbRowToRow(leg.span, dbRow);
+		nextDbRowToRow(context, leg.span, dbRow);
 		leg.expand(row);
 	};
 
 	c.visitJoin = function(leg) {
-		nextDbRowToRow(leg.span, dbRow);
+		nextDbRowToRow(context, leg.span, dbRow);
 		leg.expand(row);
 	};
 
@@ -43,9 +43,9 @@ function dbRowToRow(span, dbRow) {
 	return row;
 }
 
-function _nextDbRowToRow(span, dbRow) {
+function _nextDbRowToRow(context, span, dbRow) {
 	nextDbRowToRow = require('./dbRowToRow');
-	nextDbRowToRow(span, dbRow);
+	nextDbRowToRow(context, span, dbRow);
 }
 
 module.exports = dbRowToRow;

package/src/table/resultToRows/dbRowsToRows.js

@@ -1,10 +1,10 @@
 var dbRowToRow = require('./dbRowToRow');
 var newRowArray = require('../rowArray');
 
-function dbRowsToRows(span, dbRows) {
+function dbRowsToRows(context, span, dbRows) {
 	var rows = newRowArray();
 	for (var i = 0; i < dbRows.length; i++) {
-		var row = dbRowToRow(span, dbRows[i]);
+		var row = dbRowToRow(context, span, dbRows[i]);
 		rows.push(row);
 	}
 	return rows;

package/src/table/resultToRows/decodeDbRow.js

@@ -1,6 +1,6 @@
 var newDecodeDbRow = require('./newDecodeDbRow');
 
-function decodeDbRow(span, table, dbRow, shouldValidate, isInsert) {
+function decodeDbRow(context, span, table, dbRow, shouldValidate, isInsert) {
 	var decode = span._decodeDbRow;
 	if (!decode) {
 		let aliases = new Set();
@@ -19,7 +19,7 @@ function decodeDbRow(span, table, dbRow, shouldValidate, isInsert) {
 			},
 		});
 	}
-	return decode(dbRow);
+	return decode(context, dbRow);
 }
 
 module.exports = decodeDbRow;

package/src/table/resultToRows/delete/removeFromCache.js

@@ -1,6 +1,6 @@
 var nextRemoveFromCache = _nextRemoveFromCache;
 
-function removeFromCache(row, strategy, table) {
+function removeFromCache(context, row, strategy, table) {
 	if (Array.isArray(row)) {
 		removeManyRows();
 		return;
@@ -10,7 +10,7 @@ function removeFromCache(row, strategy, table) {
 
 	function removeManyRows() {
 		row.forEach( function(rowToRemove) {
-			nextRemoveFromCache(rowToRemove, strategy, table);
+			nextRemoveFromCache(context, rowToRemove, strategy, table);
 		});
 	}
 
@@ -19,15 +19,15 @@ function removeFromCache(row, strategy, table) {
 		for (var relationName in strategy) {
 			var relation = relations[relationName];
 			var rows = relation.getRowsSync(row);
-			nextRemoveFromCache(rows, strategy[relationName], relation.childTable);
+			nextRemoveFromCache(context, rows, strategy[relationName], relation.childTable);
 		}
-		table._cache.tryRemove(row);
+		table._cache.tryRemove(context, row);
 	}
 }
 
-function _nextRemoveFromCache(row, strategy, table) {
+function _nextRemoveFromCache(context, row, strategy, table) {
 	nextRemoveFromCache = require('./removeFromCache');
-	nextRemoveFromCache(row, strategy, table);
+	nextRemoveFromCache(context, row, strategy, table);
 }
 
 module.exports = removeFromCache;

package/src/table/resultToRows/delete.js

@@ -5,25 +5,25 @@ var newPrimaryKeyFilter = require('../newPrimaryKeyFilter');
 var createPatch = require('../../client/createPatch');
 var createDto = require('./toDto/createDto');
 
-function _delete(row, strategy, table) {
+function _delete(context, row, strategy, table) {
 	var relations = [];
-	removeFromCache(row, strategy, table);
+	removeFromCache(context, row, strategy, table);
 
-	var args = [table];
+	var args = [context, table];
 	table._primaryColumns.forEach(function(primary) {
 		args.push(row[primary.alias]);
 	});
 	var filter = newPrimaryKeyFilter.apply(null, args);
-	var cmds = newDeleteCommand([], table, filter, strategy, relations);
+	var cmds = newDeleteCommand(context, [], table, filter, strategy, relations);
 	cmds.forEach(function(cmd) {
-		pushCommand(cmd);
+		pushCommand(context, cmd);
 	});
 	var cmd = cmds[0];
 	if (table._emitChanged.callbacks.length > 0) {
 		cmd.disallowCompress = true;
 		var dto = createDto(table, row);
 		let patch =  createPatch([dto],[]);
-		cmd.emitChanged = table._emitChanged.bind(null, {row: row, patch: patch});
+		cmd.emitChanged = table._emitChanged.bind(null, {row: row, patch: patch}); //todo remove ?
 	}
 
 }

package/src/table/resultToRows/newDecodeDbRow.js

@@ -51,7 +51,7 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 				this._dbRow[key] = value;
 				if (column.validate)
 					column.validate(value, this._dbRow);
-				updateField(table, column, this);
+				updateField(this._context, table, column, this);
 				let emit = this._emitColumnChanged[name];
 				if (emit)
 					emit(this, column, value, oldValue);
@@ -114,8 +114,8 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 		let get = row._related[alias];
 		if (!get) {
 			let relation = table._relations[alias];
-			get = relation.toGetRelated(row);
-			row._relationCacheMap.set(relation, relation.getInnerCache());
+			get = relation.toGetRelated(row._context, row);
+			row._relationCacheMap.set(relation, relation.getInnerCache(row._context));
 			row._related[alias] = get;
 		}
 		return get;
@@ -144,8 +144,8 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 	};
 
 
-	Row.prototype.hydrate = function(dbRow) {
-		const engine = tryGetSessionContext()?.engine;
+	Row.prototype.hydrate = function(context, dbRow) {
+		const engine = tryGetSessionContext(context)?.engine;
 		let i = offset;
 		if (engine === 'sqlite') {
 			const errorSeparator = '12345678-1234-1234-1234-123456789012';
@@ -153,14 +153,14 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 				if (typeof dbRow[p] === 'string' && dbRow[p].indexOf(errorSeparator) === 0)
 					throw new Error(dbRow[p].split(errorSeparator)[1]);
 				let key = keys[i];
-				this._dbRow[key] = columns[i].decode(dbRow[p]);
+				this._dbRow[key] = columns[i].decode(context, dbRow[p]);
 				i++;
 			}
 		}
 		else {
 			for (let p in dbRow) {
 				let key = keys[i];
-				this._dbRow[key] = columns[i].decode(dbRow[p]);
+				this._dbRow[key] = columns[i].decode(context, dbRow[p]);
 				i++;
 			}
 		}
@@ -171,10 +171,10 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 			strategy = extractStrategy(table);
 		}
 		strategy = purifyStrategy(table, strategy);
-		if (!tryGetSessionContext()) {
-			return toDto(strategy, table, this, new Set());
+		if (!tryGetSessionContext(this._context)) {
+			return toDto(this._context, strategy, table, this, new Set());
 		}
-		let p = toDto(strategy, table, this);
+		let p = toDto(this._context, strategy, table, this);
 		return Promise.resolve().then(() => p);
 	};
 
@@ -189,18 +189,18 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 
 	Row.prototype.delete = function(strategy) {
 		strategy = extractDeleteStrategy(strategy);
-		_delete(this, strategy, table);
+		_delete(this._context, this, strategy, table);
 	};
 
 	Row.prototype.cascadeDelete = function() {
 		let strategy = newCascadeDeleteStrategy(newObject(), table);
-		_delete(this, strategy, table);
+		_delete(this._context, this, strategy, table);
 	};
 
 	Row.prototype.deleteCascade = Row.prototype.cascadeDelete;
 
 	Row.prototype.patch = async function(patches, options) {
-		await patchRow(table, this, patches, options);
+		await patchRow(this._context, table, this, patches, options);
 		return this;
 	};
 
@@ -210,16 +210,16 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 		return util.inspect(dtos, { compact: false, colors: true });
 	};
 
-	function decodeDbRow(row) {
+	function decodeDbRow(context, row) {
 		for (let i = 0; i < numberOfColumns; i++) {
 			let index = offset + i;
 			let key = keys[index];
 			if (row[key] !== undefined)
-				row[key] = columns[i].decode(row[key]);
+				row[key] = columns[i].decode(context, row[key]);
 			if (shouldValidate && columns[i].validate)
 				columns[i].validate(row[key], row, isInsert);
 		}
-		let target = new Row(row);
+		let target = new Row(context, row);
 		const p = new Proxy(target, {
 			ownKeys: function() {
 				return Array.from(aliases).concat(Object.keys(target._related).filter(alias => {
@@ -245,9 +245,10 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 		return value;
 	}
 
-	function Row(dbRow) {
+	function Row(context, dbRow) {
+		this._context = context;
 		this._relationCacheMap = new Map();
-		this._cache = table._cache.getInnerCache();
+		this._cache = table._cache.getInnerCache(context);
 		this._dbRow = dbRow;
 		this._related = {};
 		this._emitColumnChanged = {};

package/src/table/resultToRows/toDto.js

@@ -1,11 +1,11 @@
 let flags = require('../../flags');
 let tryGetSessionContext = require('../tryGetSessionContext');
 
-function toDto(strategy, table, row, joinRelationSet) {
+function toDto(context, strategy, table, row, joinRelationSet) {
 	let result;
 	flags.useProxy = false;
-	let context = tryGetSessionContext();
-	let ignoreSerializable = context && context.ignoreSerializable;
+	let rdb = tryGetSessionContext(context);
+	let ignoreSerializable = rdb && rdb.ignoreSerializable;
 	if (joinRelationSet) {
 		result = toDtoSync(table, row, joinRelationSet, strategy, ignoreSerializable);
 	}

package/src/table/resultToRows.js

@@ -1,12 +1,12 @@
 var dbRowsToRows = require('./resultToRows/dbRowsToRows');
 
-async function resultToRows(span,result) {
+async function resultToRows(context, span, result) {
 	let rows = await result[0].then(onResult);
 	await expand(spanToStrategy(span), rows);
 	return rows;
 
 	function onResult(result) {
-		return dbRowsToRows(span,result);
+		return dbRowsToRows(context, span, result);
 	}
 }
 
@@ -15,7 +15,7 @@ async function expand(strategy, rows) {
 		return;
 	if (!Array.isArray(rows))
 		rows = [rows];
-	for(let p in strategy) {
+	for (let p in strategy) {
 		if (!(strategy[p] === null || strategy[p]))
 			continue;
 		for (let i = 0; i < rows.length; i++) {

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;