orange-orm 3.10.2

package/src/table/createReadStreamDefault.js

@@ -0,0 +1,102 @@
+var extractFilter = require('./query/extractFilter');
+var cloneStrategy = require('./cloneStrategy');
+var defaultBatchSize = 200;
+var Readable = require('stream').Readable;
+var createBatchFilter = require('./readStreamDefault/createBatchFilter');
+
+function createReadStream(table, db, filter, strategy, streamOptions) {
+	filter = extractFilter(filter);
+	var batchFilter;
+	strategy = cloneStrategy(strategy);
+	calculateOrderBy();
+	streamOptions = streamOptions || {};
+	var batchSize = streamOptions.batchSize || defaultBatchSize;
+	batchSize = (batchSize + 1) / 2 >> 0;
+	var maxRows = strategy.limit;
+	var currentRowCount = 0;
+	var busy;
+	var waitingforMore;
+	var dtos = [];
+	var lastDto;
+	var done;
+
+	var stream = Readable({ objectMode: true });
+	stream._read = function() {
+		waitingforMore = true;
+		if (!busy) {
+			if (dtos.length > 0)
+				negotiatePushStream();
+			else
+				getDtos();
+		}
+	};
+	if (process.domain)
+		process.domain.add(stream);
+
+	function getDtos() {
+		busy = true;
+		return db.transaction(async () => {
+			await getBatch()
+				.then(onDtos);
+		})
+			.then(negotiatePushStream, onError);
+	}
+
+	function onDtos(result) {
+		busy = false;
+		currentRowCount += result.length;
+		lastDto = result[result.length - 1];
+		dtos = dtos.concat(result);
+		if (currentRowCount >= maxRows || result.length < batchSize) {
+			dtos.push(null);
+			done = true;
+		}
+	}
+
+	function negotiatePushStream() {
+		if (dtos.length <= batchSize && !done)
+			getDtos();
+		if (!waitingforMore)
+			return;
+		waitingforMore = false;
+		stream.push(dtos.shift());
+	}
+
+	function getBatch() {
+		calculateLimit();
+		calculateBatchFilter();
+		return table.getMany(batchFilter, strategy);
+	}
+
+	function calculateLimit() {
+		if (maxRows === undefined || maxRows === null)
+			strategy.limit = batchSize;
+		else {
+			var rowsLeft = maxRows - currentRowCount;
+			strategy.limit = Math.min(rowsLeft, batchSize);
+		}
+	}
+
+	function calculateOrderBy() {
+		strategy.orderBy = strategy.orderBy || [];
+		if (typeof strategy.orderBy === 'string') {
+			strategy.orderBy = [strategy.orderBy];
+		}
+		var primaryColumns = table._primaryColumns;
+		for (var i = 0; i < primaryColumns.length; i++) {
+			strategy.orderBy.push(primaryColumns[i].alias);
+		}
+	}
+
+	function calculateBatchFilter() {
+		batchFilter = createBatchFilter(table, filter, strategy, lastDto);
+	}
+
+	function onError(e) {
+		stream.emit('error', e);
+	}
+
+	return stream;
+}
+
+module.exports = createReadStream;

package/src/table/createReadStreamNative.js

@@ -0,0 +1,17 @@
+var createReadStreamCore = require('./createReadStreamCoreNative');
+var Stream = require('stream');
+
+function createReadStreamNative(table, db, filter, strategy, streamOptions) {
+	var transformer = Stream.Transform({ objectMode: true });
+	transformer._transform = function(chunk, _enc, cb) {
+		let result = chunk.result;
+		if (typeof result === 'string')
+			result = JSON.parse(result);
+		transformer.push(result);
+		cb();
+	};
+
+	return createReadStreamCore(table, db, filter, strategy, transformer, streamOptions);
+}
+
+module.exports = createReadStreamNative;

package/src/table/delete.js

@@ -0,0 +1,20 @@
+var pushCommand = require('./commands/pushCommand');
+var newDeleteCommand = require('./commands/newDeleteCommand');
+var extractDeleteStrategy = require('./extractDeleteStrategy');
+var negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
+var emptyPromise = require('./resultToPromise')();
+
+function _delete(table, filter, strategy) {
+	filter = negotiateRawSqlFilter(filter, table);
+	strategy = extractDeleteStrategy(strategy);
+	var relations = [];
+	var cmds = [];
+
+	cmds = newDeleteCommand(cmds, table, filter, strategy, relations);
+	cmds.forEach(function(cmd) {
+		pushCommand(cmd);
+	});
+	return emptyPromise;
+}
+
+module.exports = _delete;

package/src/table/deleteSessionContext.js

@@ -0,0 +1,17 @@
+let useHook = require('../useHook');
+let cls;
+
+function deleteSessionContext() {
+	if (useHook()) {
+		if (!cls)
+			cls = require('node-cls');
+		let context = cls.get('rdb');
+		delete context.rdb;
+		if (context.exit)
+			cls.exit('rdb');
+	}
+	else
+		delete process.domain.rdb;
+}
+
+module.exports = deleteSessionContext;

package/src/table/encodeDbSpecific.js

@@ -0,0 +1,10 @@
+var getSessionSingleton = require('./getSessionSingleton');
+
+function encodeDbSpecific(name, value) {
+	var encode = getSessionSingleton('encode' + name);
+	if (encode)
+		return encode(value);
+	return value;
+}
+
+module.exports = encodeDbSpecific;

package/src/table/executeQueries/executeChanges.js

@@ -0,0 +1,35 @@
+var executeQuery = require('./executeQuery');
+var newPromise = require('../promise');
+
+function executeChanges(queries) {
+	if (queries.length === 0)
+		return newPromise();
+	var i = -1;
+	return execute().then(emitChanged);
+
+
+	function execute() {
+		i++;
+		if (i + 1 === queries.length)
+			return executeQuery(queries[i]).then(notifyListener);
+		else {
+			return executeQuery(queries[i]).then(notifyListener).then(execute);
+		}
+	}
+
+	function notifyListener(result) {
+		if (result && queries[i].onResult)
+			queries[i].onResult(result);
+	}
+
+	async function emitChanged() {
+		for (let i = 0; i < queries.length; i++) {
+			if (queries[i].emitChanged)
+				await Promise.all(queries[i].emitChanged());
+		}
+	}
+
+
+}
+
+module.exports = executeChanges;

package/src/table/executeQueries/executeQueriesCore.js

@@ -0,0 +1,12 @@
+var executeQuery = require('./executeQuery');
+
+function executeQueriesCore(queries) {
+	var promises = [];
+	for (var i = 0; i < queries.length; i++) {
+		var q = executeQuery(queries[i]);
+		promises.push(q);
+	}
+	return promises;
+}
+
+module.exports = executeQueriesCore;

package/src/table/executeQueries/executeQuery.js

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

package/src/table/executeQueries/resolveExecuteQuery.js

@@ -0,0 +1,57 @@
+var getSessionSingleton = require('../getSessionSingleton');
+
+function resolveExecuteQuery(query) {
+	return resolve;
+
+	function resolve(success, failed) {
+		try {
+
+			var domain = process.domain;
+			if (domain) {
+				success = process.domain.bind(success);
+				failed = process.domain.bind(failed);
+			}
+
+			var client = getSessionSingleton('dbClient');
+			query = negotiateNullParams(query);
+			client.executeQuery(query, onCompleted);
+		} catch (e) {
+			failed(e);
+		}
+
+		function onCompleted(err, rows) {
+			if (!err)
+				success(rows);
+			else
+				failed(err);
+		}
+	}
+
+}
+
+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 = resolveExecuteQuery;

package/src/table/executeQueries.js

@@ -0,0 +1,15 @@
+var executeChanges = require('./executeQueries/executeChanges');
+var popChanges = require('./popChanges');
+var executeQueriesCore = require('./executeQueries/executeQueriesCore');
+
+function executeQueries(queries) {
+	var changes = popChanges();
+
+	return executeChanges(changes).then(onDoneChanges);
+
+	function onDoneChanges() {
+		return executeQueriesCore(queries);
+	}
+}
+
+module.exports = executeQueries;

package/src/table/extractDeleteStrategy.js

@@ -0,0 +1,9 @@
+var emptyStrategy = require('../newObject')();
+
+function extractDeleteStrategy(strategy) {
+	if (strategy)
+		return strategy;
+	return emptyStrategy;
+}
+
+module.exports = extractDeleteStrategy;

package/src/table/fuzzyPromise.js

@@ -0,0 +1,18 @@
+function fuzzyPromise(value) {
+	if (value !== undefined && value !== null)
+		Object.defineProperty(value, 'then', {
+			value: then,
+			writable: true,
+			enumerable: false,
+			configurable: true
+		});
+
+	return value;
+
+	function then(fn) {
+		delete value.then;
+		fn(value);
+	}
+}
+
+module.exports = fuzzyPromise;

package/src/table/getById.js

@@ -0,0 +1,33 @@
+let tryGetFromCacheById = require('./tryGetFromCacheById');
+let getFromDbById = require('./getFromDbById');
+let resultToPromise = require('./resultToPromise');
+let extractStrategy = require('./tryGetFromDbById/extractStrategy');
+
+async function getById() {
+	let strategy = extractStrategy.apply(null, arguments);
+	let cached =  tryGetFromCacheById.apply(null,arguments);
+	if (cached) {
+		await expand(cached, strategy);
+		return resultToPromise(cached);
+
+	}
+	return getFromDbById.apply(null,arguments);
+}
+
+getById.exclusive = getFromDbById.exclusive;
+
+async function expand(rows, strategy) {
+	if (!rows)
+		return;
+	if (!Array.isArray(rows))
+		rows = [rows];
+	for(let p in strategy) {
+		if(!(strategy[p] === null || strategy[p]))
+			continue;
+		for (let i = 0; i < rows.length; i++) {
+			await expand(await rows[i][p], strategy[p]);
+		}
+	}
+}
+
+module.exports = getById;

package/src/table/getFirstFromDb.js

@@ -0,0 +1,10 @@
+var tryGet = require('./tryGetFirstFromDb');
+
+function get()  {
+	var row = tryGet.apply(null,arguments);
+	if (row === null)
+		throw('Row not found.');
+	return row;
+}
+
+module.exports = get;

package/src/table/getFromDbById.js

@@ -0,0 +1,17 @@
+let tryGetFromDbById = require('./tryGetFromDbById');
+
+function get(table, ...ids) {
+	return tryGetFromDbById.apply(null, arguments).then((row) => onResult(table, row, ids));
+}
+
+get.exclusive = function(table, ...ids) {
+	return tryGetFromDbById.exclusive.apply(null, arguments).then((row) => onResult(table, row, ids));
+};
+
+function onResult(table, row, id) {
+	if (row === null)
+		throw new Error(`${table._dbName  }: Row with id ${id} not found.`);
+	return row;
+}
+
+module.exports = get;

package/src/table/getIdArgs.js

@@ -0,0 +1,14 @@
+var extractStrategy = require('./resultToRows/toDto/extractStrategy');
+
+function extractStrategyForId(table, args) {
+	args = [...args];
+	if (args.length <= table._primaryColumns.length)
+		return args;
+	let strategyPosition = table._primaryColumns.length;
+	let strategy = args[strategyPosition];
+	if (strategy === undefined)
+		args.splice(strategyPosition, 1, extractStrategy(table));
+	return args;
+}
+
+module.exports = extractStrategyForId;

package/src/table/getMany.js

@@ -0,0 +1,26 @@
+let newQuery = require('./newQuery');
+let executeQueries = require('./executeQueries');
+let resultToRows = require('./resultToRows');
+let strategyToSpan = require('./strategyToSpan');
+let emptyInnerJoin = require('./query/newParameterized')();
+let negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
+
+function getMany(table,filter,strategy) {
+	return getManyCore(table,filter,strategy);
+}
+
+async function getManyCore(table,filter,strategy,exclusive) {
+	let alias = table._dbName;
+	let noOrderBy;
+	filter = negotiateRawSqlFilter(filter, table);
+	let span = strategyToSpan(table,strategy);
+	let queries = newQuery([],table,filter,span,alias,emptyInnerJoin,noOrderBy,exclusive);
+	let result = await executeQueries(queries);
+	return resultToRows(span,result);
+}
+
+getMany.exclusive = function(table,filter,strategy) {
+	return getManyCore(table,filter,strategy,true);
+};
+
+module.exports = getMany;

package/src/table/getManyDto/newQuery.js

@@ -0,0 +1,32 @@
+var newPgQuery = require('./pg/newQuery');
+var getSessionContext = require('../getSessionContext');
+
+function newQuery() {
+	var c = {};
+	var _newQuery;
+
+	c.visitPg = function() {
+		_newQuery = newPgQuery;
+	};
+	c.visitMySql = function() {
+		throw new Error('MySql not supported');
+	};
+
+	c.visitSqlite = function() {
+		throw new Error('Sqlite not supported');
+	};
+
+	c.visitSap = function() {
+		throw new Error('Sap not supported');
+	};
+
+	c.visitOracle = function() {
+		throw new Error('Oracle not supported');
+	};
+
+	getSessionContext().accept(c);
+
+	return _newQuery.apply(null, arguments);
+}
+
+module.exports = newQuery;

package/src/table/getManyDto/pg/newQuery.js

@@ -0,0 +1,8 @@
+var newQueryCore = require('../../readStream/pg/newQueryCore');
+
+function newQuery() {
+	var query = newQueryCore.apply(null, arguments);
+	return query.prepend('select json_strip_nulls(coalesce(json_agg(row_to_json(r)), \'[]\')) as result from (').append(') r');
+}
+
+module.exports = newQuery;

package/src/table/getManyDto.js

@@ -0,0 +1,10 @@
+const tryGetSessionContext = require('../table/tryGetSessionContext');
+const getManyDtoCore = require('../getManyDto');
+
+
+function getManyDto(_table, _filter, _strategy) {
+	const _getManyDto = tryGetSessionContext().getManyDto || getManyDtoCore;
+	return _getManyDto.apply(null, arguments);
+}
+
+module.exports = getManyDto;

package/src/table/getManyDtoFast/getSubRows.js

@@ -0,0 +1,172 @@
+var newSingleQuery = require('./query/newSingleQuery');
+var extractOrderBy = require('../../table/query/extractOrderBy');
+var newShallowJoinSql = require('../query/singleQuery/joinSql/newShallowJoinSql');
+const executeQueries = require('../executeQueries');
+
+async function getSubRows(parentRows, filter, span, alias, innerJoin, orderBy) {
+	var promises = [];
+	var c = {};
+
+	c.visitOne = function(leg) {
+		const rightAlias = alias;
+		var nextAlias = rightAlias + '_0';
+		var parentTable = leg.table;
+		var childColumns = parentTable._primaryColumns;
+		var parentColumns = leg.columns;
+		var shallowJoin = newShallowJoinSql(parentTable, parentColumns, childColumns, nextAlias, rightAlias);
+		var nextOrderBy = orderBy + ',' + extractOrderBy(leg.span.table, nextAlias, leg.span.orderBy).substring(9);
+		var nextInnerJoin = shallowJoin.append(innerJoin);
+		var query = newSingleQuery(leg.span.table, filter, leg.span, nextAlias, nextInnerJoin, nextOrderBy);
+
+		promises.push(executeQueries([query])
+			.then(res => res[0])
+			.then(async (rows) => {
+				importOne(rows, leg);
+				await getSubRows(rows, filter, leg.span, alias + '_0', nextOrderBy);
+			}));
+	};
+
+	c.visitMany = function(leg) {
+		const rightAlias = alias;
+		var nextAlias = rightAlias + '_0';
+		var parentTable = leg.table;
+		var childColumns = parentTable._primaryColumns;
+		var parentColumns = leg.columns;
+		var shallowJoin = newShallowJoinSql(parentTable, parentColumns, childColumns, nextAlias, rightAlias);
+		var nextOrderBy = orderBy + ',' + extractOrderBy(leg.span.table, nextAlias, leg.span.orderBy).substring(9);
+		var nextInnerJoin = shallowJoin.append(innerJoin);
+		var query = newSingleQuery(leg.span.table, filter, leg.span, nextAlias, nextInnerJoin, nextOrderBy);
+
+		promises.push(executeQueries([query])
+			.then(res => res[0])
+			.then(async (rows) => {
+				importMany(rows, leg);
+				await getSubRows(rows, filter, leg.span, alias + '_0', nextInnerJoin, nextOrderBy);
+			}));
+	};
+
+	c.visitJoin = function(leg) {
+		var nextAlias = alias + '_0';
+		var span = leg.span;
+		var parentTable = leg.table;
+		var childColumns = span.table._primaryColumns;
+		var parentColumns = leg.columns;
+		var shallowJoin = newShallowJoinSql(parentTable, childColumns, parentColumns, nextAlias, alias);
+		var nextOrderBy = orderBy + ',' + extractOrderBy(leg.span.table, nextAlias, leg.span.orderBy).substring(9);
+		var nextInnerJoin = shallowJoin.append(innerJoin);
+		var query = newSingleQuery(span.table, filter, span, nextAlias, nextInnerJoin, nextOrderBy);
+
+		promises.push(executeQueries([query])
+			.then(res => res[0])
+			.then(async (rows) => {
+				importJoined(rows, leg);
+				await getSubRows(rows, filter, leg.span, alias + '_0', nextInnerJoin, nextOrderBy);
+			}));
+	};
+
+	const legs = span.legs.toArray();
+	for (let i = 0; i < legs.length; i++) {
+		legs[i].accept(c);
+		await Promise.all(promises);
+	}
+
+	function importOne(rows, leg) {
+		const prop = leg.name;
+		var parentColumns = leg.table._primaryColumns;
+		var childColumns = leg.columns;
+		importOneObjects(rows, prop, parentColumns, childColumns);
+	}
+
+	function importMany(rows, leg) {
+		const prop = leg.name;
+		var parentColumns = leg.table._primaryColumns;
+		var childColumns = leg.columns;
+		let j = 0;
+		for (let i = 0; i < parentRows.length; i++) {
+			const array = [rows[j]];
+			while (j+1 < rows.length && isChild(parentRows[i], rows[j+1], parentColumns, childColumns)) {
+				j++;
+				array.push(rows[j]);
+			}
+			parentRows[i][prop] = array;
+			j++;
+			if (j >= rows.length)
+				return;
+		}
+
+	}
+
+	function importJoined(rows, leg) {
+		const prop = leg.name;
+		var parentColumns = leg.columns;
+		var childColumns = leg.span.table._primaryColumns;
+		for (let i = 0; i < parentRows.length; i++) {
+			if (isChild(parentRows[i], rows[i], parentColumns, childColumns))
+				parentRows[i][prop] = rows[i];
+			else
+				parentRows[i][prop] = null;
+		}
+	}
+
+	function importOneObjects(rows, prop, parentColumns, childColumns) {
+		for (let i = 0; i < parentRows.length; i++) {
+			if (isChild(parentRows[i], rows[i], parentColumns, childColumns))
+				parentRows[i][prop] = rows[i];
+			else
+				parentRows[i][prop] = null;
+		}
+	}
+
+
+	// function importArrays(rows, prop, parentColumns, childColumns) {
+	// 	let j = 0;
+	// 	for (let i = 0; i < parentRows.length; i++) {
+	// 		const array = [rows[j]];
+	// 		while (isChild)
+
+	// 		// parentRows[i][prop] = [];
+	// 		// if (isChild(parentRows[i], rows[j], parentColumns, childColumns)) {
+	// 		// 	parentRows[i][prop] = rows[j];
+	// 		// 	j++;
+	// 		// 	if (j == parentRows.length)
+	// 		// 		return;
+	// 		// 	while (isChild(parentRows[i], rows[j], parentColumns, childColumns)) {
+	// 		// 		if (j == parentRows.length)
+	// 		// 			return;
+	// 		// 		parentRows[i][prop] = rows[j];
+	// 		// 		j++;
+	// 		// 	}
+	// 		// }
+	// 	}
+	// let j = 0;
+	// for (let i = 0; i < rows.length; i++) {
+	// 	const row = rows[i];
+	// 	while (j < parentRows.length && !isChild(parentRows[j], row, parentColumns, childColumns)) {
+	// 		if (!parentRows[j][prop])
+	// 			parentRows[j][prop] = [];
+	// 		j++;
+	// 	}
+	// 	if (j < parentRows.length)
+	// 		if (parentRows[j][prop])
+	// 			parentRows[j][prop].push(row);
+	// 		else
+	// 			parentRows[j][prop] = [row];
+	// 	else
+	// 		return;
+
+	// }
+	// }
+
+
+	function isChild(parentRow, row, parentColumns, childColumns) {
+		for (let i = 0; i < childColumns.length; i++) {
+			if (row[childColumns[i].alias] == parentRow[parentColumns[i].alias])
+				continue;
+			return false;
+		}
+		return true;
+	}
+
+}
+
+module.exports = getSubRows;

package/src/table/getManyDtoFast/newQuery.js

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