orange-orm 4.3.0-beta.3 → 4.4.0-beta.0

package/src/getManyDtoFastes.js

@@ -0,0 +1,588 @@
+const emptyFilter = require('./emptyFilter');
+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, spanFromParent) {
+	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 = spanFromParent || strategyToSpan(table, strategy);
+	let alias = table._dbName;
+
+	const query = newQuery(table, filter, span, alias);
+	const res = await executeQueries([query]);
+	return decode(strategy, span, await res[0]);
+}
+
+function newCreateRow(span) {
+	let columnsMap = span.columns;
+	const columns = span.table._columns.filter(column => !columnsMap || columnsMap.get(column));
+	const protoRow = createProto(columns, span);
+	const manyNames = [];
+
+	const c = {};
+	c.visitJoin = () => { };
+	c.visitOne = () => { };
+	c.visitMany = function (leg) {
+		manyNames.push(leg.name);
+	};
+
+	span.legs.forEach(onEachLeg);
+	return createRow;
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	function createRow() {
+		const obj = Object.create(protoRow);
+		for (let i = 0; i < manyNames.length; i++) {
+			obj[manyNames[i]] = [];
+		}
+		return obj;
+	}
+}
+
+function createProto(columns, span) {
+	let obj = {};
+	for (let i = 0; i < columns.length; i++) {
+		obj[columns[i].alias] = null;
+	}
+	for (let key in span.aggregates) {
+		obj[key] = null;
+	}
+	const c = {};
+
+	c.visitJoin = function (leg) {
+		obj[leg.name] = null;
+	};
+	c.visitOne = c.visitJoin;
+	c.visitMany = function (leg) {
+		obj[leg.name] = null;
+	};
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	return obj;
+}
+
+function hasManyRelations(span) {
+	let result;
+	const c = {};
+	c.visitJoin = () => { };
+	c.visitOne = c.visitJoin;
+	c.visitMany = function () {
+		result = true;
+	};
+
+	span.legs.forEach(onEachLeg);
+	return result;
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+}
+
+async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys(rows[0]) : []) {
+	const table = span.table;
+	let columnsMap = span.columns;
+	const columns = table._columns.filter(column => !columnsMap || columnsMap.get(column));
+	const rowsLength = rows.length;
+	const columnsLength = columns.length;
+	const primaryColumns = table._primaryColumns;
+	const primaryColumnsLength = primaryColumns.length;
+	const rowsMap = new Map();
+	const fkIds = new Array(rows.length);
+	const getIds = createGetIds();
+	const aggregateKeys = Object.keys(span.aggregates);
+
+	const outRows = new Array(rowsLength);
+	const createRow = newCreateRow(span);
+	const shouldCreateMap = hasManyRelations(span);
+	for (let i = 0; i < rowsLength; i++) {
+		const row = rows[i];
+		let outRow = createRow();
+		let pkWithNullCount = 0;
+		for (let j = 0; j < columnsLength; j++) {
+			if (j < primaryColumnsLength) {
+				if (row[keys[j]] === null)
+					pkWithNullCount++;
+				if (pkWithNullCount === primaryColumnsLength) {
+					outRow = null;
+					break;
+				}
+				const column = columns[j];
+				outRow[column.alias] = column.decode(row[keys[j]]);
+				// fkId = outRow[column.alias];
+			}
+			else {
+				const column = columns[j];
+				outRow[column.alias] = column.decode(row[keys[j]]);
+			}
+			// const column = columns[j];
+			// outRow[column.alias] = column.decode(row[keys[j]]);
+
+		}
+
+		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 + columnsLength]]);
+		}
+
+		outRows[i] = outRow;
+		if (shouldCreateMap && outRow) {
+			// fkIds[i] = fkId;			
+			fkIds[i] = getIds(outRow);
+			// console.dir(fkIds[i]);
+			addToMap(rowsMap, primaryColumns, outRow);
+		}
+	}
+	span._rowsMap = rowsMap;
+	span._ids = fkIds;
+
+	keys.splice(0, columnsLength + aggregateKeys.length);
+	if (span.legs.toArray().length === 0)
+		return outRows;
+
+	//alt 1
+	// 3.1 sec
+	// await new Promise((resolve, reject) => {
+	// 	setTimeout(() => {
+	// 		if (shouldCreateMap)
+	// 			decodeManyRelations(strategy, span, rows, outRows, keys)
+	// 				.then(() => decodeRelations2(strategy, span, rows, outRows, keys))
+	// 				.then(resolve)
+	// 				.catch(reject);
+	// 		else
+	// 			decodeRelations2(strategy, span, rows, outRows, keys)
+	// 				.then(resolve)
+	// 				.catch(reject);
+	// 	}, 0);
+	// });
+
+
+	//alt 1
+	// 3.2 sec
+	// await new Promise((resolve, reject) => {
+	// 	setTimeout(() => {
+	// 		const all = [];
+	// 		if (shouldCreateMap) 
+	// 			all.push(decodeManyRelations(strategy, span, rows, outRows, keys))
+
+	// 		all.push(new Promise((resolve, reject) => {
+	// 			setTimeout(async () => {
+	// 				await decodeRelations2(strategy, span, rows, outRows, keys);
+	// 				resolve();
+
+	// 			}, 0);
+	// 		}));
+	// 		// const p2 = decodeRelations2(strategy, span, rows, outRows, keys);
+	// 		Promise.all(all).then(resolve, reject);				
+	// 	}, 0);
+	// });
+
+
+	// let all = [];;
+	// if(shouldCreateMap) {
+
+	// 	await decodeManyRelations(strategy, span, rows, outRows, keys).then(() => decodeRelations2(strategy, span, rows, outRows, keys));		
+	// }
+	// else
+	// 	await  decodeRelations2(strategy, span, rows, outRows, keys);
+
+	// await Promise.all(all);
+
+
+
+	//alt 3
+	// 3.05 sec
+	let all = [];;
+
+	if(shouldCreateMap) {
+		// all.push( decodeRelations2(strategy, span, rows, outRows, keys).then(() => decodeManyRelations(strategy, span)));
+		all.push( decodeManyRelations(strategy, span));
+		all.push(decodeRelations2(strategy, span, rows, outRows, keys));
+		// all.push( decodeManyRelations(strategy, span).then(() => decodeRelations2(strategy, span, rows, outRows, keys)));
+		// all.push( decodeManyRelations(strategy, span));
+		// all.push(decodeRelations2(strategy, span, rows, outRows, keys));
+		// all.push( decodeRelations2(strategy, span, rows, outRows, keys) );		
+	}
+	else
+		all.push( decodeRelations2(strategy, span, rows, outRows, keys) );
+
+	await Promise.all(all);
+
+	//alt 4
+	// 3.02 sec
+	// const all = [];
+	// if (shouldCreateMap)
+	// 	// all.push(new Promise((resolve, reject) => {
+	// 	// 	setTimeout(async () => {
+	// 	// 		await decodeManyRelations(strategy, span);
+	// 	// 		resolve();
+
+	// 	// 	}, 0)
+	// 	// }));
+	// all.push(decodeManyRelations(strategy, span));
+	// all.push(new Promise((resolve, reject) => {
+	// 	setTimeout(async () => {
+	// 		await decodeRelations2(strategy, span, rows, outRows, keys);
+	// 		resolve();
+
+	// 	}, 0);
+	// }));
+	// await Promise.all(all);
+
+	// all.push(decodeRelations2(strategy, span, rows, outRows, keys));
+
+	//alt 4
+	// 3.3 sec
+	// if(shouldCreateMap) 
+	// 	await decodeRelations(strategy, span, rows, outRows, keys);
+	// else
+	// 	await decodeRelations2(strategy, span, rows, outRows, keys);
+
+	// await decodeRelationsNext(strategy, span, rows, outRows, keys);
+	// await decodeRelations(strategy, span, rows, outRows, keys);
+
+	return outRows;
+
+
+	function createGetIds() {
+		const primaryColumns = table._primaryColumns;
+		const length = primaryColumns.length;
+		if (length === 1) {
+			const alias = table._primaryColumns[0].alias;
+			return (row) => row[alias];
+		}
+		else
+			return (row) => {
+				const result = new Array(length);
+				for (let i = 0; i < length; i++) {
+					result[i] = row[primaryColumns[i].alias];
+				}
+				return result;
+			};
+	}
+
+}
+async function decodeRelations2(strategy, span, rawRows, resultRows, keys) {
+	const legs = span.legs.toArray();
+	if (legs.length === 0)
+		return;
+	const promises = [];
+	const c = {};
+	c.visitJoin = function (leg) {
+		const name = leg.name;
+		const p = decode(strategy[name], leg.span, rawRows, keys).then((rows) => {
+			for (let i = 0; i < rows.length; i++) {
+				resultRows[i][name] = rows[i];
+			}
+		});
+		promises.push(p);
+	};
+
+	c.visitOne = c.visitJoin;
+
+	c.visitMany = () => { };
+
+	function processLegs(index) {
+		if (index >= legs.length) {
+			return;
+		}
+		const leg = legs[index];
+		leg.accept(c);
+		Promise.all(promises).then(() => {
+			setImmediate(() => {
+				processLegs(index + 1);
+			});
+		});
+	}
+
+	processLegs(0);
+
+	await Promise.all(promises);
+}
+
+async function decodeRelations3(strategy, span, rawRows, resultRows, keys) {
+	const promises = [];
+	const c = {};
+	c.visitJoin = function (leg) {
+		const name = leg.name;
+		const p = decode(strategy[name], leg.span, rawRows, keys).then((rows) => {
+			for (let i = 0; i < rows.length; i++) {
+				resultRows[i][name] = rows[i];
+			}
+		});
+		promises.push(p);
+	};
+
+	c.visitOne = c.visitJoin;
+
+	c.visitMany = () => { };
+
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	await Promise.all(promises);
+}
+
+
+async function decodeManyRelations(strategy, span, rawRows, resultRows, keys) {
+	const promises = [];
+	const c = {};
+	c.visitJoin = () => { };
+	c.visitOne = c.visitJoin;
+
+	c.visitMany = function (leg) {
+		const name = leg.name;
+		const table = span.table;
+		const relation = table._relations[name];
+		const filter = createOneFilter(relation, span._ids);
+		const rowsMap = span._rowsMap;
+		const p = getManyDto(relation.childTable, filter, strategy[name], leg.span).then(subRows => {
+			for (let i = 0; i < subRows.length; i++) {
+				const key = leg.columns.map(column => subRows[i][column.alias]);
+				const parentRow = getFromMap(rowsMap, table._primaryColumns, key);
+				parentRow[name].push(subRows[i]);
+			}
+		});
+		promises.push(p);
+	};
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	// 	await Promise.all(promises);
+	// }
+
+	// async function decodeRelations2(strategy, span, rawRows, resultRows, keys) {
+	// 	const promises = [];
+	// 	const c = {};
+	// c.visitJoin = function (leg) {
+	// 	const name = leg.name;
+	// 	//todo avoid traverse twice noMany relations below
+	// 	const p = decode(strategy[name], leg.span, rawRows, keys).then((rows) => {
+	// 		for (let i = 0; i < rows.length; i++) {
+	// 			resultRows[i][name] = rows[i];
+	// 		}
+	// 	});
+	// 	promises.push(p);
+	// };
+
+	// c.visitOne = c.visitJoin;
+
+	// c.visitMany = () => { };
+
+	// span.legs.forEach(onEachLeg);
+
+	// function onEachLeg(leg) {
+	// 	leg.accept(c);
+	// }
+
+	await Promise.all(promises);
+}
+
+async function decodeRelations3(strategy, span, rawRows, resultRows, keys) {
+
+	let previous = new Promise((resolve) => setImmediate(() => resolve()));
+	const c = {};
+
+	c.visitJoin = function (leg) {
+		const name = leg.name;
+		const p = new Promise((resolve) => {
+			setImmediate(() => {
+				decode(strategy[name], leg.span, rawRows, keys).then((rows) => {
+					for (let i = 0; i < rows.length; i++) {
+						resultRows[i][name] = rows[i];
+					}
+					resolve();
+				});
+			});
+		});
+		previous = previous.then(() => p);
+	};
+
+	c.visitOne = c.visitJoin;
+
+	c.visitMany = () => { };
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	await previous;
+
+}
+
+
+async function decodeRelationsNext(strategy, span, rawRows, resultRows, keys) {
+	// const promises = [];
+	let previous = new Promise((resolve) => setImmediate(() => resolve()));
+	const c = {};
+
+	c.visitJoin = function (leg) {
+		const name = leg.name;
+		const p = new Promise((resolve) => {
+			setImmediate(() => {
+				decode(strategy[name], leg.span, rawRows, keys).then((rows) => {
+					for (let i = 0; i < rows.length; i++) {
+						resultRows[i][name] = rows[i];
+					}
+					resolve();
+				});
+			});
+		});
+		previous = previous.then(() => p);
+	};
+
+	c.visitOne = c.visitJoin;
+
+	c.visitMany = function (leg) {
+		const p = new Promise((resolve, reject) => {
+			setImmediate(() => {
+
+				const name = leg.name;
+				const table = span.table;
+				const relation = table._relations[name];
+				const filter = createOneFilter(relation, span._ids);
+				const rowsMap = span._rowsMap;
+
+				getManyDto(relation.childTable, filter, strategy[name], leg.span).then(subRows => {
+					for (let i = 0; i < subRows.length; i++) {
+						const key = leg.columns.map(column => subRows[i][column.alias]);
+						const parentRow = getFromMap(rowsMap, table._primaryColumns, key);
+						parentRow[name].push(subRows[i]);
+					}
+				}).then(() => resolve(), reject);
+
+
+			});
+		});
+
+
+		previous = previous.then(() => p);
+		// promises.push(p);
+	};
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	await previous
+}
+
+
+async function decodeRelations(strategy, span, rawRows, resultRows, keys) {
+	const promises = [];
+	const c = {};
+	c.visitJoin = function (leg) {
+		const name = leg.name;
+		const p = decode(strategy[name], leg.span, rawRows, keys).then((rows) => {
+			for (let i = 0; i < rows.length; i++) {
+				resultRows[i][name] = rows[i];
+			}
+		});
+		promises.push(p);
+	};
+
+	c.visitOne = c.visitJoin;
+
+	c.visitMany = function (leg) {
+		const name = leg.name;
+		const table = span.table;
+		const relation = table._relations[name];
+		const filter = createOneFilter(relation, span._ids);
+		const rowsMap = span._rowsMap;
+		const p = getManyDto(relation.childTable, filter, strategy[name], leg.span).then(subRows => {
+			for (let i = 0; i < subRows.length; i++) {
+				const key = leg.columns.map(column => subRows[i][column.alias]);
+				const parentRow = getFromMap(rowsMap, table._primaryColumns, key);
+				parentRow[name].push(subRows[i]);
+			}
+		});
+		promises.push(p);
+	};
+
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	await Promise.all(promises);
+}
+
+function createOneFilter(relation, ids) {
+	const columns = relation.joinRelation.columns;
+
+	if (columns.length === 1)
+		return columns[0].in(ids);
+
+	else
+		return createCompositeFilter();
+
+	function createCompositeFilter() {
+		let filter = emptyFilter;
+		for (let id of ids) {
+			let nextFilter;
+			for (let i = 0; i < columns.length; i++) {
+				if (nextFilter)
+					nextFilter = nextFilter.and(columns[i].eq(id[i]));
+				else
+					nextFilter = columns[i].eq(id[i]);
+			}
+			filter = filter.or(nextFilter);
+		}
+		return filter;
+	}
+}
+
+function addToMap(map, primaryColumns, row) {
+
+	const lastIndex = primaryColumns.length - 1;
+	for (let i = 0; i < lastIndex; i++) {
+		const id = row[primaryColumns[i].alias];
+		if (map.has(id))
+			map = map.get(id);
+		else {
+			const next = new Map();
+			map.set(id, next);
+			map = next;
+		}
+	}
+	map.set(row[primaryColumns[lastIndex].alias], row);
+}
+
+function getFromMap(map, primaryColumns, values) {
+	const length = primaryColumns.length;
+	for (let i = 0; i < length; i++) {
+		map = map.get(values[i]);
+	}
+	return map;
+}
+
+
+module.exports = getManyDto;

package/src/table/column/binary/newEncode.js

@@ -17,6 +17,13 @@ function _new(_column) {
 		return Buffer.from(value, 'base64');
 	};
 
+	encode.direct = function(value) {
+		value = purify(value);
+		if (value === null)
+			return null;
+		return Buffer.from(value, 'base64');
+	};
+
 	return encode;
 }
 

package/src/table/column/boolean/newEncode.js

@@ -30,6 +30,18 @@ function _new(column) {
 		return encodeCore(value);
 	};
 
+	encode.direct = function(value) {
+		value = purify(value);
+		if (value === null) {
+			if (column.dbNull === null)
+				return null;
+			return column.dbNull ;
+		}
+		var encodeCore = getSessionSingleton('encodeBoolean');
+
+		return encodeCore(value);
+	};
+
 	return encode;
 }
 

package/src/table/column/date/newEncode.js

@@ -21,8 +21,19 @@ function _new(column) {
 		value = purify(value);
 		if (value == null) {
 			if (column.dbNull === null)
-				return newPara('null');
-			return newPara('\'' + column.dbNull + '\'');
+				'null';
+			return '\'' + column.dbNull + '\'';
+		}
+		var encodeCore = getSessionSingleton('encodeDate') || encodeDate;
+		return encodeCore(value);
+	};
+
+	encode.direct = function(value) {
+		value = purify(value);
+		if (value == null) {
+			if (column.dbNull === null)
+				null;
+			return column.dbNull;
 		}
 		var encodeCore = getSessionSingleton('encodeDate') || encodeDate;
 		return encodeCore(value);

package/src/table/column/dateWithTimeZone/newEncode.js

@@ -23,6 +23,16 @@ function _new(column) {
 		return encodeDate(value);
 	};
 
+	encode.direct = function(value) {
+		value = purify(value);
+		if (value == null) {
+			if (column.dbNull === null)
+				return null;
+			return column.dbNull;
+		}
+		return encodeDate(value);
+	};
+
 	return encode;
 
 

package/src/table/column/guid/newEncode.js

@@ -23,6 +23,16 @@ function _new(column) {
 		return '\'' + value + '\'';
 	};
 
+	encode.direct = function(candidate) {
+		var value = purify(candidate);
+		if (value == null) {
+			if (column.dbNull === null)
+				return null;
+			return column.dbNull;
+		}
+		return value ;
+	};
+
 
 	return encode;
 }

package/src/table/column/in.js

@@ -1,25 +1,22 @@
-var newParameterized = require('../query/newParameterized');
-var newBoolean = require('./newBoolean');
-var encodeFilterArg = require('./encodeFilterArg');
-var quote = require('../quote');
+const newParameterized = require('../query/newParameterized');
+const newBoolean = require('./newBoolean');
+const quote = require('../quote');
 
 function _in(column,values,alias) {
-	var filter;
+	let filter;
 	if (values.length === 0) {
 		filter =  newParameterized('1=2');
 		return newBoolean(filter);
 	}
-	var firstPart = quote(alias) + '.' + quote(column._dbName) + ' in ';
-	var parameterized = newParameterized(firstPart);
-	var separator = '(';
+	const firstPart = `${quote(alias)}.${quote(column._dbName)} in (`;
 
-	for (var i = 0; i < values.length; i++) {
-		var encoded = encodeFilterArg(column, values[i]);
-		parameterized = parameterized.append(separator).append(encoded);
-		separator = ',';
+	const encode = column.encode.direct;
+	const params = new Array(values.length);
+	for (let i = 0; i < values.length; i++) {
+		params[i] = encode(values[i]);
 	}
-	filter =  parameterized.append(')');
-	return newBoolean(filter);
+	const sql = `${firstPart +  new Array(values.length).fill('?').join(',')})`;
+	return newBoolean(newParameterized(sql, params));
 }
 
 module.exports = _in;