orange-orm 4.8.0 → 4.8.2

package/src/table/commands/delete/singleCommand/newSingleCommandCore.js

@@ -1,19 +1,128 @@
 var getSessionSingleton = require('../../../getSessionSingleton');
+var newParameterized = require('../../../query/newParameterized');
 
-function newSingleCommandCore(context, table, filter, alias) {
+function newSingleCommandCore(context, table, filter, alias, concurrencyState) {
 	var c = {};
+	var quote = getSessionSingleton(context, 'quote');
+	var engine = getSessionSingleton(context, 'engine');
+	var concurrency = buildConcurrencyChecks(concurrencyState);
+	var parameters = filter.parameters ? filter.parameters.slice() : [];
+	if (concurrency && concurrency.parameters.length > 0)
+		parameters = parameters.concat(concurrency.parameters);
 
 	c.sql = function() {
 		var whereSql = filter.sql();
+		if (concurrency && concurrency.sql) {
+			if (whereSql)
+				whereSql += ' AND ' + concurrency.sql;
+			else
+				whereSql = concurrency.sql;
+		}
 		if (whereSql)
 			whereSql = ' where ' + whereSql;
 		var deleteFromSql = getSessionSingleton(context, 'deleteFromSql');
 		return deleteFromSql(table, alias, whereSql);
 	};
 
-	c.parameters = filter.parameters;
+	c.parameters = parameters;
 
 	return c;
+
+	function buildConcurrencyChecks(state) {
+		const columnsState = state && state.columns;
+		if (!columnsState)
+			return;
+		const parts = [];
+		const params = [];
+		for (let alias in columnsState) {
+			const columnState = columnsState[alias];
+			if (!columnState || columnState.concurrency === 'overwrite')
+				continue;
+			const column = table[alias];
+			if (!column)
+				continue;
+			const encoded = (engine === 'mysql' && column.tsType === 'JSONColumn')
+				? encodeJsonValue(columnState.oldValue, column)
+				: column.encode(context, columnState.oldValue);
+			const comparison = buildNullSafeComparison(column, encoded);
+			if (comparison.sql)
+				parts.push(comparison.sql());
+			if (comparison.parameters.length > 0)
+				params.push(...comparison.parameters);
+		}
+		if (parts.length === 0)
+			return;
+		return { sql: parts.join(' AND '), parameters: params };
+	}
+
+	function buildNullSafeComparison(column, encoded) {
+		const columnSql = quote(column._dbName);
+		if (engine === 'pg') {
+			return newParameterized(columnSql + ' IS NOT DISTINCT FROM ' + encoded.sql(), encoded.parameters);
+		}
+		if (engine === 'mysql') {
+			return newParameterized(columnSql + ' <=> ' + encoded.sql(), encoded.parameters);
+		}
+		if (engine === 'sqlite') {
+			return newParameterized(columnSql + ' IS ' + encoded.sql(), encoded.parameters);
+		}
+		if (engine === 'sap' && column.tsType === 'JSONColumn') {
+			if (encoded.sql() === 'null')
+				return newParameterized(columnSql + ' IS NULL');
+			const casted = newParameterized('CONVERT(VARCHAR(16384), ' + encoded.sql() + ')', encoded.parameters);
+			return newParameterized('CONVERT(VARCHAR(16384), ' + columnSql + ')=' + casted.sql(), casted.parameters);
+		}
+		if (engine === 'oracle' && column.tsType === 'JSONColumn') {
+			if (encoded.sql() === 'null')
+				return newParameterized(columnSql + ' IS NULL');
+			const jsonValue = newParameterized('JSON(' + encoded.sql() + ')', encoded.parameters);
+			return newParameterized('JSON_EQUAL(' + columnSql + ', ' + jsonValue.sql() + ')', jsonValue.parameters);
+		}
+		if (encoded.sql() === 'null')
+			return newParameterized(columnSql + ' IS NULL');
+		return newParameterized(columnSql + '=' + encoded.sql(), encoded.parameters);
+	}
+
+	function encodeJsonValue(value, column) {
+		if (engine === 'oracle') {
+			if (value === null || value === undefined)
+				return newParameterized('null');
+			if (isJsonObject(value))
+				return column.encode(context, value);
+			if (typeof value === 'boolean' || typeof value === 'number')
+				return newParameterized('?', [String(value)]);
+			return newParameterized('?', [value]);
+		}
+		if (engine === 'pg') {
+			const jsonValue = JSON.stringify(value === undefined ? null : value);
+			return newParameterized('?::jsonb', [jsonValue]);
+		}
+		if (engine === 'mysql') {
+			const jsonValue = JSON.stringify(value === undefined ? null : value);
+			return newParameterized('CAST(? AS JSON)', [jsonValue]);
+		}
+		if (engine === 'sqlite') {
+			if (isJsonObject(value)) {
+				const jsonValue = JSON.stringify(value);
+				return newParameterized('?', [jsonValue]);
+			}
+			if (value === null || value === undefined)
+				return newParameterized('null');
+			return newParameterized('?', [value]);
+		}
+		if (engine === 'mssql' || engine === 'mssqlNative') {
+			if (isJsonObject(value))
+				return newParameterized('JSON_QUERY(?)', [JSON.stringify(value)]);
+			if (value === null || value === undefined)
+				return newParameterized('null');
+			return newParameterized('?', [String(value)]);
+		}
+		return column.encode(context, value);
+	}
+
+	function isJsonObject(value) {
+		return value && typeof value === 'object';
+	}
 }
 
-module.exports = newSingleCommandCore;
+module.exports = newSingleCommandCore;

package/src/table/commands/newDeleteCommand.js

@@ -1,7 +1,7 @@
 var newSingleCommand = require('./delete/newSingleCommand');
 
-function newCommand(context, queries, table, filter, strategy, relations) {
-	var singleCommand = newSingleCommand(context, table, filter, relations);
+function newCommand(context, queries, table, filter, strategy, relations, concurrencyState) {
+	var singleCommand = newSingleCommand(context, table, filter, relations, concurrencyState);
 	for (var name in strategy) {
 		if (!(strategy[name] === null || strategy[name]))
 			continue;
@@ -15,4 +15,4 @@ function newCommand(context, queries, table, filter, strategy, relations) {
 	return queries;
 }
 
-module.exports = newCommand;
+module.exports = newCommand;

package/src/table/commands/newRow.js

@@ -1,7 +1,7 @@
 var decodeDbRow = require('../resultToRows/decodeDbRow');
 var flags = require('../../flags');
 
-function newRow(context, {table, _options}) {
+function newRow(context, {table, _options, shouldValidate = true}) {
 	var dto = {};
 	table._columns.forEach(addColumn);
 
@@ -41,7 +41,7 @@ function newRow(context, {table, _options}) {
 			dto[column.alias] = pkValue;
 		}
 
-	return decodeDbRow(context, table, table, dto, true, true);
+	return decodeDbRow(context, table, table, dto, shouldValidate, true);
 }
 
 function isObject(object) {

package/src/table/commands/newUpdateCommand.js

@@ -16,6 +16,9 @@ function UpdateCommand(context, table, column, row) {
 	this._columnList[column.alias] = column;
 	this.onFieldChanged = this.onFieldChanged.bind(this);
 	row.subscribeChanged(this.onFieldChanged);
+	this._concurrencyState = undefined;
+	this._concurrencySummary = undefined;
+	this._usesReturning = false;
 }
 
 UpdateCommand.prototype.onFieldChanged = function(_row, column) {
@@ -33,11 +36,20 @@ Object.defineProperty(UpdateCommand.prototype, 'parameters', {
 });
 
 UpdateCommand.prototype._getCoreCommand = function() {
-	return this.__getCoreCommand(this._table, this._columnList, this._row);
+	return this.__getCoreCommand(this._table, this._columnList, this._row, this._concurrencyState);
 };
 
 UpdateCommand.prototype.endEdit = function() {
-	this._getCoreCommand();
+	this._concurrencyState = this._row._concurrencyState;
+	delete this._row._concurrencyState;
+
+	const coreCommand = this._getCoreCommand();
+	delete this._row._jsonUpdateState;
+	this._usesReturning = Boolean(coreCommand._usesReturning);
+	this._concurrencySummary = summarizeConcurrency(this._concurrencyState);
+	if (this._concurrencySummary.hasConcurrency)
+		this.onResult = this._onConcurrencyResult.bind(this);
+
 	this._row.unsubscribeChanged(this.onFieldChanged);
 	let dto = JSON.parse(JSON.stringify(createDto(this._table, this._row)));
 	this._patch = createPatch([JSON.parse(this._row._oldValues)],[dto]);
@@ -59,4 +71,42 @@ Object.defineProperty(UpdateCommand.prototype, 'disallowCompress', {
 	}
 });
 
+UpdateCommand.prototype._onConcurrencyResult = function(result) {
+	const rowCount = extractRowCount(result, this._usesReturning);
+	if (rowCount === undefined)
+		return;
+	if (rowCount === 0 && this._concurrencySummary.hasOptimistic) {
+		throw new Error('The row was changed by another user.');
+	}
+};
+
+function summarizeConcurrency(concurrencyState) {
+	const summary = { hasConcurrency: false, hasOptimistic: false };
+	if (!concurrencyState || !concurrencyState.columns)
+		return summary;
+	for (let name in concurrencyState.columns) {
+		const state = concurrencyState.columns[name];
+		if (!state)
+			continue;
+		const strategy = state.concurrency || 'optimistic';
+		if (strategy === 'overwrite')
+			continue;
+		summary.hasConcurrency = true;
+		if (strategy === 'optimistic')
+			summary.hasOptimistic = true;
+	}
+	return summary;
+}
+
+function extractRowCount(result, usesReturning) {
+	if (usesReturning && Array.isArray(result))
+		return result.length;
+	if (Array.isArray(result) && typeof result[0].rowsAffected === 'number')
+		return result[0].rowsAffected;
+	if (!result || typeof result !== 'object')
+		return;
+	if (typeof result.rowsAffected === 'number')
+		return result.rowsAffected;
+}
+
 module.exports = newUpdateCommand;

package/src/table/commands/newUpdateCommandCore.js

@@ -1,20 +1,31 @@
 const getSessionSingleton = require('../getSessionSingleton');
 var newParameterized = require('../query/newParameterized');
+const isJsonUpdateSupported = require('../isJsonUpdateSupported');
 
-function newUpdateCommandCore(context, table, columns, row) {
+function newUpdateCommandCore(context, table, columns, row, concurrencyState) {
 	const quote = getSessionSingleton(context, 'quote');
+	const engine = getSessionSingleton(context, 'engine');
 	var command = newParameterized('UPDATE ' + quote(table._dbName) + ' SET');
 	var separator = ' ';
 
 	addColumns();
 	addWhereId();
 	addDiscriminators();
+	addConcurrencyChecks();
 
 	function addColumns() {
 		for (var alias in columns) {
 			var column = columns[alias];
-			var encoded = column.encode(context, row[alias]);
-			command = command.append(separator + quote(column._dbName) + '=').append(encoded);
+			const columnSql = quote(column._dbName);
+			const jsonUpdate = row._jsonUpdateState && row._jsonUpdateState[alias];
+			if (jsonUpdate && jsonUpdate.patches && jsonUpdate.patches.length) {
+				const updated = buildJsonUpdateExpression(columnSql, jsonUpdate.patches, column);
+				command = command.append(separator + columnSql + '=').append(updated);
+			}
+			else {
+				var encoded = column.encode(context, row[alias]);
+				command = command.append(separator + columnSql + '=').append(encoded);
+			}
 			separator = ',';
 		}
 	}
@@ -39,9 +50,301 @@ function newUpdateCommandCore(context, table, columns, row) {
 		command = command.append(discriminators);
 	}
 
+	function addConcurrencyChecks() {
+		const columnsState = concurrencyState && concurrencyState.columns;
+		if (!columnsState)
+			return;
+		for (let alias in columnsState) {
+			const state = columnsState[alias];
+			if (!state || state.concurrency === 'overwrite')
+				continue;
+			const column = table[alias];
+			if (!column)
+				continue;
+			if (state.paths && state.paths.length) {
+				for (let i = 0; i < state.paths.length; i++) {
+					const pathState = state.paths[i];
+					const encoded = encodeJsonValue(pathState.oldValue, column);
+					const jsonPath = buildJsonPath(pathState.path);
+					const columnExpr = buildJsonExtractExpression(quote(column._dbName), jsonPath, pathState.oldValue);
+					command = appendJsonPathComparison(columnExpr, encoded);
+				}
+			}
+			else {
+				const encoded = (engine === 'mysql' && column.tsType === 'JSONColumn')
+					? encodeJsonValue(state.oldValue, column)
+					: column.encode(context, state.oldValue);
+				command = appendNullSafeComparison(column, encoded);
+			}
+		}
+	}
+
+	function appendNullSafeComparison(column, encoded) {
+		const columnSql = quote(column._dbName);
+		if (engine === 'pg') {
+			command = command.append(separator + columnSql + ' IS NOT DISTINCT FROM ').append(encoded);
+		}
+		else if (engine === 'mysql') {
+			command = command.append(separator + columnSql + ' <=> ').append(encoded);
+		}
+		else if (engine === 'sqlite') {
+			command = command.append(separator + columnSql + ' IS ').append(encoded);
+		}
+		else if (engine === 'sap' && column.tsType === 'JSONColumn') {
+			if (encoded.sql() === 'null') {
+				command = command.append(separator + columnSql + ' IS NULL');
+			}
+			else {
+				const casted = newParameterized('CONVERT(VARCHAR(16384), ' + encoded.sql() + ')', encoded.parameters);
+				command = command.append(separator + 'CONVERT(VARCHAR(16384), ' + columnSql + ')=') .append(casted);
+			}
+		}
+		else if (engine === 'oracle' && column.tsType === 'JSONColumn') {
+			if (encoded.sql() === 'null') {
+				command = command.append(separator + columnSql + ' IS NULL');
+			}
+			else {
+				const jsonValue = newParameterized('JSON(' + encoded.sql() + ')', encoded.parameters);
+				const compare = newParameterized('JSON_EQUAL(' + columnSql + ', ' + jsonValue.sql() + ')', jsonValue.parameters);
+				command = command.append(separator).append(compare);
+			}
+		}
+		else {
+			if (encoded.sql() === 'null')
+				command = command.append(separator + columnSql + ' IS NULL');
+			else
+				command = command.append(separator + columnSql + '=').append(encoded);
+		}
+		separator = ' AND ';
+		return command;
+	}
+
+	function appendJsonPathComparison(columnExpr, encoded) {
+		if (engine === 'pg') {
+			command = command.append(separator).append(columnExpr).append(' IS NOT DISTINCT FROM ').append(encoded);
+		}
+		else if (engine === 'mysql') {
+			command = command.append(separator).append(columnExpr).append(' <=> ').append(encoded);
+		}
+		else if (engine === 'sqlite') {
+			command = command.append(separator).append(columnExpr).append(' IS ').append(encoded);
+		}
+		else if (engine === 'oracle') {
+			const isJsonQuery = columnExpr.sql().indexOf('JSON_QUERY(') === 0;
+			if (encoded.sql() === 'null') {
+				command = command.append(separator).append(columnExpr).append(' IS NULL');
+			}
+			else if (isJsonQuery) {
+				const jsonValue = newParameterized('JSON(' + encoded.sql() + ')', encoded.parameters);
+				const compare = newParameterized('JSON_EQUAL(' + columnExpr.sql() + ', ' + jsonValue.sql() + ')', columnExpr.parameters.concat(jsonValue.parameters));
+				command = command.append(separator).append(compare);
+			}
+			else {
+				command = command.append(separator).append(columnExpr).append('=').append(encoded);
+			}
+		}
+		else {
+			if (encoded.sql() === 'null')
+				command = command.append(separator).append(columnExpr).append(' IS NULL');
+			else
+				command = command.append(separator).append(columnExpr).append('=').append(encoded);
+		}
+		separator = ' AND ';
+		return command;
+	}
+
+	function buildJsonUpdateExpression(columnSql, patches, column) {
+		if (!isJsonUpdateSupported(engine))
+			return column.encode(context, row[column.alias]);
+		let expr = newParameterized(columnSql);
+		for (let i = 0; i < patches.length; i++) {
+			const patch = patches[i];
+			expr = applyJsonPatchExpression(expr, patch, column);
+		}
+		return expr;
+	}
+
+	function applyJsonPatchExpression(expr, patch, column) {
+		const path = patch.path || [];
+		const jsonPath = buildJsonPath(path);
+		if (patch.op === 'remove')
+			return buildJsonRemoveExpression(expr, jsonPath);
+		return buildJsonSetExpression(expr, jsonPath, patch.value, column);
+	}
+
+	function buildJsonSetExpression(expr, jsonPath, value, column) {
+		if (engine === 'pg') {
+			const pathLiteral = buildPgPathLiteral(jsonPath.tokens);
+			const jsonValue = JSON.stringify(value === undefined ? null : value);
+			const sql = 'jsonb_set(' + expr.sql() + ', ' + pathLiteral + ', ?::jsonb, true)';
+			return newParameterized(sql, expr.parameters.concat([jsonValue]));
+		}
+		if (engine === 'mysql') {
+			const jsonValue = JSON.stringify(value === undefined ? null : value);
+			const sql = 'JSON_SET(' + expr.sql() + ', ' + jsonPath.sql + ', CAST(? AS JSON))';
+			return newParameterized(sql, expr.parameters.concat(jsonPath.parameters, [jsonValue]));
+		}
+		if (engine === 'sqlite') {
+			const jsonValue = JSON.stringify(value === undefined ? null : value);
+			const sql = 'json_set(' + expr.sql() + ', ' + jsonPath.sql + ', json(?))';
+			return newParameterized(sql, expr.parameters.concat(jsonPath.parameters, [jsonValue]));
+		}
+		if (engine === 'mssql' || engine === 'mssqlNative') {
+			const mssqlValue = buildMssqlJsonValue(value);
+			const sql = 'JSON_MODIFY(' + expr.sql() + ', ' + jsonPath.sql + ', ' + mssqlValue.sql() + ')';
+			return newParameterized(sql, expr.parameters.concat(jsonPath.parameters, mssqlValue.parameters));
+		}
+		if (engine === 'oracle') {
+			const jsonValue = JSON.stringify(value === undefined ? null : value);
+			const sql = 'JSON_TRANSFORM(' + expr.sql() + ', SET ' + jsonPath.sql + ' = JSON(?))';
+			return newParameterized(sql, expr.parameters.concat(jsonPath.parameters, [jsonValue]));
+		}
+		return column.encode(context, row[column.alias]);
+	}
+
+	function buildJsonRemoveExpression(expr, jsonPath) {
+		if (engine === 'pg') {
+			const pathLiteral = buildPgPathLiteral(jsonPath.tokens);
+			const sql = expr.sql() + ' #- ' + pathLiteral;
+			return newParameterized(sql, expr.parameters);
+		}
+		if (engine === 'mysql') {
+			const sql = 'JSON_REMOVE(' + expr.sql() + ', ' + jsonPath.sql + ')';
+			return newParameterized(sql, expr.parameters.concat(jsonPath.parameters));
+		}
+		if (engine === 'sqlite') {
+			const sql = 'json_remove(' + expr.sql() + ', ' + jsonPath.sql + ')';
+			return newParameterized(sql, expr.parameters.concat(jsonPath.parameters));
+		}
+		if (engine === 'mssql' || engine === 'mssqlNative') {
+			const sql = 'JSON_MODIFY(' + expr.sql() + ', ' + jsonPath.sql + ', NULL)';
+			return newParameterized(sql, expr.parameters.concat(jsonPath.parameters));
+		}
+		if (engine === 'oracle') {
+			const sql = 'JSON_TRANSFORM(' + expr.sql() + ', REMOVE ' + jsonPath.sql + ')';
+			return newParameterized(sql, expr.parameters.concat(jsonPath.parameters));
+		}
+		return expr;
+	}
+
+	function buildJsonExtractExpression(columnSql, jsonPath, oldValue) {
+		if (engine === 'pg') {
+			const sql = columnSql + ' #> ' + buildPgPathLiteral(jsonPath.tokens);
+			return newParameterized(sql);
+		}
+		if (engine === 'mysql') {
+			const sql = 'JSON_EXTRACT(' + columnSql + ', ' + jsonPath.sql + ')';
+			return newParameterized(sql, jsonPath.parameters);
+		}
+		if (engine === 'sqlite') {
+			const sql = 'json_extract(' + columnSql + ', ' + jsonPath.sql + ')';
+			return newParameterized(sql, jsonPath.parameters);
+		}
+		if (engine === 'mssql' || engine === 'mssqlNative') {
+			const fn = isJsonObject(oldValue) ? 'JSON_QUERY' : 'JSON_VALUE';
+			const sql = fn + '(' + columnSql + ', ' + jsonPath.sql + ')';
+			return newParameterized(sql, jsonPath.parameters);
+		}
+		if (engine === 'oracle') {
+			const fn = isJsonObject(oldValue) ? 'JSON_QUERY' : 'JSON_VALUE';
+			const sql = fn + '(' + columnSql + ', ' + jsonPath.sql + ')';
+			return newParameterized(sql, jsonPath.parameters);
+		}
+		return newParameterized(columnSql);
+	}
+
+	function buildJsonPath(pathTokens) {
+		const tokens = Array.isArray(pathTokens) ? pathTokens : [];
+		if (engine === 'pg')
+			return { tokens, sql: buildPgPathLiteral(tokens), parameters: [] };
+		if (engine === 'oracle') {
+			let jsonPath = '$';
+			for (let i = 0; i < tokens.length; i++) {
+				const token = String(tokens[i]);
+				if (/^\d+$/.test(token))
+					jsonPath += '[' + token + ']';
+				else if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(token))
+					jsonPath += '.' + token;
+				else
+					jsonPath += '["' + token.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"]';
+			}
+			return { tokens, sql: '\'' + jsonPath.replace(/'/g, '\'\'') + '\'', parameters: [] };
+		}
+		let jsonPath = '$';
+		for (let i = 0; i < tokens.length; i++) {
+			const token = String(tokens[i]);
+			if (/^\d+$/.test(token))
+				jsonPath += '[' + token + ']';
+			else if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(token))
+				jsonPath += '.' + token;
+			else
+				jsonPath += '["' + token.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"]';
+		}
+		return { tokens, sql: '?', parameters: [jsonPath] };
+	}
+
+	function buildPgPathLiteral(tokens) {
+		const parts = tokens.map(token => {
+			const text = String(token);
+			if (/^[A-Za-z0-9_]+$/.test(text))
+				return text;
+			return '"' + text.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
+		});
+		return '\'{'+ parts.join(',') + '}\'';
+	}
+
+	function encodeJsonValue(value, column) {
+		if (engine === 'oracle') {
+			if (value === null || value === undefined)
+				return newParameterized('null');
+			if (isJsonObject(value))
+				return column.encode(context, value);
+			if (typeof value === 'boolean' || typeof value === 'number')
+				return newParameterized('?', [String(value)]);
+			return newParameterized('?', [value]);
+		}
+		if (engine === 'pg') {
+			const jsonValue = JSON.stringify(value === undefined ? null : value);
+			return newParameterized('?::jsonb', [jsonValue]);
+		}
+		if (engine === 'mysql') {
+			const jsonValue = JSON.stringify(value === undefined ? null : value);
+			return newParameterized('CAST(? AS JSON)', [jsonValue]);
+		}
+		if (engine === 'sqlite') {
+			if (isJsonObject(value)) {
+				const jsonValue = JSON.stringify(value);
+				return newParameterized('?', [jsonValue]);
+			}
+			if (value === null || value === undefined)
+				return newParameterized('null');
+			return newParameterized('?', [value]);
+		}
+		if (engine === 'mssql' || engine === 'mssqlNative') {
+			if (isJsonObject(value))
+				return newParameterized('JSON_QUERY(?)', [JSON.stringify(value)]);
+			if (value === null || value === undefined)
+				return newParameterized('null');
+			return newParameterized('?', [String(value)]);
+		}
+		return column.encode(context, value);
+	}
+
+	function buildMssqlJsonValue(value) {
+		if (isJsonObject(value))
+			return newParameterized('JSON_QUERY(?)', [JSON.stringify(value)]);
+		if (value === null || value === undefined)
+			return newParameterized('null');
+		return newParameterized('?', [value]);
+	}
+
+	function isJsonObject(value) {
+		return value && typeof value === 'object';
+	}
+
 	return command;
 
 
 }
 
-module.exports = newUpdateCommandCore;
+module.exports = newUpdateCommandCore;

package/src/table/executeQueries/executeChanges.js

@@ -1,4 +1,4 @@
-var executeQuery = require('./executeQuery');
+var executeCommand = require('./executeCommand');
 var newPromise = require('../promise');
 
 function executeChanges(context, queries) {
@@ -11,9 +11,9 @@ function executeChanges(context, queries) {
 	function execute() {
 		i++;
 		if (i + 1 === queries.length)
-			return executeQuery(context, queries[i]).then(notifyListener);
+			return executeCommand(context, queries[i]).then(notifyListener);
 		else {
-			return executeQuery(context, queries[i]).then(notifyListener).then(execute);
+			return executeCommand(context, queries[i]).then(notifyListener).then(execute);
 		}
 	}
 

package/src/table/executeQueries/executeCommand.js

@@ -0,0 +1,8 @@
+var newResolver = require('./resolveExecuteCommand');
+
+function executeCommand(context, query) {
+	var resolver = newResolver(context, query);
+	return new Promise(resolver);
+}
+
+module.exports = executeCommand;

package/src/table/executeQueries/negotiateNullParams.js

@@ -0,0 +1,26 @@
+function negotiateNullParams(query) {
+	if (query && query.parameters && query.parameters.length > 0 && (query.parameters.filter(x => x === null || x === undefined).length > 0)) {
+		var splitted = query.sql().split('?');
+		var sql = '';
+		var parameters = [];
+		var lastIndex = splitted.length - 1;
+		for (var i = 0; i < lastIndex; i++) {
+			if (query.parameters[i] === null || query.parameters[i] === undefined)
+				sql += splitted[i] + 'null';
+			else {
+				sql += splitted[i] + '?';
+				parameters.push(query.parameters[i]);
+			}
+		}
+		sql += splitted[lastIndex];
+		return {
+			sql: () => sql,
+			parameters
+		};
+
+	}
+	else
+		return query;
+}
+
+module.exports = negotiateNullParams;

package/src/table/executeQueries/resolveExecuteCommand.js

@@ -0,0 +1,28 @@
+const getSessionSingleton = require('../getSessionSingleton');
+const negotiateNullParams = require('./negotiateNullParams');
+
+function resolveExecuteQuery(context, query) {
+	return resolve;
+
+	function resolve(success, failed) {
+		try {
+			var client = getSessionSingleton(context, 'dbClient');
+			query = negotiateNullParams(query);
+			client.executeCommand(query, onCompleted);
+		} catch (e) {
+			failed(e);
+		}
+
+		function onCompleted(err, rows) {
+			if (!err)
+				success(rows);
+			else
+				failed(err);
+		}
+	}
+
+}
+
+
+
+module.exports = resolveExecuteQuery;