orange-orm 3.10.2

package/src/mySql/newTransaction.js

@@ -0,0 +1,54 @@
+const wrapQuery = require('./wrapQuery');
+const encodeBoolean = require('./encodeBoolean');
+const deleteFromSql = require('./deleteFromSql');
+const selectForUpdateSql = require('./selectForUpdateSql');
+const lastInsertedSql = require('./lastInsertedSql');
+const limitAndOffset = require('./limitAndOffset');
+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, connection, done) {
+			try {
+				if (err) {
+					onError(err);
+					return;
+				}
+				connection.executeQuery = wrapQuery(connection);
+				// connection.streamQuery = wrapQueryStream(connection);
+				rdb.engine = 'mysql';
+				rdb.dbClient = connection;
+				rdb.dbClientDone = done;
+				rdb.encodeBoolean = encodeBoolean;
+				rdb.encodeJSON = JSON.stringify;
+				rdb.deleteFromSql = deleteFromSql;
+				rdb.selectForUpdateSql = selectForUpdateSql;
+				rdb.lastInsertedIsSeparate = true;
+				rdb.lastInsertedSql = lastInsertedSql;
+				rdb.insertSql = insertSql;
+				rdb.insert = insert;
+				rdb.multipleStatements = false;
+				rdb.limitAndOffset = limitAndOffset;
+				rdb.accept = function(caller) {
+					caller.visitMySql();
+				};
+				rdb.aggregateCount = 0;
+				domain.rdb = rdb;
+				onSuccess();
+			} catch (e) {
+				onError(e);
+			}
+		}
+	};
+}
+
+module.exports = newResolveTransaction;

package/src/mySql/pool/defaults.js

@@ -0,0 +1,16 @@
+module.exports = {
+	//Connection pool options - see https://github.com/coopernurse/node-pool
+	//number of connections to use in connection pool
+	//0 will disable connection pooling
+	poolSize: 0,
+
+	//max milliseconds a client can go unused before it is removed
+	//from the pool and destroyed
+	poolIdleTimeout: 30000,
+
+	//frequeny to check for idle clients within the client pool
+	reapIntervalMillis: 1000,
+
+	//pool log function / boolean
+	poolLog: false,
+};

package/src/mySql/pool/end.js

@@ -0,0 +1,13 @@
+var pools = require('../../pools');
+
+function endPool(genericPool, id, done) {
+	genericPool.drain(onDrained);
+
+	function onDrained() {
+		genericPool.destroyAllNow();
+		delete pools[id];
+		done();
+	}
+}
+
+module.exports = endPool;

package/src/mySql/pool/negotiatePoolOptions.js

@@ -0,0 +1,12 @@
+function negotiatePoolOptions(pool, options) {
+	var config = pool.config;
+	for(var name in options) {
+		var value = options[name];
+		if (name === 'size')
+			config.connectionLimit = value;
+		else
+			config[name] = value;
+	}
+}
+
+module.exports = negotiatePoolOptions;

package/src/mySql/pool/newGenericPool.js

@@ -0,0 +1,67 @@
+// @ts-nocheck
+/* eslint-disable no-prototype-builtins */
+var EventEmitter = require('events').EventEmitter;
+
+var defaults = require('./defaults');
+var genericPool = require('../../generic-pool');
+var mysql = require('mysql2');
+
+function newGenericPool(connectionString, poolOptions) {
+	if (typeof connectionString === 'string')
+		connectionString = connectionString + '?dateStrings=true&decimalNumbers=true';
+	else
+		connectionString.dateStrings = true;
+	poolOptions = poolOptions || {};
+	var pool = genericPool.Pool({
+		max: poolOptions.size || poolOptions.poolSize || defaults.poolSize,
+		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
+		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
+		log: poolOptions.log || defaults.poolLog,
+		create: function(cb) {
+			var innerPool = mysql.createPool(connectionString);
+			return cb(null, innerPool);
+			// innerPool.getConnection(onConnected);
+
+			// function onConnected(err, client) {
+			// 	console.dir('onConnected');
+			// 	if(err)
+			// 		return cb(err, null);
+			// 	client.poolCount = 0;
+			// 	return cb(null, client);
+			// }
+		},
+
+		destroy: function(client) {
+			client.poolCount = undefined;
+			client.end();
+		}
+	});
+	//mixin EventEmitter to pool
+	EventEmitter.call(pool);
+	for(var key in EventEmitter.prototype) {
+		if(EventEmitter.prototype.hasOwnProperty(key)) {
+			pool[key] = EventEmitter.prototype[key];
+		}
+	}
+	//monkey-patch with connect method
+	pool.connect = function(cb) {
+		var domain = process.domain;
+		pool.acquire(function(err, client) {
+			if(domain) {
+				cb = domain.bind(cb);
+			}
+			if(err)  return cb(err, null, function() {/*NOOP*/});
+			client.poolCount++;
+			cb(null, client, function(err) {
+				if(err) {
+					pool.destroy(client);
+				} else {
+					pool.release(client);
+				}
+			});
+		});
+	};
+	return pool;
+}
+
+module.exports = newGenericPool;

package/src/mySql/selectForUpdateSql.js

@@ -0,0 +1,3 @@
+module.exports = function(_alias) {
+	return ' FOR UPDATE';
+};

package/src/mySql/wrapQuery.js

@@ -0,0 +1,16 @@
+var log = require('../table/log');
+
+function wrapQuery(connection) {
+	var runOriginalQuery = connection.query;
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		var params = query.parameters;
+		var sql = query.sql();
+		log.emitQuery({sql, parameters: params});
+		return runOriginalQuery.call(connection, sql, params, onCompleted);
+	}
+
+}
+
+module.exports = wrapQuery;

package/src/mySql/wrapQueryStream.js

@@ -0,0 +1,9 @@
+function wrapQueryStream(connection) {
+	return runQuery;
+
+	function runQuery(query, options) {
+		return connection.executeQuery(query).stream(options);
+	}
+}
+
+module.exports = wrapQueryStream;

package/src/newArray.js

@@ -0,0 +1,3 @@
+module.exports = function() {
+	return [];
+};

package/src/newCollection.js

@@ -0,0 +1,55 @@
+function newCollection() {
+	var c = {};
+	var initialArgs = [];
+	for (var i = 0; i < arguments.length; i++) {
+		initialArgs.push(arguments[i]);
+	}
+	var ranges = [initialArgs];
+
+	c.addRange = function(otherCollection) {
+		ranges.push(otherCollection);
+	};
+
+	c.add = function(element) {
+		c.addRange([element]);
+	};
+
+	c.toArray = function() {
+		var result = [];
+		c.forEach(onEach);
+		return result;
+
+		function onEach(element) {
+			result.push(element);
+		}
+	};
+
+	c.forEach = function(callback) {
+		var index = 0;
+		for (var i = 0; i < ranges.length; i++) {
+			ranges[i].forEach(onEach);
+		}
+
+		function onEach(element) {
+			callback(element, index);
+			index++;
+		}
+
+	};
+
+	Object.defineProperty(c, 'length', {
+		enumerable: false,
+		get: function() {
+			var result = 0;
+			for (var i = 0; i < ranges.length; i++) {
+				result += ranges[i].length;
+			}
+			return result;
+		},
+	});
+
+
+	return c;
+}
+
+module.exports = newCollection;

package/src/newId.js

@@ -0,0 +1 @@
+module.exports = require('uuid').v4;

package/src/newImmutable.js

@@ -0,0 +1,22 @@
+function newImmutable(fn) {
+	var result;
+	var _run = runFirst;
+	return run;
+
+	function run() {
+		var args = [].slice.call(arguments);
+		return _run(args);
+	}
+
+	function runFirst(args) {
+		result =  fn.apply(null, args);
+		_run = runNIgnoreArgs;
+		return result;
+	}
+
+	function runNIgnoreArgs() {
+		return result;
+	}
+}
+
+module.exports = newImmutable;

package/src/newObject.js

@@ -0,0 +1,5 @@
+function newObject() {
+	return {};
+}
+
+module.exports = newObject;

package/src/oracle/deleteFromSql.js

@@ -0,0 +1,8 @@
+var format = 'delete from %s where %s.rowId in (SELECT %s.rowId FROM %s %s%s)';
+var util = require('util');
+
+function deleteFromSql(table, alias, whereSql) {
+	var name = table._dbName;
+	return util.format(format, name, name, alias, name, alias, whereSql);
+}
+module.exports = deleteFromSql;

package/src/oracle/encodeBoolean.js

@@ -0,0 +1,7 @@
+function encodeBoolean(bool) {
+	if (bool)
+		return 1;
+	return 0;
+}
+
+module.exports = encodeBoolean;

package/src/oracle/encodeBuffer.js

@@ -0,0 +1,7 @@
+//unused because using sql parameters instead
+//Remove ?
+function encodeBuffer(buffer) {
+	return 'E\'\\\\x' + buffer.toString('hex') + '\'';
+}
+
+module.exports = encodeBuffer;

package/src/oracle/encodeDate.js

@@ -0,0 +1,7 @@
+function encodeDate(date) {
+	if (date.toISOString)
+		return  '\'' + date.toISOString() + '\'';
+	return '\'' + date + '\'';
+}
+
+module.exports = encodeDate;

package/src/oracle/formatDateIn.js

@@ -0,0 +1,5 @@
+function formatDateColumn(value) {
+	return `TO_TIMESTAMP(${value}, 'YYYY-MM-DD"T"HH24:MI:SS.FF3')`;
+}
+
+module.exports = formatDateColumn;

package/src/oracle/formatDateOut.js

@@ -0,0 +1,5 @@
+function formatDateColumn(column, alias) {
+	return `TO_CHAR(${alias}.${column._dbName}, 'YYYY-MM-DD"T"HH24:MI:SS.FF3')`;
+}
+
+module.exports = formatDateColumn;

package/src/oracle/insert.js

@@ -0,0 +1,23 @@
+const newInsertCommand = require('../table/commands/newInsertCommand');
+const newInsertCommandCore = require('./newInsertCommandCore');
+const setSessionSingleton = require('../table/setSessionSingleton');
+const newGetLastInsertedCommand = require('../table/commands/newGetLastInsertedCommand');
+const executeQueries = require('../table/executeQueries');
+
+function insert(table, row, options) {
+
+	return new Promise((res, rej) => {
+		const cmd = newInsertCommand(newInsertCommandCore, table, row, options);
+		cmd.disallowCompress = true;
+		executeQueries([cmd]).then((result) => result[0]).then(onResult).then(res, rej);
+
+		function onResult([result]) {
+			setSessionSingleton('lastRowid', result.lastRowid);
+			const selectCmd = newGetLastInsertedCommand(table, row, cmd);
+			return executeQueries([selectCmd]).then((result) => res(result[0]));
+		}
+
+	});
+}
+
+module.exports = insert;

package/src/oracle/insertSql.js

@@ -0,0 +1,73 @@
+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()} (${table._primaryColumns[0]._dbName}) VALUES(DEFAULT)`;
+	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);
+				if (column.tsType === 'DateColumn')
+					values.push('TO_TIMESTAMP(%s, \'YYYY-MM-DD"T"HH24:MI:SS.FF6\')');
+				else
+					values.push('%s');
+			}
+		}
+	}
+
+
+	function outputInserted() {
+
+		return ' ' + outputInsertedSql(table) + ' ';
+	}
+
+}
+
+module.exports = getSqlTemplate;

package/src/oracle/lastInsertedSql.js

@@ -0,0 +1,14 @@
+let getSessionSingleton = require('../table/getSessionSingleton');
+
+function lastInsertedSql(table, keyValues) {
+	return keyValues.map((value,i) => {
+		let column = table._primaryColumns[i];
+		if (value === undefined)
+			return `ROWID='${getSessionSingleton('lastRowid')}'`;
+		else
+			return column.eq(value);
+	});
+
+}
+
+module.exports = lastInsertedSql;

package/src/oracle/limitAndOffset.js

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

package/src/oracle/mergeSql.js

@@ -0,0 +1,79 @@
+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} target USING (SELECT ${values.join(',')} FROM DUAL) source ON (${join()}) WHEN MATCHED THEN ${matched} WHEN NOT MATCHED THEN ${whenNotMatched()} ${outputInsertedSql(table)}`;
+	else
+		sql = `MERGE INTO ${table._dbName} target USING (SELECT ${values.join(',')} FROM DUAL) 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]} ${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 ${column.alias}`);
+				if (!column.isPrimary)
+					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 RAISE_APPLICATION_ERROR(-20001, 'Conflict when updating ${column._dbName}') ELSE target.${column._dbName} END`);
+				conflictColumnUpdates.push(`target.${column._dbName} = CASE WHEN target.${column._dbName} <> source.${column._dbName} THEN 1/0 ELSE target.${column._dbName} END`);
+
+		}
+	}
+}
+
+module.exports = insertSql;

package/src/oracle/newDatabase.js

@@ -0,0 +1,128 @@
+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;