orange-orm 3.10.2

package/src/table/getManyDtoFast/newQueryCore.js

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

package/src/table/getManyDtoFast/query/newSingleQuery.js

@@ -0,0 +1,20 @@
+var newColumnSql = require('./singleQuery/newShallowColumnSql');
+var newWhereSql = require('../../../table/query/singleQuery/newWhereSql');
+var negotiateLimit = require('../../../table/query/singleQuery/negotiateLimit');
+var newParameterized = require('../../../table/query/newParameterized');
+
+function _new(table, filter, span, alias, innerJoin, orderBy, limit, offset = '') {
+
+	var name = table._dbName;
+	var columnSql = newColumnSql(table, alias, span);
+	var whereSql = newWhereSql(table, filter, alias);
+	var safeLimit = negotiateLimit(limit);
+
+	return newParameterized('select ' + safeLimit + ' ' + columnSql + ' from ' + name + ' ' + alias)
+		.append(innerJoin)
+		.append(whereSql)
+		.append(orderBy + offset);
+
+}
+
+module.exports = _new;

package/src/table/getManyDtoFast/query/newSubQueries/joinLegToQuery.js

@@ -0,0 +1,18 @@
+var newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
+var newQuery = require('../../newQueryCore');
+var newParameterized = require('../../../../table/query/newParameterized');
+
+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 shallowJoin  = newShallowJoinSql(parentTable,childColumns,parentColumns,childAlias,parentAlias);
+	var filter = newParameterized(shallowJoin);
+	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/table/getManyDtoFast/query/newSubQueries/manyLegToQuery.js

@@ -0,0 +1,20 @@
+var newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
+var newQuery = require('../../newQueryCore');
+var newParameterized = require('../../../../table/query/newParameterized');
+var util = require('util');
+
+function manyLegToQuery(rightAlias, leg, legNo) {
+	var leftAlias = rightAlias + 'x' + legNo;
+	var span = leg.span;
+	var rightTable = leg.table;
+	var rightColumns = rightTable._primaryColumns;
+	var leftColumns = leg.columns;
+
+	var shallowJoin = newShallowJoinSql(rightTable, leftColumns, rightColumns, leftAlias, rightAlias);
+	var filter = newParameterized(shallowJoin);
+	var query = newQuery(span.table, filter, span, leftAlias);
+	return util.format(',JSON_QUERY( coalesce((%s FOR JSON PATH, INCLUDE_NULL_VALUES),\'[]\')) "%s"', query.sql(), leg.name);
+
+}
+
+module.exports = manyLegToQuery;

package/src/table/getManyDtoFast/query/newSubQueries/oneLegToQuery.js

@@ -0,0 +1,21 @@
+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 + 'x' + legNo;
+	var span = leg.span;
+	var rightTable = leg.table;
+	var rightColumns = rightTable._primaryColumns;
+	var leftColumns = leg.columns;
+
+	var shallowJoin  = newShallowJoinSql(rightTable,leftColumns,rightColumns,leftAlias,rightAlias);
+	var filter = newParameterized(shallowJoin);
+	var query = newQuery(span.table,filter,span,leftAlias);
+	var sql = 'SELECT TOP 1' + query.sql().substring(6);
+	return util.format(',JSON_QUERY((%s FOR JSON PATH, INCLUDE_NULL_VALUES, WITHOUT_ARRAY_WRAPPER)) "%s"',sql, leg.name );
+
+}
+
+module.exports = oneLegToQuery;

package/src/table/getManyDtoFast/query/newSubQueries.js

@@ -0,0 +1,47 @@
+var joinLegToQuery = _joinLegToQuery;
+var oneLegToQuery = _oneLegToQuery;
+var manyLegToQuery = _manyLegToQuery;
+
+function newSubQueries(table,span,alias) {
+	var result = [];
+	var c = {};
+	var _legNo;
+
+	c.visitJoin = function(leg) {
+		result.push(joinLegToQuery( alias,leg,_legNo));
+	};
+	c.visitOne = function(leg) {
+		result.push(oneLegToQuery( alias,leg,_legNo));
+	};
+	c.visitMany = function(leg) {
+		result.push(manyLegToQuery( alias,leg,_legNo));
+	};
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg,legNo) {
+		_legNo = legNo;
+		leg.accept(c);
+	}
+
+	return result.join('');
+}
+
+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/table/getManyDtoFast/query/singleQuery/newShallowColumnSql.js

@@ -0,0 +1,21 @@
+var util = require('util');
+
+function _new(table, alias, span) {
+	let columnsMap = span.columns;
+	var columnFormat = '%s as "%s"';
+	var columns = table._columns;
+	var sql = '';
+	var separator = alias + '.';
+
+
+	for (var i = 0; i < columns.length; i++) {
+		var column = columns[i];
+		if (!columnsMap || (columnsMap.get(column))) {
+			sql = sql + separator + util.format(columnFormat, column._dbName, column.alias);
+			separator = ',' + alias + '.';
+		}
+	}
+	return sql;
+}
+
+module.exports = _new;

package/src/table/getSessionContext.js

@@ -0,0 +1,10 @@
+let tryGetSessionContext = require('./tryGetSessionContext');
+
+function getSessionContext() {
+	let context = tryGetSessionContext();
+	if (!context)
+		throw new Error('Rdb transaction is no longer available. Is promise chain broken ?');
+	return context;
+}
+
+module.exports = getSessionContext;

package/src/table/getSessionSingleton.js

@@ -0,0 +1,5 @@
+var getSessionContext = require('./getSessionContext');
+
+module.exports = function(name) {
+	return getSessionContext()[name];
+};

package/src/table/groupBy/newQuery.js

@@ -0,0 +1,25 @@
+var newSingleQuery = require('../../getManyDto/query/newSingleQuery');
+var extractFilter = require('../query/extractFilter');
+var extractLimit = require('../query/extractLimit');
+var newParameterized = require('../query/newParameterized');
+var extractOffset = require('../query/extractOffset');
+
+function newQuery(table,filter,span,alias) {
+	filter = extractFilter(filter);
+	var orderBy = '';
+	var limit = extractLimit(span);
+	var offset = extractOffset(span);
+
+	var query = newSingleQuery(table,filter,span,alias,orderBy,limit,offset);
+	const groupClause = groupBy(span);
+	return newParameterized(query.sql(), query.parameters).append(groupClause);
+}
+
+function groupBy(span) {
+	const keys =  Object.keys(span.aggregates).filter(x => span.aggregates[x].column);
+	if (keys.length === 0)
+		return '';
+	return ' GROUP BY ' + keys.map(key => span.aggregates[key].groupBy).join(',');
+}
+
+module.exports = newQuery;

package/src/table/groupBy.js

@@ -0,0 +1,65 @@
+const newQuery = require('./groupBy/newQuery');
+const negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
+const strategyToSpan = require('./strategyToSpan');
+const executeQueries = require('./executeQueries');
+
+async function groupBy(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);
+	span.columns = new Map();
+
+	let alias = table._dbName;
+
+	const query = newQuery(table, filter, span, alias);
+	const res = await executeQueries([query]);
+	return decode(span, await res[0]);
+}
+
+function newCreateRow(span) {
+	const protoRow = createProto(span);
+
+	return createRow;
+
+	function createRow() {
+		return Object.create(protoRow);
+	}
+}
+
+function createProto(span) {
+	let obj = {};
+	for (let key in span.aggregates) {
+		obj[key] = null;
+	}
+
+	return obj;
+}
+
+
+async function decode(span, rows, keys = rows.length > 0 ? Object.keys(rows[0]) : []) {
+	const rowsLength = rows.length;
+	const aggregateKeys = Object.keys(span.aggregates);
+
+	const outRows = new Array(rowsLength);
+	const createRow = newCreateRow(span);
+	for (let i = 0; i < rowsLength; i++) {
+		const row = rows[i];
+		let outRow = createRow();
+
+		for (let j = 0; j < aggregateKeys.length; j++) {
+			const key = aggregateKeys[j];
+			const parse = span.aggregates[key].column?.decode || Number.parseFloat;
+			outRow[key] =  parse(row[keys[j]]);
+		}
+
+		outRows[i] = outRow;
+	}
+
+	return outRows;
+}
+
+module.exports = groupBy;

package/src/table/hasMany.js

@@ -0,0 +1,33 @@
+var newManyRelation = require('./newManyRelation');
+var newRelatedTable = require('./newRelatedTable');
+
+function newOne(joinRelation) {
+	var c = {};
+	var parentTable = joinRelation.childTable;
+
+	c.as = function(alias) {
+		joinRelation.rightAlias = alias;
+		var relation = newManyRelation(joinRelation);
+		parentTable._relations[alias] = relation;
+
+		Object.defineProperty(parentTable, alias, {
+			get: function() {
+				return newRelatedTable([relation]);
+			}
+		});
+
+		return relation;
+	};
+
+	c.notNullExceptInsert = function() {
+		return c;
+	};
+
+	c.notNull = function() {
+		return c;
+	};
+
+	return c;
+}
+
+module.exports = newOne;

package/src/table/hasOne.js

@@ -0,0 +1,33 @@
+var newOneRelation = require('./newOneRelation');
+var newRelatedTable = require('./newRelatedTable');
+
+function newOne(joinRelation) {
+	var c = {};
+	var parentTable = joinRelation.childTable;
+
+	c.as = function(alias) {
+		joinRelation.rightAlias = alias;
+		var relation = newOneRelation(joinRelation);
+		parentTable._relations[alias] = relation;
+
+		Object.defineProperty(parentTable, alias, {
+			get: function() {
+				return newRelatedTable([relation]);
+			}
+		});
+		return relation;
+	};
+
+	c.notNullExceptInsert = function() {
+		return c;
+	};
+
+	c.notNull = function() {
+		return c;
+	};
+
+
+	return c;
+}
+
+module.exports = newOne;

package/src/table/insert.js

@@ -0,0 +1,91 @@
+let getSessionContext = require('./getSessionContext');
+let newRow = require('./commands/newRow');
+let insertDefault = require('./insertDefault');
+
+function insert({ table, options }, arg) {
+	// return insertDefault.apply(null, arguments);
+	if (Array.isArray(arg)) {
+		let all = [];
+		for (let i = 0; i < arg.length; i++) {
+			all.push(insert(table, arg[i]));
+		}
+		return Promise.all(all);
+	}
+	let args = [table].slice.call(arguments);
+	let row = newRow.apply(null, args);
+	let hasPrimary = getHasPrimary(table, row);
+	if (hasPrimary) {
+		row = table._cache.tryAdd(row);
+	}
+	expand(table, row);
+	Object.defineProperty(row, 'then', {
+		value: then,
+		writable: true,
+		enumerable: false,
+		configurable: true
+	});
+	const context = getSessionContext();
+	const insertP = (context.insert || insertDefault)(table, row, options).then(onResult);
+
+
+	// }
+	// else {
+	// 	// Non-PG case, use Promise
+	// 	result = new Promise((resolve, reject) => {
+	// 		([result]) => {
+	// 			row.hydrate(result);
+	// 			if (!hasPrimary) {
+	// 				row = table._cache.tryAdd(row);
+	// 			}
+	// 			table._cache.tryAdd(row);
+	// 			resolve(row);qq
+	// 		};
+	// 	});
+	// }
+
+	async function then(fn, efn) {
+		delete row.then;
+		return insertP.then(() => fn(row), efn);
+	}
+
+	return row;
+
+	function onResult([result]) {
+		row.hydrate(result);
+		if (!hasPrimary)
+			row = table._cache.tryAdd(row);
+		table._cache.tryAdd(row);
+		return row;
+	}
+}
+
+function expand(table, row) {
+	let relationName;
+	let visitor = {};
+	visitor.visitJoin = function() { };
+
+	visitor.visitMany = function() {
+		row.expand(relationName);
+	};
+
+	visitor.visitOne = function() {
+		row.expand(relationName);
+	};
+
+	for (relationName in table._relations) {
+		let relation = table._relations[relationName];
+		relation.accept(visitor);
+	}
+}
+
+function getHasPrimary(table, row) {
+	for (let i = 0; i < table._primaryColumns.length; i++) {
+		let column = table._primaryColumns[i];
+		if (row[column.alias] === null) {
+			return false;
+		}
+	}
+	return true;
+}
+
+module.exports = insert;

package/src/table/insertDefault.js

@@ -0,0 +1,88 @@
+let getSessionContext = require('./getSessionContext');
+let executeQueries = require('./executeQueries');
+let newRow = require('./commands/newRow');
+let newInsertCommand = require('./commands/newInsertCommand');
+let newInsertCommandCore = require('./commands/newInsertCommandCore');
+let newGetLastInsertedCommand = require('./commands/newGetLastInsertedCommand');
+let pushCommand = require('./commands/pushCommand');
+
+function insert({table, options}, arg) {
+	if (Array.isArray(arg)) {
+		let all = [];
+		for (let i = 0; i < arg.length; i++) {
+			all.push(insert(table, arg[i]));
+		}
+		return Promise.all(all);
+	}
+	let args = [table].slice.call(arguments);
+	let row = newRow.apply(null, args);
+	let hasPrimary = getHasPrimary(table, row);
+	if (hasPrimary)
+		row = table._cache.tryAdd(row);
+	let cmd = newInsertCommand(newInsertCommandCore, table, row, options);
+
+	pushCommand(cmd);
+	expand(table, row);
+	Object.defineProperty(row, 'then', {
+		value: then,
+		writable: true,
+		enumerable: false,
+		configurable: true
+	});
+
+	let selectCmd;
+	if (getSessionContext().lastInsertedIsSeparate) {
+		selectCmd = newGetLastInsertedCommand(table, row, cmd);
+		pushCommand(selectCmd);
+		selectCmd.onResult = onResult;
+	}
+	else {
+		cmd.onResult = onResult;
+		cmd.disallowCompress = true;
+	}
+
+	return row;
+	function then(fn,efn) {
+		delete row.then;
+		return executeQueries([]).then(() => fn(row), efn);
+	}
+
+	function onResult([result]) {
+		row.hydrate(result);
+		if (!hasPrimary)
+			row = table._cache.tryAdd(row);
+		table._cache.tryAdd(row);
+	}
+}
+
+function expand(table, row) {
+	let relationName;
+	let visitor = {};
+	visitor.visitJoin = function() { };
+
+	visitor.visitMany = function() {
+		row.expand(relationName);
+	};
+
+	visitor.visitOne = function() {
+		row.expand(relationName);
+	};
+
+	for (relationName in table._relations) {
+		let relation = table._relations[relationName];
+		relation.accept(visitor);
+	}
+
+}
+
+function getHasPrimary(table, row) {
+	for (let i = 0; i < table._primaryColumns.length; i++) {
+		let column = table._primaryColumns[i];
+		if (row[column.alias] === null)
+			return;
+	}
+	return true;
+
+}
+
+module.exports = insert;

package/src/table/join.js

@@ -0,0 +1,42 @@
+var newJoinRelation = require('./newJoinRelation');
+var newRelatedTable = require('./newRelatedTable');
+
+function newJoin(parentTable, childTable) {
+	var c = {};
+	var columnNames = [];
+	var relation;
+
+	c.by = function() {
+		for (var i = 0; i < arguments.length; i++) {
+			columnNames.push(getColumnName(arguments[i]));
+		}
+		relation = newJoinRelation(parentTable, childTable, columnNames);
+		relation.as = c.as;
+		return relation;
+	};
+
+	function getColumnName(columnName) {
+		var columns = parentTable._columns;
+		for (var i = 0; i < columns.length; i++) {
+			if (columns[i]._dbName === columnName || columns[i].alias === columnName)
+				return columns[i]._dbName;
+		}
+		throw new Error('Unknown column: ' + columnName);
+	}
+
+	c.as = function(alias) {
+		relation.leftAlias = alias;
+		parentTable._relations[alias] = relation;
+
+		Object.defineProperty(parentTable, alias, {
+			get: function() {
+				return newRelatedTable([relation]);
+			}
+		});
+
+		return relation;
+	};
+	return c;
+}
+
+module.exports = newJoin;

package/src/table/joinRelation/getRelatives.js

@@ -0,0 +1,64 @@
+var newPrimaryKeyFilter = require('../newPrimaryKeyFilter');
+var emptyFilter = require('../../emptyFilter');
+var negotiateExpandInverse = require('../negotiateExpandInverse');
+
+function getRelatives(parent, relation) {
+	var queryContext = parent.queryContext;
+	let strategy = queryContext && queryContext.strategy[relation.leftAlias];
+	var filter = emptyFilter;
+	if (relation.columns.length === 1)
+		createInFilter();
+	else
+		createCompositeFilter();
+
+	function createInFilter() {
+		var ids = [];
+		var row;
+		var id;
+		var alias = relation.columns[0].alias;
+		for (var i = 0; i < queryContext.rows.length; i++) {
+			row = queryContext.rows[i];
+			id = row[alias];
+			if (!isNullOrUndefined(id))
+				ids.push(id);
+		}
+
+		if (ids.length > 0)
+			filter = relation.childTable._primaryColumns[0].in(ids);
+	}
+
+	function createCompositeFilter() {
+		var keyFilter;
+		for (var i = 0; i < queryContext.rows.length; i++) {
+			keyFilter = rowToPrimaryKeyFilter(queryContext.rows[i], relation);
+			if (keyFilter)
+				filter = filter.or(keyFilter);
+		}
+	}
+
+	return relation.childTable.getMany(filter, strategy).then(onRows);
+
+	function onRows(rows) {
+		queryContext.expand(relation);
+		negotiateExpandInverse(parent, relation, rows);
+		return rows;
+	}
+
+}
+
+function rowToPrimaryKeyFilter(row, relation) {
+	var key = relation.columns.map( function(column) {
+		return row[column.alias];
+	});
+	if (key.some(isNullOrUndefined)) {
+		return;
+	}
+	var args = [relation.childTable].concat(key);
+	return newPrimaryKeyFilter.apply(null, args);
+}
+
+function isNullOrUndefined(item) {
+	return item === null || item === undefined;
+}
+
+module.exports = getRelatives;

package/src/table/log.js

@@ -0,0 +1,39 @@
+var newEmitEvent = require('../emitEvent');
+
+var emitters = {
+	query: newEmitEvent()
+};
+
+var logger = function() {
+};
+
+function log() {
+	logger.apply(null, arguments);
+}
+function emitQuery({ sql, parameters }) {
+	emitters.query.apply(null, arguments);
+	log(sql);
+	log('parameters: ' + parameters);
+}
+
+log.emitQuery = emitQuery;
+
+log.registerLogger = function(cb) {
+	logger = cb;
+};
+
+log.on = function(type, cb) {
+	if (type === 'query')
+		emitters.query.add(cb);
+	else
+		throw new Error('unknown event type: ' + type);
+};
+
+log.off = function(type, cb) {
+	if (type === 'query')
+		emitters.query.tryRemove(cb);
+	else
+		throw new Error('unknown event type: ' + type);
+};
+
+module.exports = log;