orange-orm 5.3.6 → 5.4.0

package/docs/changelog.md

@@ -1,4 +1,6 @@
 ## Changelog
+__5.4.0__  
+Support for `Select for update` and `skip locked`. [#193](https://github.com/alfateam/orange-orm/issues/193)  
 __5.3.6__  
 Fix npm package contents by excluding the demo project and local install artifacts.  
 __5.3.5__  

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "orange-orm",
-    "version": "5.3.6",
+    "version": "5.4.0",
     "publishConfig": {
         "access": "public"
     },

package/src/applyPatch.js

@@ -108,27 +108,32 @@ function applyPatch({ options = {}, context }, dto, changes, column) {
 
 }
 
-// function assertDatesEqual(date1, date2) {
-// 	if (date1 && date2) {
-// 		const parts1 = date1.split('T');
-// 		const time1parts = (parts1[1] || '').split(/[-+.]/);
-// 		const parts2 = date2.split('T');
-// 		const time2parts = (parts2[1] || '').split(/[-+.]/);
-// 		while (time1parts.length !== time2parts.length) {
-// 			if (time1parts.length > time2parts.length)
-// 				time1parts.pop();
-// 			else if (time1parts.length < time2parts.length)
-// 				time2parts.pop();
-// 		}
-// 		date1 = `${parts1[0]}T${time1parts[0]}`;
-// 		date2 = `${parts2[0]}T${time2parts[0]}`;
-// 	}
-// 	assertDeepEqual(date1, date2);
-// }
-
 function assertDeepEqual(a, b) {
-	if (JSON.stringify(a) !== JSON.stringify(b))
+	if (!deepEqual(a, b))
 		throw new Error('A, b are not equal');
 }
 
-module.exports = applyPatch;
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (a && b && typeof a === 'object' && typeof b === 'object') {
+		if (Array.isArray(a)) {
+			if (!Array.isArray(b) || a.length !== b.length) return false;
+			for (let i = 0; i < a.length; i++) {
+				if (!deepEqual(a[i], b[i])) return false;
+			}
+			return true;
+		}
+		if (Array.isArray(b)) return false;
+
+		const keysA = Object.keys(a);
+		const keysB = Object.keys(b);
+		if (keysA.length !== keysB.length) return false;
+		for (const key of keysA) {
+			if (!Object.prototype.hasOwnProperty.call(b, key) || !deepEqual(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return false;
+}
+
+module.exports = applyPatch;

package/src/client/index.js

@@ -308,7 +308,7 @@ function rdbClient(options = {}) {
 				return false;
 			if (Object.keys(value).length === 0)
 				return true;
-			if ('where' in value || 'orderBy' in value || 'limit' in value || 'offset' in value)
+			if ('where' in value || 'orderBy' in value || 'limit' in value || 'offset' in value || 'forUpdate' in value || 'skipLocked' in value)
 				return true;
 			for (let key in value) {
 				const v = value[key];
@@ -558,6 +558,7 @@ function rdbClient(options = {}) {
 
 		function proxifyArray(array, strategy, fast) {
 			let _array = array;
+			const storedStrategy = toStoredFetchStrategy(strategy);
 			if (_reactive)
 				array = _reactive(array);
 			let handler = {
@@ -585,17 +586,17 @@ function rdbClient(options = {}) {
 			};
 
 			let watcher = onChange(array, () => {
-				rootMap.set(array, { json: cloneFromDb(array, fast), strategy, originalArray: [...array] });
+				rootMap.set(array, { json: cloneFromDb(array, fast), strategy: storedStrategy, originalArray: [...array] });
 			});
 			let innerProxy = new Proxy(watcher, handler);
-			if (strategy !== undefined) {
-				const { limit, ...cleanStrategy } = { ...strategy };
-				fetchingStrategyMap.set(array, cleanStrategy);
+			if (storedStrategy !== undefined) {
+				fetchingStrategyMap.set(array, storedStrategy);
 			}
 			return innerProxy;
 		}
 
 		function proxifyRow(row, strategy, fast) {
+			const storedStrategy = toStoredFetchStrategy(strategy);
 			let handler = {
 				get(_target, property,) {
 					if (property === 'save' || property === 'saveChanges') //call server then acceptChanges
@@ -620,10 +621,10 @@ function rdbClient(options = {}) {
 
 			};
 			let watcher = onChange(row, () => {
-				rootMap.set(row, { json: cloneFromDb(row, fast), strategy });
+				rootMap.set(row, { json: cloneFromDb(row, fast), strategy: storedStrategy });
 			});
 			let innerProxy = new Proxy(watcher, handler);
-			fetchingStrategyMap.set(row, strategy);
+			fetchingStrategyMap.set(row, storedStrategy);
 			return innerProxy;
 		}
 
@@ -714,7 +715,7 @@ function rdbClient(options = {}) {
 			let insertedPositions = getInsertedRowsPosition(array);
 			let { changed, strategy: newStrategy } = await p;
 			copyIntoArray(changed, array, [...insertedPositions, ...updatedPositions]);
-			rootMap.set(array, { json: cloneFromDb(array), strategy: newStrategy, originalArray: [...array] });
+			rootMap.set(array, { json: cloneFromDb(array), strategy: toStoredFetchStrategy(newStrategy), originalArray: [...array] });
 		}
 
 		async function patch(patch, concurrencyOptions, strategy) {
@@ -776,8 +777,7 @@ function rdbClient(options = {}) {
 				let context = rootMap.get(obj);
 				if (context?.strategy !== undefined) {
 					// @ts-ignore
-					let { limit, ...strategy } = { ...context.strategy };
-					return strategy;
+					return toStoredFetchStrategy(context.strategy);
 				}
 			}
 		}
@@ -787,9 +787,24 @@ function rdbClient(options = {}) {
 				return strategy;
 			else if (fetchingStrategyMap.get(obj) !== undefined) {
 				// @ts-ignore
-				const { limit, ...strategy } = { ...fetchingStrategyMap.get(obj) };
+				return toStoredFetchStrategy(fetchingStrategyMap.get(obj));
+			}
+		}
+
+		function toStoredFetchStrategy(strategy) {
+			if (strategy === undefined || strategy === null || typeof strategy !== 'object')
 				return strategy;
+			if (Array.isArray(strategy))
+				return strategy.map(toStoredFetchStrategy);
+			const cleanStrategy = { ...strategy };
+			delete cleanStrategy.limit;
+			delete cleanStrategy.forUpdate;
+			delete cleanStrategy.skipLocked;
+			for (let name in cleanStrategy) {
+				if (name !== 'where' && cleanStrategy[name] && typeof cleanStrategy[name] === 'object')
+					cleanStrategy[name] = toStoredFetchStrategy(cleanStrategy[name]);
 			}
+			return cleanStrategy;
 		}
 
 		function clearChangesArray(array) {
@@ -880,8 +895,9 @@ function rdbClient(options = {}) {
 				array.splice(i + offset, 1);
 				offset--;
 			}
-			rootMap.set(array, { json: cloneFromDb(array), strategy, originalArray: [...array] });
-			fetchingStrategyMap.set(array, strategy);
+			const storedStrategy = toStoredFetchStrategy(strategy);
+			rootMap.set(array, { json: cloneFromDb(array), strategy: storedStrategy, originalArray: [...array] });
+			fetchingStrategyMap.set(array, storedStrategy);
 		}
 
 		async function deleteRow(row, options) {
@@ -915,7 +931,7 @@ function rdbClient(options = {}) {
 			let adapter = netAdapter(url, tableName, { http: httpInterceptor, tableOptions });
 			let { changed, strategy: newStrategy } = await adapter.patch(body);
 			copyInto(changed, [row]);
-			rootMap.set(row, { json: cloneFromDb(row), strategy: newStrategy });
+			rootMap.set(row, { json: cloneFromDb(row), strategy: toStoredFetchStrategy(newStrategy) });
 		}
 
 		async function refreshRow(row, strategy) {
@@ -939,8 +955,9 @@ function rdbClient(options = {}) {
 			for (let p in rows[0]) {
 				row[p] = rows[0][p];
 			}
-			rootMap.set(row, { json: cloneFromDb(row), strategy });
-			fetchingStrategyMap.set(row, strategy);
+			const storedStrategy = toStoredFetchStrategy(strategy);
+			rootMap.set(row, { json: cloneFromDb(row), strategy: storedStrategy });
+			fetchingStrategyMap.set(row, storedStrategy);
 		}
 
 		function acceptChangesRow(row) {

package/src/getManyDto/query/newSingleQuery.js

@@ -3,18 +3,22 @@ var newWhereSql = require('../../table/query/singleQuery/newWhereSql');
 var newJoinSql = require('../../table/query/singleQuery/newJoinSql');
 var newParameterized = require('../../table/query/newParameterized');
 var getSessionSingleton = require('../../table/getSessionSingleton');
+var lockSql = require('../../table/query/singleQuery/lockSql');
 
 function _new(context,table,filter,span, alias,orderBy,limit,offset,distinct = false) {
 	var quote = getSessionSingleton(context, 'quote');
 	var name = quote(table._dbName);
+	var quotedAlias = quote(alias);
 	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 ';
+	const lockClause = lockSql.selectLockSql(context, span, alias);
+	const tableHint = lockSql.tableHintSql(context, span);
 
-	return newParameterized(selectClause + limit + columnSql + ' from ' + name + ' ' + quote(alias)).append(joinSql).append(whereSql).append(orderBy + offset);
+	return newParameterized(selectClause + limit + columnSql + ' from ' + name + ' ' + quotedAlias + tableHint).append(joinSql).append(whereSql).append(orderBy + offset + lockClause);
 
 }
 

package/src/getTSDefinition.js

@@ -247,6 +247,8 @@ export interface ${name}Strategy {
 	offset?: number;
 	orderBy?: Array<${orderByColumns(table)}> | ${orderByColumns(table)};
 	where?: (table: ${name}TableBase) => RawFilter;
+	forUpdate?: boolean;
+	skipLocked?: boolean;
 }
 
 ${otherConcurrency}

package/src/hostExpress/executePath.js

@@ -303,7 +303,7 @@ function _executePath(context, ...rest) {
 
 		async function replace(subject, strategy = { insertAndForget: true }) {
 			validateStrategy(table, strategy);
-			const refinedStrategy = objectToStrategy(subject, {}, table);
+			const refinedStrategy = withLockingStrategy(objectToStrategy(subject, {}, table), strategy);
 			const JSONFilter2 = {
 				path: 'getManyDto',
 				args: [subject, refinedStrategy]
@@ -320,7 +320,7 @@ function _executePath(context, ...rest) {
 
 		async function update(subject, whereStrategy, strategy = { insertAndForget: true }) {
 			validateStrategy(table, strategy);
-			const refinedWhereStrategy = objectToStrategy(subject, whereStrategy, table);
+			const refinedWhereStrategy = withLockingStrategy(objectToStrategy(subject, whereStrategy, table), strategy);
 			const JSONFilter2 = {
 				path: 'getManyDto',
 				args: [null, refinedWhereStrategy]
@@ -340,6 +340,43 @@ function _executePath(context, ...rest) {
 			return changed;
 		}
 
+		function withLockingStrategy(fetchStrategy, strategy) {
+			const lockStrategy = extractLockingStrategy(strategy);
+			if (!lockStrategy)
+				return fetchStrategy;
+			return mergeLockingStrategy(fetchStrategy, lockStrategy);
+		}
+
+		function extractLockingStrategy(strategy) {
+			if (!strategy || typeof strategy !== 'object')
+				return;
+			const result = {};
+			if (strategy.forUpdate)
+				result.forUpdate = strategy.forUpdate;
+			if (strategy.skipLocked)
+				result.skipLocked = strategy.skipLocked;
+			for (let name in strategy) {
+				if (name === 'where' || name === 'orderBy' || name === 'limit' || name === 'offset' || name === 'forUpdate' || name === 'skipLocked')
+					continue;
+				const child = extractLockingStrategy(strategy[name]);
+				if (child)
+					result[name] = child;
+			}
+			return Object.keys(result).length > 0 ? result : undefined;
+		}
+
+		function mergeLockingStrategy(fetchStrategy, lockStrategy) {
+			const result = { ...fetchStrategy };
+			for (let name in lockStrategy) {
+				const value = lockStrategy[name];
+				if (name === 'forUpdate' || name === 'skipLocked')
+					result[name] = value;
+				else
+					result[name] = mergeLockingStrategy(result[name] && typeof result[name] === 'object' ? result[name] : {}, value);
+			}
+			return result;
+		}
+
 		function objectToStrategy(object, whereStrategy, table, strategy = {}) {
 			strategy = { ...whereStrategy, ...strategy };
 			if (Array.isArray(object)) {

package/src/hostLocal.js

@@ -80,7 +80,7 @@ function hostLocal() {
 				|| beforeCommit
 				|| afterCommit
 				|| afterRollback);
-			if (!hasTransactionHooks && readonlyOps.includes(body.path))
+			if (!hasTransactionHooks && readonlyOps.includes(body.path) && !hasLockingStrategy(body))
 				await db.transaction({ readonly: true }, fn);
 			else {
 				await db.transaction(async (context) => {
@@ -114,6 +114,24 @@ function hostLocal() {
 			result = await executePath(context, options);
 		}
 	}
+
+	function hasLockingStrategy(body) {
+		if (!body || !body.args)
+			return false;
+		return hasLockingStrategyCore(body.args[1]);
+	}
+
+	function hasLockingStrategyCore(strategy) {
+		if (!strategy || typeof strategy !== 'object')
+			return false;
+		if (strategy.forUpdate || strategy.skipLocked)
+			return true;
+		for (let name in strategy) {
+			if (name !== 'where' && hasLockingStrategyCore(strategy[name]))
+				return true;
+		}
+		return false;
+	}
 	async function query() {
 		let args = arguments;
 		let result;

package/src/map2.d.ts

@@ -187,7 +187,7 @@ export type OrderBy<M extends Record<string, TableDefinition<M>>, K extends keyo
     >;
 
 // Reserved property names that should not conflict with relation selectors
-type ReservedFetchStrategyProps = 'orderBy' | 'where';
+type ReservedFetchStrategyProps = 'orderBy' | 'where' | 'forUpdate' | 'skipLocked';
 
 // Base fetch strategy properties (reserved props)
 type BaseFetchStrategy<M extends Record<string, TableDefinition<M>>, K extends keyof M> = {
@@ -195,6 +195,8 @@ type BaseFetchStrategy<M extends Record<string, TableDefinition<M>>, K extends k
   limit?: number;
   offset?: number;
   where?: WhereClause<M, K>;
+  forUpdate?: boolean;
+  skipLocked?: boolean;
 };
 
 export type PrimaryKeyObject<M extends Record<string, TableDefinition<M>>, K extends keyof M> =

package/src/mySql/selectForUpdateSql.js

@@ -1,3 +1,10 @@
-module.exports = function(_alias) {
-	return ' FOR UPDATE';
-};
+module.exports = function(_context, lock) {
+	if (typeof lock === 'string')
+		lock = { forUpdate: true };
+	let sql = '';
+	if (lock.forUpdate)
+		sql += ' FOR UPDATE';
+	if (lock.skipLocked)
+		sql += ' SKIP LOCKED';
+	return sql;
+};

package/src/oracle/selectForUpdateSql.js

@@ -1,5 +1,10 @@
-const quote = require('../table/quote');
-
-module.exports = function(alias) {
-	return ' FOR UPDATE OF ' + quote(alias);
-};
+module.exports = function(_context, lock) {
+	if (typeof lock === 'string')
+		lock = { forUpdate: true };
+	let sql = '';
+	if (lock.forUpdate)
+		sql = ' FOR UPDATE';
+	if (lock.skipLocked)
+		sql += ' SKIP LOCKED';
+	return sql;
+};

package/src/patchTable.js

@@ -20,6 +20,7 @@ async function patchTableCore(context, table, patches, { strategy = undefined, d
 	const engine = getSessionSingleton(context, 'engine');
 	options = cleanOptions(options);
 	strategy = JSON.parse(JSON.stringify(strategy || {}));
+	await lockTouchedRows();
 	let changed = new Set();
 	for (let i = 0; i < patches.length; i++) {
 		let patch = { path: undefined, value: undefined, op: undefined };
@@ -39,14 +40,28 @@ async function patchTableCore(context, table, patches, { strategy = undefined, d
 	}
 	if (strategy['insertAndForget'])
 		return {
-			changed: [], strategy
+			changed: [], strategy: stripLockingStrategy(strategy)
 		};
-	return { changed: await toDtos(changed), strategy };
+	return { changed: await toDtos(changed), strategy: stripLockingStrategy(strategy) };
 
 
 	async function toDtos(set) {
 		set = [...set];
-		const result = await table.getManyDto(context, set, strategy);
+		const result = await table.getManyDto(context, set, stripLockingStrategy(strategy));
+		return result;
+	}
+
+	function stripLockingStrategy(strategy) {
+		if (!strategy || typeof strategy !== 'object')
+			return strategy;
+		if (Array.isArray(strategy))
+			return strategy.map(stripLockingStrategy);
+		const result = {};
+		for (let name in strategy) {
+			if (name === 'forUpdate' || name === 'skipLocked')
+				continue;
+			result[name] = stripLockingStrategy(strategy[name]);
+		}
 		return result;
 	}
 
@@ -57,6 +72,54 @@ async function patchTableCore(context, table, patches, { strategy = undefined, d
 			return [property];
 	}
 
+	async function lockTouchedRows() {
+		if (!hasLockingStrategy(strategy))
+			return;
+		const keys = [];
+		const keySet = new Set();
+		for (let i = 0; i < patches.length; i++) {
+			const patch = patches[i];
+			const path = patch.path.split('/').slice(1);
+			if (path.length === 0)
+				continue;
+			if (patch.op === 'add' && path.length === 1)
+				continue;
+			const key = toKey(path[0]);
+			if (isTemporaryKey(key))
+				continue;
+			const keyString = JSON.stringify(key);
+			if (keySet.has(keyString))
+				continue;
+			keySet.add(keyString);
+			keys.push(key);
+		}
+		for (let i = 0; i < keys.length; i++) {
+			const row = await table.tryGetById.apply(null, [context, ...keys[i], strategy]);
+			if (!row)
+				throw new Error(`Row ${table._dbName} with id ${keys[i]} was not found.`);
+		}
+	}
+
+	function hasLockingStrategy(strategy) {
+		if (!strategy || typeof strategy !== 'object')
+			return false;
+		if (strategy.forUpdate || strategy.skipLocked)
+			return true;
+		for (let name in strategy) {
+			if (name !== 'where' && hasLockingStrategy(strategy[name]))
+				return true;
+		}
+		return false;
+	}
+
+	function isTemporaryKey(key) {
+		for (let i = 0; i < key.length; i++) {
+			if (typeof key[i] === 'string' && key[i].indexOf('~') === 0)
+				return true;
+		}
+		return false;
+	}
+
 	async function add({ path, value, op, oldValue, strategy, options }, table, row, parentRow, relation) {
 		let property = path[0];
 		path = path.slice(1);

package/src/pg/selectForUpdateSql.js

@@ -1,5 +1,15 @@
 const quote = require('../table/quote');
 
-module.exports = function(alias) {
-	return ' FOR UPDATE OF ' + quote(alias);
-};
+module.exports = function(context, lock) {
+	if (typeof lock === 'string')
+		lock = { aliases: [lock], forUpdate: true };
+	let sql = '';
+	if (lock.forUpdate) {
+		sql = ' FOR UPDATE';
+		if (lock.aliases && lock.aliases.length > 0)
+			sql += ' OF ' + lock.aliases.map(alias => quote(context, alias)).join(', ');
+	}
+	if (lock.skipLocked)
+		sql += ' SKIP LOCKED';
+	return sql;
+};

package/src/sap/selectForUpdateSql.js

@@ -1,5 +1,5 @@
-const quote = require('../table/quote');
-
-module.exports = function(alias) {
-	return ' FOR UPDATE OF ' + quote(alias);
-};
+module.exports = function(_context, lock) {
+	if (lock)
+		throw new Error('select for update is not supported by SAP ASE');
+	return '';
+};

package/src/sqlite/selectForUpdateSql.js

@@ -1,5 +1,5 @@
-const quote = require('../table/quote');
-
-module.exports = function(context, alias) {
-	return ' FOR UPDATE OF ' + quote(context, alias);
-};
+module.exports = function(_context, lock) {
+	if (lock)
+		throw new Error('select for update is not supported by SQLite');
+	return '';
+};

package/src/table/commands/newUpdateCommandCore.js

@@ -67,7 +67,7 @@ function newUpdateCommandCore(context, table, columns, row, concurrencyState) {
 					const encoded = encodeJsonValue(pathState.oldValue, column);
 					const jsonPath = buildJsonPath(pathState.path);
 					const columnExpr = buildJsonExtractExpression(quote(column._dbName), jsonPath, pathState.oldValue);
-					command = appendJsonPathComparison(columnExpr, encoded);
+					command = appendJsonPathComparison(columnExpr, encoded, pathState.oldValue);
 				}
 			}
 			else {
@@ -127,7 +127,12 @@ function newUpdateCommandCore(context, table, columns, row, concurrencyState) {
 		return command;
 	}
 
-	function appendJsonPathComparison(columnExpr, encoded) {
+	function appendJsonPathComparison(columnExpr, encoded, oldValue) {
+		if (oldValue === undefined) {
+			command = command.append(separator).append(columnExpr).append(' IS NULL');
+			separator = ' AND ';
+			return command;
+		}
 		if (engine === 'pg') {
 			command = command.append(separator).append(columnExpr).append(' IS NOT DISTINCT FROM ').append(encoded);
 		}

package/src/table/getMany.js

@@ -19,8 +19,8 @@ async function getManyCore(context,table,filter,strategy,exclusive) {
 	return resultToRows(context, span,result);
 }
 
-getMany.exclusive = function(table,filter,strategy) {
-	return getManyCore(table,filter,strategy,true);
+getMany.exclusive = function(context,table,filter,strategy) {
+	return getManyCore(context,table,filter,strategy,true);
 };
 
 module.exports = getMany;

package/src/table/newPrimaryKeyFilter.js

@@ -2,8 +2,8 @@ function primaryKeyFilter(context, table) {
 	var primaryColumns = table._primaryColumns;
 	var key = arguments[2];
 	var filter = primaryColumns[0].equal(context, key);
-	for (var i = 2; i < primaryColumns.length; i++) {
-		key = arguments[i+1];
+	for (var i = 1; i < primaryColumns.length; i++) {
+		key = arguments[i + 2];
 		var colFilter = primaryColumns[i].equal(context, key);
 		filter = filter.and(context, colFilter);
 	}

package/src/table/query/newSingleQuery.js

@@ -2,23 +2,25 @@ 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 lockSql = require('./singleQuery/lockSql');
 var newParameterized = require('../../table/query/newParameterized');
 var quote = require('../quote');
 
 function _new(context, table, filter, span, alias, innerJoin, orderBy, limit, offset, exclusive) {
 
 	var name = quote(context, table._dbName);
+	var quotedAlias = quote(context, alias);
 	var columnSql = newColumnSql(context, table, span, alias);
 	var joinSql = newJoinSql(context, span, alias);
 	var whereSql = newWhereSql(context, table, filter, alias);
 	var safeLimit = negotiateLimit(limit);
-	var exclusiveClause = negotiateExclusive(table, alias, exclusive);
-	return newParameterized('select' + safeLimit + ' ' + columnSql + ' from ' + name + ' ' + quote(context, alias))
+	var lockClause = lockSql.selectLockSql(context, span, alias, exclusive);
+	var tableHint = lockSql.tableHintSql(context, span, exclusive);
+	return newParameterized('select' + safeLimit + ' ' + columnSql + ' from ' + name + ' ' + quotedAlias + tableHint)
 		.append(innerJoin)
 		.append(joinSql)
 		.append(whereSql)
-		.append(orderBy + offset + exclusiveClause);
+		.append(orderBy + offset + lockClause);
 }
 
-module.exports = _new;
+module.exports = _new;

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

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

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

@@ -1,11 +1,13 @@
 const newJoinCore = require('./newShallowJoinSqlCore');
 const getSessionSingleton = require('../../../getSessionSingleton');
+const lockSql = require('../lockSql');
 
-function _new(context, rightTable, leftColumns, rightColumns, leftAlias, rightAlias, filter) {
+function _new(context, rightTable, leftColumns, rightColumns, leftAlias, rightAlias, filter, span) {
 	const quote = getSessionSingleton(context, 'quote');
-	const sql = ' JOIN ' + quote(rightTable._dbName) + ' ' + quote(rightAlias) + ' ON (';
+	const tableHint = lockSql.tableHintSql(context, span);
+	const sql = ' JOIN ' + quote(rightTable._dbName) + ' ' + quote(rightAlias) + tableHint + ' ON (';
 	const joinCore = newJoinCore(context, rightTable, leftColumns, rightColumns, leftAlias, rightAlias, filter);
 	return joinCore.prepend(sql).append(')');
 }
 
-module.exports = _new;
+module.exports = _new;

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

@@ -4,7 +4,7 @@ function toJoinSql(context,leg,alias,childAlias) {
 	var parentTable = leg.table;
 	var columns = leg.columns;
 	var childTable = leg.span.table;
-	return newShallowJoinSql(context,childTable,parentTable._primaryColumns,columns,alias,childAlias, leg.span.where).prepend(' LEFT');
+	return newShallowJoinSql(context,childTable,parentTable._primaryColumns,columns,alias,childAlias, leg.span.where,leg.span).prepend(' LEFT');
 }
 
-module.exports = toJoinSql;
+module.exports = toJoinSql;