orange-orm 3.10.2

package/src/tedious/formatDateOut.js

@@ -0,0 +1,5 @@
+function formatDateOut(column, alias) {
+	return `CONVERT(VARCHAR, ${alias}.${column._dbName}, 121)`;
+}
+
+module.exports = formatDateOut;

package/src/tedious/formatJSONOut.js

@@ -0,0 +1,5 @@
+function formatJSONOut(column, alias) {
+	return `JSON_QUERY(${alias}.${column._dbName})`;
+}
+
+module.exports = formatJSONOut;

package/src/tedious/getManyDto/newQuery.js

@@ -0,0 +1,8 @@
+var newQueryCore = require('./newQueryCore');
+
+function newQuery() {
+	var query = newQueryCore.apply(null, arguments);
+	return query.append(' FOR JSON path, INCLUDE_NULL_VALUES');
+}
+
+module.exports = newQuery;

package/src/tedious/getManyDto/newQueryCore.js

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

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

@@ -0,0 +1,29 @@
+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 name = table._dbName;
+	var columnSql = newColumnSql(table, alias, span);
+	var whereSql = newWhereSql(table, filter, alias);
+	if (limit)
+		limit = limit + ' ';
+
+	let join = '';
+	const set = new Set();
+	for(let key in span.aggregates) {
+		const agg = span.aggregates[key];
+		for(let sql of agg.joins) {
+			if (!set.has(sql)) {
+				join = join + sql;
+				set.add(sql);
+			}
+		}
+	}
+
+
+	return newParameterized('select ' + limit + columnSql).append(subQueries).append(' from ' + name + ' ' + alias + join).append(whereSql).append(orderBy + offset);
+}
+
+module.exports = _new;

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

@@ -0,0 +1,16 @@
+var newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
+var newQuery = require('../../newQueryCore');
+
+function joinLegToQuery(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);
+	return query.prepend('JSON_QUERY((').append(` FOR JSON PATH, INCLUDE_NULL_VALUES, WITHOUT_ARRAY_WRAPPER)) "${leg.name}"`);
+}
+
+module.exports = joinLegToQuery;

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

@@ -0,0 +1,16 @@
+var newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
+var newQuery = require('../../newQueryCore');
+
+function manyLegToQuery(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);
+	return query.prepend('JSON_QUERY( coalesce((').append(` FOR JSON PATH, INCLUDE_NULL_VALUES),'[]')) "${leg.name}"`);
+}
+
+module.exports = manyLegToQuery;

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

@@ -0,0 +1,19 @@
+var newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
+var newQuery = require('../../newQueryCore');
+var newParameterized = require('../../../../table/query/newParameterized');
+var util = require('util');
+
+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;
+
+	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);
+}
+
+module.exports = oneLegToQuery;

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

@@ -0,0 +1,48 @@
+var joinLegToQuery = _joinLegToQuery;
+var oneLegToQuery = _oneLegToQuery;
+var manyLegToQuery = _manyLegToQuery;
+var newParameterized = require('../../../table/query/newParameterized');
+
+function newSubQueries(_table,span,alias) {
+	var result = newParameterized('', []);
+	var c = {};
+	var _legNo;
+
+	c.visitJoin = function(leg) {
+		result = result.append(',').append(joinLegToQuery( alias,leg,_legNo));
+	};
+	c.visitOne = function(leg) {
+		result = result.append(',').append(oneLegToQuery( alias,leg,_legNo));
+	};
+	c.visitMany = function(leg) {
+		result = result.append(',').append(manyLegToQuery( alias,leg,_legNo));
+	};
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg,legNo) {
+		_legNo = legNo;
+		leg.accept(c);
+	}
+
+	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

@@ -0,0 +1,34 @@
+function _new(table,alias, span) {
+	let columnsMap = span.columns;
+	var columns = table._columns;
+	var sql = '';
+	var separator = '';
+
+	for (var i = 0; i < columns.length; i++) {
+		var column = columns[i];
+		if (!columnsMap || (columnsMap.get(column))) {
+			sql = sql + separator  + formatColumn(column) + ' as ' + column.alias;
+			separator = ',';
+		}
+	}
+
+	for (let name in span.aggregates || {}) {
+		sql = sql + separator + span.aggregates[name].expression(name);
+	}
+
+	return sql;
+
+	function formatColumn(column) {
+
+		const formatted = column.formatOut && column.tsType !== 'DateColumn' ? column.formatOut(alias) : alias + '.' + column._dbName;
+		if (column.dbNull === null)
+			return formatted;
+		else {
+			const encoded = column.encode.unsafe(column.dbNull);
+			return `CASE WHEN ${formatted}=${encoded} THEN null ELSE ${formatted} END`;
+		}
+
+	}
+}
+
+module.exports = _new;

package/src/tedious/getManyDto.js

@@ -0,0 +1,27 @@
+const newQuery = require('./getManyDto/newQuery');
+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);
+	if (strategy && strategy.where) {
+		let arg = typeof strategy.where === 'function' ? strategy.where(table) : strategy.where;
+		filter = filter.and(arg);
+	}
+	let span = strategyToSpan(table,strategy);
+	let alias = table._dbName;
+
+	const query = newQuery(table, filter, span, alias);
+	const res =  await executeQueries([query]);
+	const rows = await res[0];
+	if (rows.length === 0)
+		return [];
+	let json = '';
+	for (let i = 0; i < rows.length; i++) {
+		json += rows[i]['JSON_F52E2B61-18A1-11d1-B105-00805F49916B'];
+	}
+	return JSON.parse(json);
+}
+
+module.exports = getManyDto;

package/src/tedious/insert.js

@@ -0,0 +1,13 @@
+let newInsertCommand = require('../table/commands/newInsertCommand');
+let newInsertCommandCore = require('../table/commands/newInsertCommandCore');
+let executeQueries = require('../table/executeQueries');
+
+async function insertDefault(table, row, options) {
+	let insertCmd = newInsertCommand(newInsertCommandCore, table, row, options);
+	insertCmd.disallowCompress = true;
+
+	return executeQueries([insertCmd]).then((result) => result[result.length - 1]);
+
+}
+
+module.exports = insertDefault;

package/src/tedious/insertSql.js

@@ -0,0 +1,70 @@
+let outputInsertedSql = require('./outputInsertedSql');
+let mergeSql = require('./mergeSql');
+
+function getSqlTemplate(_table, _row, options) {
+	if (hasConcurrency(_table, options) && hasColumns())
+		return mergeSql.apply(null, arguments);
+	else
+		return insertSql.apply(null, arguments);
+
+	function hasColumns() {
+		for(let p in _row) {
+			let alias = _table[p]?.alias;
+			if (alias &&  _row['__' + alias] !== undefined && _table[p]?.equal)
+				return true;
+		}
+	}
+}
+
+function hasConcurrency(table,options) {
+	for (let i = 0; i < table._primaryColumns.length; i++) {
+		const concurrency = options[table._primaryColumns[i]]?.concurrency;
+		if ( concurrency === 'skipOnConflict' || concurrency === 'overwrite' )
+			return true;
+	}
+	return options.concurrency === 'skipOnConflict' || options.concurrency === 'overwrite';
+}
+
+function insertSql(table, row) {
+	let columnNames = [];
+	let regularColumnNames = [];
+	let values = [];
+	let sql = 'INSERT INTO ' + table._dbName + ' ';
+	addDiscriminators();
+	addColumns();
+	if (columnNames.length === 0)
+		sql += `${outputInserted()}DEFAULT VALUES`;
+	else
+		sql = sql + '('+ columnNames.join(',') + ')' + outputInserted() +  'VALUES (' + values.join(',') + ')';
+	return sql;
+
+	function addDiscriminators() {
+		let discriminators = table._columnDiscriminators;
+		for (let i = 0; i < discriminators.length; i++) {
+			let parts = discriminators[i].split('=');
+			columnNames.push(parts[0]);
+			values.push(parts[1]);
+		}
+	}
+
+	function addColumns() {
+		let columns = table._columns;
+		for (let i = 0; i < columns.length; i++) {
+			let column = columns[i];
+			regularColumnNames.push(column._dbName);
+			if (row['__' + column.alias] !== undefined) {
+				columnNames.push(column._dbName);
+				values.push('%s');
+			}
+		}
+	}
+
+
+	function outputInserted() {
+
+		return ' ' + outputInsertedSql(table) + ' ';
+	}
+
+}
+
+module.exports = getSqlTemplate;

package/src/tedious/limitAndOffset.js

@@ -0,0 +1,16 @@
+function limitAndOffset(span) {
+	if (span.offset)
+		return ` OFFSET ${span.offset} ROWS${limit()}`;
+	else
+		return '';
+
+	function limit() {
+		if (span.limit || span.limit === 0)
+			return ` FETCH NEXT ${span.limit} ROW ONLY`;
+		else
+			return '';
+	}
+
+}
+
+module.exports = limitAndOffset;

package/src/tedious/mergeSql.js

@@ -0,0 +1,76 @@
+const outputInsertedSql = require('./outputInsertedSql');
+
+function insertSql(table, row, options) {
+	let columnNames = [];
+	let regularColumnNames = [];
+	let conflictColumnUpdateSql = '';
+	let values = [];
+	addDiscriminators();
+	addColumns();
+
+	const matched = whenMatched();
+	let sql;
+	if (matched)
+		sql = `MERGE INTO ${table._dbName} AS target USING (SELECT ${values.join(',')}) AS source ON ${join()} WHEN MATCHED THEN ${matched} WHEN NOT MATCHED THEN ${whenNotMatched()} ${outputInsertedSql(table)};`;
+	else
+		sql = `MERGE INTO ${table._dbName} AS target USING (SELECT ${values.join(',')}) AS source ON ${join()} WHEN NOT MATCHED THEN ${whenNotMatched()} ${outputInsertedSql(table)};`;
+	return sql;
+
+	function join() {
+		const discriminators = table._columnDiscriminators.map(x => {
+			const name = x.split('=')[0];
+
+			return `target.${name}=source.${name}`;
+		});
+		const primaries = table._primaryColumns.map(x => `target.${x._dbName}=source.${x._dbName}`);
+		return [...discriminators, ...primaries].join(' AND ');
+	}
+
+	function whenMatched() {
+		if (options.concurrency === 'skipOnConflict' || options.concurrency === 'overwrite') {
+			return conflictColumnUpdateSql;
+		}
+		else return '';
+	}
+
+	function whenNotMatched() {
+		return `INSERT (${columnNames.join(',')}) VALUES (${columnNames.map(name => 'source.' + name)})`;
+	}
+
+	function addDiscriminators() {
+		let discriminators = table._columnDiscriminators;
+		for (let i = 0; i < discriminators.length; i++) {
+			let parts = discriminators[i].split('=');
+			columnNames.push(parts[0]);
+			values.push(`${parts[1]} AS ${parts[0]}`);
+		}
+	}
+
+	function addColumns() {
+		let conflictColumnUpdates = [];
+		let columns = table._columns;
+		for (let i = 0; i < columns.length; i++) {
+			let column = columns[i];
+			regularColumnNames.push(column._dbName);
+			if (row['__' + column.alias] !== undefined) {
+				columnNames.push(column._dbName);
+				values.push(`%s AS ${column.alias}`);
+				addConflictUpdate(column);
+			}
+		}
+
+		if (conflictColumnUpdates.length > 0)
+			conflictColumnUpdateSql = 'UPDATE SET ' + conflictColumnUpdates.join(',');
+
+
+		function addConflictUpdate(column) {
+			let concurrency = options[column.alias]?.concurrency || options.concurrency;
+			if (concurrency === 'overwrite')
+				conflictColumnUpdates.push(`target.${column._dbName}=source.${column._dbName}`);
+			else if (concurrency === 'optimistic')
+				conflictColumnUpdates.push(`target.${column._dbName} = CASE WHEN target.${column._dbName} <> source.${column._dbName} THEN CAST('12345678-1234-1234-1234-123456789012Conflict when updating ${column._dbName}12345678-1234-1234-1234-123456789012' AS INTEGER) ELSE target.${column._dbName} END`);
+		}
+	}
+}
+
+module.exports = insertSql;

package/src/tedious/newDatabase.js

@@ -0,0 +1,129 @@
+let createDomain = require('../createDomain');
+let newTransaction = require('./newTransaction');
+let begin = require('../table/begin');
+let commit = require('../table/commit');
+let rollback = require('../table/rollback');
+let newPool = require('./newPool');
+let useHook = require('../useHook');
+let promise = require('promise/domains');
+let versionArray = process.version.replace('v', '').split('.');
+let major = parseInt(versionArray[0]);
+let express = require('../hostExpress');
+let hostLocal = require('../hostLocal');
+let doQuery = require('../query');
+let releaseDbClient = require('../table/releaseDbClient');
+let setSessionSingleton = require('../table/setSessionSingleton');
+
+function newDatabase(connectionString, poolOptions) {
+	if (!connectionString)
+		throw new Error('Connection string cannot be empty');
+	var pool;
+	if (!poolOptions)
+		pool = newPool.bind(null,connectionString, poolOptions);
+	else
+		pool = newPool(connectionString, poolOptions);
+
+	let c = {poolFactory: pool, hostLocal, express};
+
+	c.transaction = function(options, fn) {
+		if ((arguments.length === 1) && (typeof options === 'function')) {
+			fn = options;
+			options = undefined;
+		}
+		let domain = createDomain();
+
+		if (fn)
+			return domain.run(runInTransaction);
+		else if ((major >= 12) && useHook()) {
+			domain.exitContext = true;
+			return domain.start().then(run);
+		}
+		else
+			return domain.run(run);
+
+		async function runInTransaction() {
+			let result;
+			let transaction = newTransaction(domain, pool);
+			await new Promise(transaction)
+				.then(begin)
+				.then(fn)
+				.then((res) => result = res)
+				.then(c.commit)
+				.then(null, c.rollback);
+			return result;
+		}
+
+		function run() {
+			let p;
+			let transaction = newTransaction(domain, pool);
+			if (useHook())
+				p = new Promise(transaction);
+			else
+				p = new promise(transaction);
+
+			return p.then(begin);
+		}
+
+	};
+
+	c.createTransaction = function() {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction).then(begin));
+
+		function run(fn) {
+			return p.then(domain.run.bind(domain, fn));
+		}
+		return run;
+	};
+
+	c.bindTransaction = function() {
+		// @ts-ignore
+		var domain = process.domain;
+		let p = domain.run(() => true);
+
+		function run(fn) {
+			return p.then(domain.run.bind(domain, fn));
+		}
+		return run;
+	};
+
+	c.query = function(query) {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction)
+			.then(() => setSessionSingleton('changes', []))
+			.then(() => doQuery(query).then(onResult, onError)));
+		return p;
+
+		function onResult(result) {
+			releaseDbClient();
+			return result;
+		}
+
+		function onError(e) {
+			releaseDbClient();
+			throw e;
+		}
+	};
+
+
+	c.rollback = rollback;
+	c.commit = commit;
+
+	c.end = function() {
+		if (poolOptions)
+			return pool.end();
+		else
+			return Promise.resolve();
+	};
+
+	c.accept = function(caller) {
+		caller.visitSqlite();
+	};
+
+
+	return c;
+}
+
+module.exports = newDatabase;

package/src/tedious/newPool.js

@@ -0,0 +1,19 @@
+var pools = require('../pools');
+var promise = require('../table/promise');
+var end = require('./pool/end');
+var newGenericPool = require('./pool/newGenericPool');
+var newId = require('../newId');
+
+function newPool(connectionString, poolOptions) {
+	var pool = newGenericPool(connectionString, poolOptions);
+	var id = newId();
+	var boundEnd = end.bind(null, pool, id);
+	var c = {};
+
+	c.connect = pool.connect;
+	c.end = promise.denodeify(boundEnd);
+	pools[id] = c;
+	return c;
+}
+
+module.exports = newPool;

package/src/tedious/newTransaction.js

@@ -0,0 +1,72 @@
+var wrapQuery = require('./wrapQuery');
+var encodeBoolean = require('./encodeBoolean');
+var deleteFromSql = require('./deleteFromSql');
+var selectForUpdateSql = require('./selectForUpdateSql');
+var outputInsertedSql = require('./outputInsertedSql');
+const limitAndOffset = require('./limitAndOffset');
+const getManyDto = require('./getManyDto');
+const formatDateOut = require('./formatDateOut');
+const formatJSONOut = require('./formatJSONOut');
+const insertSql = require('./insertSql');
+const insert = require('./insert');
+
+function newResolveTransaction(domain, pool) {
+	var rdb = {poolFactory: pool};
+	if (!pool.connect) {
+		pool = pool();
+		rdb.pool = pool;
+	}
+
+	return function(onSuccess, onError) {
+		pool.connect(onConnected);
+
+		function onConnected(err, client, done) {
+			try {
+				if (err) {
+					onError(err);
+					return;
+				}
+				client.executeQuery = wrapQuery(client);
+				rdb.engine = 'mssql';
+				rdb.getManyDto = getManyDto;
+				rdb.dbClient = client;
+				rdb.dbClientDone = done;
+				rdb.encodeBoolean = encodeBoolean;
+				rdb.decodeJSON = decodeJSON;
+				rdb.encodeJSON = JSON.stringify;
+				rdb.deleteFromSql = deleteFromSql;
+				rdb.selectForUpdateSql = selectForUpdateSql;
+				rdb.outputInsertedSql = outputInsertedSql;
+				rdb.lastInsertedIsSeparate = false;
+				rdb.insertSql = insertSql;
+				rdb.insert = insert;
+				rdb.formatDateOut = formatDateOut;
+				rdb.formatJSONOut = formatJSONOut;
+				rdb.multipleStatements = true;
+				rdb.begin = 'BEGIN TRANSACTION';
+				rdb.limit = (span) => {
+					if (span.offset)
+						return '';
+					else if (span.limit || span.limit === 0)
+						return 'TOP ' + span.limit;
+					else
+						return '';
+				};
+				rdb.limitAndOffset = limitAndOffset;
+				rdb.accept = function(caller) {
+					caller.visitSqlite();
+				};
+				rdb.aggregateCount = 0;
+				domain.rdb = rdb;
+				onSuccess();
+			} catch (e) {
+				onError(e);
+			}
+		}
+	};
+}
+function decodeJSON(value){
+	return JSON.parse(value);
+}
+
+module.exports = newResolveTransaction;

package/src/tedious/outputInsertedSql.js

@@ -0,0 +1,11 @@
+function outputInsertedSql(table) {
+	let separator = '';
+	let result = 'OUTPUT ';
+	for (let i = 0; i < table._columns.length; i++) {
+		result += separator + 'INSERTED.' + table._columns[i]._dbName;
+		separator = ',';
+	}
+	return result;
+}
+
+module.exports = outputInsertedSql;