orange-orm 3.10.2

package/src/table/commands/negotiateEndEdit.js

@@ -0,0 +1,7 @@
+function negotiateEndEdit(changes) {
+	var last = changes[changes.length - 1];
+	if (last && last.endEdit)
+		last.endEdit();
+}
+
+module.exports = negotiateEndEdit;

package/src/table/commands/newDeleteCommand.js

@@ -0,0 +1,23 @@
+var newSingleCommand = require('./delete/newSingleCommand');
+
+var nextCommand = function() {
+	nextCommand = require('./newDeleteCommand');
+	nextCommand.apply(null, arguments);
+};
+
+function newCommand(queries,table,filter,strategy,relations) {
+	var singleCommand = newSingleCommand(table,filter,relations);
+	for(var name in strategy) {
+		if (!(strategy[name] === null || strategy[name]))
+			continue;
+		var childStrategy = strategy[name];
+		var childRelation = table._relations[name];
+		var joinRelation = childRelation.joinRelation;
+		var	childRelations = [joinRelation].concat(relations);
+		nextCommand(queries,childRelation.childTable,filter,childStrategy,childRelations);
+	}
+	queries.push(singleCommand);
+	return queries;
+}
+
+module.exports = newCommand;

package/src/table/commands/newGetLastInsertedCommand.js

@@ -0,0 +1,49 @@
+var newGetLastInsertedCommandCore = require('./newGetLastInsertedCommandCore');
+var newImmutable = require('../../newImmutable');
+
+function newGetLastInsertedCommand(table, row, insertCommand) {
+	let cmd =  new InsertCommand(table, row, insertCommand);
+	insertCommand.endEdit = () => {};
+	return cmd;
+}
+
+function InsertCommand(table, row, insertCommand) {
+	this._insertCommand = insertCommand;
+	this.__getCoreCommand = newImmutable(newGetLastInsertedCommandCore);
+	this._table = table;
+	this._row = row;
+}
+
+InsertCommand.prototype._getCoreCommand = function() {
+	return this.__getCoreCommand(this._table, this._row);
+};
+
+InsertCommand.prototype.sql = function() {
+	return this._getCoreCommand().sql();
+};
+
+InsertCommand.prototype.matches = function(otherRow) {
+	return this._row === otherRow;
+};
+
+
+InsertCommand.prototype.endEdit = function() {
+	this._insertCommand.endEdit();
+	this.sql();
+};
+
+Object.defineProperty(InsertCommand.prototype, 'parameters', {
+	get: function() {
+		return this._getCoreCommand().parameters;
+
+	}
+});
+
+Object.defineProperty(InsertCommand.prototype, 'disallowCompress', {
+	get: function() {
+		return true;
+	}
+});
+
+
+module.exports = newGetLastInsertedCommand;

package/src/table/commands/newGetLastInsertedCommandCore.js

@@ -0,0 +1,42 @@
+let newParameterized = require('../query/newParameterized');
+let getSessionContext = require('../getSessionContext');
+
+function newGetLastInsertedCommandCore(table, row) {
+	let parameters = [];
+	let keyValues = table._primaryColumns.map(column => row['__' + column.alias]);
+	let sql = `SELECT ${columnNames()} FROM ${table._dbName} WHERE ${whereSql()}`;
+	return newParameterized(sql, parameters);
+
+	function columnNames() {
+		return table._columns.map(col => col._dbName).join(',');
+	}
+
+	function whereSql() {
+		let parameterized;
+		let filter = getSessionContext().lastInsertedSql(table, keyValues);
+		if (Array.isArray(filter)) {
+			for (let i = 0; i < filter.length; i++) {
+				const sep = i === 0 ? '' : ' AND ';
+				if (!filter[i].sql) {
+					const sql = filter[i];
+					filter[i] = {sql : () => sql};
+				}
+				let next = newParameterized(sep + filter[i].sql(), filter[i].parameters);
+				if (parameterized)
+					parameterized = parameterized.append(next);
+				else
+					parameterized = next;
+			}
+		}
+		else
+			parameterized = newParameterized(filter);
+		parameters = parameters.concat(parameterized.parameters);
+		return [discriminators(), parameterized.sql()].filter(x => x).join(' AND ');
+	}
+
+	function discriminators() {
+		return table._columnDiscriminators.join(',');
+	}
+}
+
+module.exports = newGetLastInsertedCommandCore;

package/src/table/commands/newInsertAndForgetCommand.js

@@ -0,0 +1,55 @@
+var newInsertCommandCore = require('./newInsertCommandCore');
+var newImmutable = require('../../newImmutable');
+var createPatch = require('../../client/createPatch');
+var createDto = require('../resultToRows/toDto/createDto');
+
+function newInsertCommand(table, row, options) {
+	return new InsertCommand(table, row, options);
+}
+
+function InsertCommand(table, row) {
+	this.__getCoreCommand = newImmutable(newInsertCommandCore);
+	this._table = table;
+	this._row = row;
+}
+
+InsertCommand.prototype._getCoreCommand = function() {
+	return this.__getCoreCommand(this._table, this._row);
+};
+
+InsertCommand.prototype.sql = function() {
+	return this._getCoreCommand().sql();
+};
+
+InsertCommand.prototype.matches = function(otherRow) {
+	return this._row === otherRow;
+};
+
+
+InsertCommand.prototype.endEdit = function() {
+	this.sql();
+	var dto = createDto(this._table, this._row);
+	if (this._table._emitChanged.callbacks.length > 0)
+		this._patch = createPatch([], [dto]);
+};
+
+InsertCommand.prototype.emitChanged = function() {
+	return this._table._emitChanged({row: this._row, patch: this._patch});
+};
+
+Object.defineProperty(InsertCommand.prototype, 'parameters', {
+	get: function() {
+		return this._getCoreCommand().parameters;
+
+	}
+});
+
+Object.defineProperty(InsertCommand.prototype, 'disallowCompress', {
+	get: function() {
+		return this._table._emitChanged.callbacks.length > 0;
+
+	}
+});
+
+
+module.exports = newInsertCommand;

package/src/table/commands/newInsertCommand.js

@@ -0,0 +1,56 @@
+// var newInsertCommandCore = require('./newInsertCommandCore');
+var newImmutable = require('../../newImmutable');
+var createPatch = require('../../client/createPatch');
+var createDto = require('../resultToRows/toDto/createDto');
+
+function newInsertCommand(newInsertCommandCore, table, row, options) {
+	return new InsertCommand(newInsertCommandCore, table, row,  options);
+}
+
+function InsertCommand(newInsertCommandCore, table, row, options) {
+	this.__getCoreCommand = newImmutable(newInsertCommandCore);
+	this._table = table;
+	this._row = row;
+	this._options = options;
+}
+
+InsertCommand.prototype._getCoreCommand = function() {
+	return this.__getCoreCommand(this._table, this._row, this._options);
+};
+
+InsertCommand.prototype.sql = function() {
+	return this._getCoreCommand().sql();
+};
+
+InsertCommand.prototype.matches = function(otherRow) {
+	return this._row === otherRow;
+};
+
+
+InsertCommand.prototype.endEdit = function() {
+	this.sql();
+	var dto = createDto(this._table, this._row);
+	if (this._table._emitChanged.callbacks.length > 0)
+		this._patch = createPatch([], [dto]);
+};
+
+InsertCommand.prototype.emitChanged = function() {
+	return this._table._emitChanged({row: this._row, patch: this._patch});
+};
+
+Object.defineProperty(InsertCommand.prototype, 'parameters', {
+	get: function() {
+		return this._getCoreCommand().parameters;
+
+	}
+});
+
+Object.defineProperty(InsertCommand.prototype, 'disallowCompress', {
+	get: function() {
+		return this._table._emitChanged.callbacks.length > 0;
+
+	}
+});
+
+
+module.exports = newInsertCommand;

package/src/table/commands/newInsertCommandCore.js

@@ -0,0 +1,27 @@
+var newParameterized = require('../query/newParameterized');
+var getSqlTemplate = require('./insert/getSqlTemplate');
+var util = require('util');
+
+function newInsertCommandCore(table, row, options = {}) {
+	var parameters = [];
+	var values = [getSqlTemplate(table, row, options)];
+
+	var columns = table._columns;
+	for (var i = 0; i < columns.length; i++) {
+		var column = columns[i];
+		var alias = column.alias;
+		if (row['__' + column.alias] !== undefined) {
+			var encoded = column.encode(row[alias]);
+			if (encoded.parameters.length > 0) {
+				values.push('?');
+				parameters.push(encoded.parameters[0]);
+			} else
+				values.push(encoded.sql());
+		}
+	}
+
+	var sql = util.format.apply(null, values);
+	return newParameterized(sql, parameters);
+}
+
+module.exports = newInsertCommandCore;

package/src/table/commands/newRow.js

@@ -0,0 +1,51 @@
+var decodeDbRow = require('../resultToRows/decodeDbRow');
+var flags = require('../../flags');
+
+function newRow({table, _options}) {
+	var dto = {};
+	table._columns.forEach(addColumn);
+
+	function addColumn(column) {
+		var alias = column.alias;
+		if ('default' in column) {
+			if (typeof column.default === 'function')
+				dto[alias] = column.default();
+			else if (column.toDto)
+				dto[alias] = column.toDto(column.default);
+			else
+				dto[alias] = column.default;
+		}
+		else if (flags.useLazyDefaults && 'lazyDefault' in column && !column.isPrimary) {
+			if (typeof column.lazyDefault === 'function')
+				dto[alias] = column.lazyDefault();
+			else if (column.toDto)
+				dto[alias] = column.toDto(column.lazyDefault);
+			else
+				dto[alias] = column.lazyDefault;
+		}
+		else if (column.dbNull !== null)
+			dto[alias] = null;
+		else
+			dto[alias] = undefined;
+	}
+	const arg = arguments[1];
+	if (isObject(arg))
+		for (let name in arg) {
+			if (table[name] && table[name].equal)
+				dto[name] = arg[name];
+		}
+	else
+		for (var i = 1; i < arguments.length; i++) {
+			var pkValue = arguments[i];
+			var column = table._primaryColumns[i - 1];
+			dto[column.alias] = pkValue;
+		}
+
+	return decodeDbRow(table, table, dto, true, true);
+}
+
+function isObject(object) {
+	return (object === Object(object) && !Array.isArray(object) && !(object instanceof Date));
+}
+
+module.exports = newRow;

package/src/table/commands/newUpdateCommand.js

@@ -0,0 +1,62 @@
+let newUpdateCommandCore = require('./newUpdateCommandCore');
+let newImmutable = require('../../newImmutable');
+let newColumnList = require('../../newObject');
+var createPatch = require('../../client/createPatch');
+let createDto = require('../resultToRows/toDto/createDto');
+
+function newUpdateCommand(table, column, row) {
+	return new UpdateCommand(table, column, row);
+}
+
+function UpdateCommand(table, column, row) {
+	this._table = table;
+	this._row = row;
+	this.__getCoreCommand = newImmutable(newUpdateCommandCore);
+	this._columnList = newColumnList();
+	this._columnList[column.alias] = column;
+	this.onFieldChanged = this.onFieldChanged.bind(this);
+	row.subscribeChanged(this.onFieldChanged);
+}
+
+UpdateCommand.prototype.onFieldChanged = function(_row, column) {
+	this._columnList[column.alias] = column;
+};
+
+UpdateCommand.prototype.sql = function() {
+	return this._getCoreCommand().sql();
+};
+
+Object.defineProperty(UpdateCommand.prototype, 'parameters', {
+	get: function() {
+		return this._getCoreCommand().parameters;
+	}
+});
+
+UpdateCommand.prototype._getCoreCommand = function() {
+	return this.__getCoreCommand(this._table, this._columnList, this._row);
+};
+
+UpdateCommand.prototype.endEdit = function() {
+	this._getCoreCommand();
+	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]);
+	this._row._oldValues = JSON.stringify(dto);
+};
+
+UpdateCommand.prototype.emitChanged = function() {
+	return this._table._emitChanged({row: this._row, patch: this._patch});
+};
+
+UpdateCommand.prototype.matches = function(otherRow) {
+	return this._row === otherRow;
+};
+
+Object.defineProperty(UpdateCommand.prototype, 'disallowCompress', {
+	get: function() {
+		return this._table._emitChanged.callbacks.length > 0;
+
+	}
+});
+
+module.exports = newUpdateCommand;

package/src/table/commands/newUpdateCommandCore.js

@@ -0,0 +1,45 @@
+var newParameterized = require('../query/newParameterized');
+
+function newUpdateCommandCore(table, columns, row) {
+	var command = newParameterized('UPDATE ' + table._dbName + ' SET');
+	var separator = ' ';
+
+	addColumns();
+	addWhereId();
+	addDiscriminators();
+
+	function addColumns() {
+		for (var alias in columns) {
+			var column = columns[alias];
+			var encoded = column.encode(row[alias]);
+			command = command.append(separator + column._dbName + '=').append(encoded);
+			separator = ',';
+		}
+	}
+
+	function addWhereId() {
+		separator = ' WHERE ';
+		var columns = table._primaryColumns;
+		for (var i = 0; i < columns.length; i++) {
+			var column = columns[i];
+			var value = row[column.alias];
+			var encoded = column.encode(value);
+			command = command.append(separator + column._dbName + '=').append(encoded);
+			separator = ' AND ';
+		}
+	}
+
+	function addDiscriminators() {
+		var discriminators = table._columnDiscriminators;
+		if (discriminators.length === 0)
+			return;
+		discriminators = separator + discriminators.join(' AND ');
+		command = command.append(discriminators);
+	}
+
+	return command;
+
+
+}
+
+module.exports = newUpdateCommandCore;

package/src/table/commands/pushCommand.js

@@ -0,0 +1,10 @@
+var getChangeSet = require('./getChangeSet');
+var negotiateEndEdit = require('./negotiateEndEdit');
+
+function pushCommand(command) {
+	var changes = getChangeSet();
+	negotiateEndEdit(changes);
+	changes.push(command);
+}
+
+module.exports = pushCommand;

package/src/table/commands/rollbackCommand.js

@@ -0,0 +1,13 @@
+var newParameterized = require('../query/newParameterized');
+
+var command = newParameterized('ROLLBACK');
+function empty() {}
+
+// @ts-ignore
+command.endEdit = empty;
+// @ts-ignore
+command.matches = empty;
+
+module.exports = command;
+
+

package/src/table/commit.js

@@ -0,0 +1,30 @@
+let commitCommand = require('./commands/commitCommand');
+let pushCommand = require('./commands/pushCommand');
+let executeChanges = require('./executeQueries/executeChanges');
+let releaseDbClient = require('./releaseDbClient');
+let popChanges = require('./popChanges');
+
+function commit(result) {
+	return popAndPushChanges()
+		.then(releaseDbClient)
+		.then(onReleased);
+
+	function onReleased() {
+		return result;
+	}
+
+	async function popAndPushChanges() {
+		let changes = popChanges();
+		while (changes.length > 0) {
+			await executeChanges(changes);
+			changes = popChanges();
+		}
+		pushCommand(commitCommand);
+		return executeChanges(popChanges());
+	}
+}
+
+module.exports = function(result) {
+	return Promise.resolve()
+		.then(() => commit(result));
+};

package/src/table/count.js

@@ -0,0 +1,29 @@
+const executeQueries = require('./executeQueries');
+const negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
+const extractFilter = require('./query/extractFilter');
+const newWhereSql = require('./query/singleQuery/newWhereSql');
+
+async function count(table, filter) {
+	let alias = table._dbName;
+	filter = negotiateRawSqlFilter(filter, table);
+	let query = newQuery(table, filter, alias);
+	let allResults = await executeQueries([query]);
+	let count = await allResults[0].then((rows) => {
+
+		const count = Number.parseInt(rows[0]._count);
+		return count;
+	});
+	return count;
+}
+
+function newQuery(table, filter, alias) {
+	filter = extractFilter(filter);
+	var name = table._dbName;
+	var whereSql = newWhereSql(table, filter, alias);
+
+	return whereSql.prepend('select count(*) "_count" from ' + name + ' ' + alias);
+
+
+}
+
+module.exports = count;

package/src/table/createJSONReadStream.js

@@ -0,0 +1,7 @@
+var createJSONReadStreamDefault = require('./createJSONReadStreamDefault');
+
+function createJSONReadStream(table, db, filter, strategy, streamOptions) {
+	return createJSONReadStreamDefault(table, db, filter, strategy, streamOptions);
+}
+
+module.exports = createJSONReadStream;

package/src/table/createJSONReadStreamDefault.js

@@ -0,0 +1,33 @@
+var createReadStreamCore = require('./createReadStreamDefault');
+var Stream = require('stream');
+
+function createJSONReadStream(table, db, filter, strategy, streamOptions) {
+	var transformer = Stream.Transform({ objectMode: true });
+	var started;
+	transformer._transform = function(obj, enc, cb) {
+		var data = JSON.stringify(obj);
+		if (started)
+			transformer.push(',' + data);
+		else {
+			transformer.push('[');
+			transformer.push(data);
+			started = true;
+		}
+		cb();
+	};
+
+	transformer._flush = function(cb) {
+		transformer.push(']');
+		cb();
+	};
+
+	var objectStream = createReadStreamCore(table, db, filter, strategy, streamOptions);
+	objectStream.on('error', onError);
+	return objectStream.pipe(transformer);
+
+	function onError(e) {
+		transformer.emit('error', e);
+	}
+}
+
+module.exports = createJSONReadStream;

package/src/table/createJSONReadStreamNative.js

@@ -0,0 +1,31 @@
+var createReadStreamCore = require('./createReadStreamCoreNative');
+var Stream = require('stream');
+
+function createJSONReadStream(table, db, filter, strategy, streamOptions) {
+	var transformer = Stream.Transform({
+		objectMode: true
+	});
+	var started;
+	transformer._transform = function(chunk, enc, cb) {
+		if (started)
+			transformer.push(',' + chunk.result);
+		else {
+			transformer.push('[');
+			let result = chunk.result;
+			if (typeof result === 'object')
+				result = JSON.stringify(result);
+			transformer.push(result);
+			started = true;
+		}
+		cb();
+	};
+
+	transformer._flush = function(cb) {
+		transformer.push(']');
+		cb();
+	};
+
+	return createReadStreamCore(table, db, filter, strategy, transformer, streamOptions);
+}
+
+module.exports = createJSONReadStream;

package/src/table/createReadStream.js

@@ -0,0 +1,24 @@
+var createReadStreamNative = require('./createReadStreamNative');
+var createReadStreamDefault = require('./createReadStreamDefault');
+
+function createReadStream(table, db, filter, strategy, streamOptions) {
+	var create;
+	var c = {};
+
+	c.visitPg = function() {
+		create =  createReadStreamNative;
+	};
+
+	c.visitMySql = c.visitPg;
+
+	c.visitSqlite = function() {
+		create =  createReadStreamDefault;
+	};
+	c.visitSap = c.visitSqlite;
+
+	db.accept(c);
+
+	return create(table, db, filter, strategy, streamOptions);
+}
+
+module.exports = createReadStream;

package/src/table/createReadStreamCoreNative.js

@@ -0,0 +1,40 @@
+var newQuery = require('./readStream/newQuery');
+var strategyToSpan = require('./strategyToSpan');
+var negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
+var newQueryStream = require('./readStream/newQueryStream');
+
+function createReadStreamCoreNative(table, db, filter, strategy, transformer, streamOptions) {
+	var alias = table._dbName;
+	filter = negotiateRawSqlFilter(filter, table);
+	var span = strategyToSpan(table, strategy);
+
+	if (process.domain)
+		process.domain.add(transformer);
+
+	db.transaction(async () => {
+		await start();
+	}).then(null, onError);
+
+	function start() {
+		return new Promise((resolve, reject) => {
+			var query = newQuery(db, table, filter, span, alias);
+			var queryStream = newQueryStream(query, streamOptions);
+			queryStream.on('end', resolve);
+			queryStream.on('error', onStreamError);
+			queryStream.pipe(transformer);
+
+			function onStreamError(e) {
+				reject(e);
+			}
+		});
+
+	}
+
+	function onError(e) {
+		transformer.emit('error', e);
+	}
+
+	return transformer;
+}
+
+module.exports = createReadStreamCoreNative;