orange-orm 4.3.0 → 4.4.0-beta.0

package/src/getManyDto.js

@@ -19,62 +19,92 @@ async function getManyDto(table, filter, strategy, spanFromParent) {
 	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 newCreateRow(span) {
-	let columnsMap = span.columns;
+	const columnsMap = span.columns;
 	const columns = span.table._columns.filter(column => !columnsMap || columnsMap.get(column));
-	const protoRow = createProto(columns, span);
+	const ProtoRow = createProto(columns, span);
 	const manyNames = [];
 
-	const c = {};
-	c.visitJoin = () => { };
-	c.visitOne = () => { };
-	c.visitMany = function(leg) {
-		manyNames.push(leg.name);
+	const c = {
+		visitJoin: () => { },
+		visitOne: () => { },
+		visitMany: function(leg) {
+			manyNames.push(leg.name);
+		}
 	};
 
-	span.legs.forEach(onEachLeg);
-	return createRow;
+	span.legs.forEach(leg => leg.accept(c));
 
-	function onEachLeg(leg) {
-		leg.accept(c);
-	}
+	return createRow;
 
 	function createRow() {
-		const obj = Object.create(protoRow);
-		for (let i = 0; i < manyNames.length; i++) {
-			obj[manyNames[i]] = [];
-		}
+		const obj = new ProtoRow();
+		manyNames.forEach(name => {
+			obj[name] = [];
+		});
 		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 = {};
+	function ProtoRow() {
+		columns.forEach(column => {
+			this[column.alias] = null;
+		});
 
-	c.visitJoin = function(leg) {
-		obj[leg.name] = null;
-	};
-	c.visitOne = c.visitJoin;
-	c.visitMany = function(leg) {
-		obj[leg.name] = null;
-	};
+		for (const key in span.aggregates) {
+			this[key] = null;
+		}
 
-	span.legs.forEach(onEachLeg);
+		const c = {
+			visitJoin: (leg) => {
+				this[leg.name] = null;
+			},
+			visitOne: (leg) => {
+				this[leg.name] = null;
+			},
+			visitMany: (leg) => {
+				this[leg.name] = null;
+			}
+		};
 
-	function onEachLeg(leg) {
-		leg.accept(c);
+		span.legs.forEach(leg => leg.accept(c));
 	}
 
-	return obj;
+	return ProtoRow;
 }
 
+
 function hasManyRelations(span) {
 	let result;
 	const c = {};
@@ -92,7 +122,7 @@ function hasManyRelations(span) {
 	}
 }
 
-async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys(rows[0]) : []) {
+async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys(rows[0]) : [], parentRows, parentProp) {
 	const table = span.table;
 	let columnsMap = span.columns;
 	const columns = table._columns.filter(column => !columnsMap || columnsMap.get(column));
@@ -132,9 +162,11 @@ async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys
 		}
 
 		outRows[i] = outRow;
+		if (parentRows)
+			parentRows[i][parentProp] = outRow;
 		if (shouldCreateMap) {
 			fkIds[i] = getIds(outRow);
-			addToMap(rowsMap, primaryColumns, outRow);
+			addToMap(rowsMap, fkIds[i], outRow);
 		}
 	}
 	span._rowsMap = rowsMap;
@@ -185,18 +217,38 @@ async function decodeManyRelations(strategy, span) {
 		const name = leg.name;
 		const table = span.table;
 		const relation = table._relations[name];
-		const filter = createOneFilter(relation, span._ids);
 		const rowsMap = span._rowsMap;
+
+		const filter = createOneFilter(relation, span._ids);
+		const extractKey = createExtractKey(leg);
+		const extractFromMap = createExtractFromMap(rowsMap, table._primaryColumns);
 		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);
+				const key = extractKey(subRows[i]);
+				const parentRow = extractFromMap(key);
 				parentRow[name].push(subRows[i]);
 			}
 		});
 		promises.push(p);
 	};
 
+	function createExtractKey(leg) {
+		if (leg.columns.length === 1) {
+			const alias = leg.columns[0].alias;
+			return (row) => row[alias];
+		}
+		else {
+			const aliases = leg.columns.map(column => column.alias);
+			return (row) => aliases.map(alias => row[alias]);
+		}
+	}
+	function createExtractFromMap(map, primaryColumns) {
+		if (primaryColumns.length === 1)
+			return (key) => map.get(key);
+		else
+			return getFromMap.bind(null, map, primaryColumns);
+	}
+
 	span.legs.forEach(onEachLeg);
 
 	function onEachLeg(leg) {
@@ -211,11 +263,7 @@ async function decodeRelations2(strategy, span, rawRows, resultRows, keys) {
 	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];
-			}
-		});
+		const p = decode(strategy[name], leg.span, rawRows, keys, resultRows, name);
 		promises.push(p);
 	};
 
@@ -233,47 +281,6 @@ async function decodeRelations2(strategy, span, rawRows, resultRows, keys) {
 	await Promise.all(promises);
 }
 
-
-// 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;
 
@@ -299,28 +306,36 @@ function createOneFilter(relation, ids) {
 	}
 }
 
-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;
+function addToMap(map, values, row) {
+	if (Array.isArray(values)) {
+
+		const lastIndex = values.length - 1;
+		for (let i = 0; i < lastIndex; i++) {
+			const id = values[i];
+			if (map.has(id))
+				map = map.get(id);
+			else {
+				const next = new Map();
+				map.set(id, next);
+				map = next;
+			}
 		}
+		map.set(values[lastIndex], row);
 	}
-	map.set(row[primaryColumns[lastIndex].alias], row);
+	else
+		map.set(values, row);
 }
 
 function getFromMap(map, primaryColumns, values) {
-	const length = primaryColumns.length;
-	for (let i = 0; i < length; i++) {
-		map = map.get(values[i]);
+	if (Array.isArray(values)) {
+		const length = primaryColumns.length;
+		for (let i = 0; i < length; i++) {
+			map = map.get(values[i]);
+		}
+		return map;
 	}
-	return map;
+	else
+		return map.get(values);
 }
 
 

package/src/getManyDtoFast2.js

@@ -0,0 +1,293 @@
+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);
+	const promises = [];
+	for (let i = 0; i < rowsLength; i++) {
+		const row = rows[i];
+		let outRow = createRow();
+		let pkWithNullCount = 0;
+		for (let j = 0; j < primaryColumnsLength; j++) {
+			if (row[keys[j]] === null)
+				pkWithNullCount++;
+			if (pkWithNullCount === primaryColumnsLength) {
+				outRow = null;
+				break;
+			}
+			const column = columns[j];
+			outRow[column.alias] = column.decode(row[keys[j]]);
+		}
+
+		outRows[i] = outRow;
+		if (outRow === null)
+			continue;
+		if (shouldCreateMap) {
+			fkIds[i] = getIds(outRow);
+			addToMap(rowsMap, primaryColumns, outRow);
+		}
+
+		// Execute code inside start and stop in the next event loop and as a promise
+		promises.push(new Promise((resolve) => {
+			((currentRow, currentOutRow) => {
+				setTimeout(async () => {
+					for (let j = primaryColumnsLength; j < columnsLength; j++) {
+						const column = columns[j];
+						currentOutRow[column.alias] = column.decode(currentRow[keys[j]]);
+					}
+
+					for (let j = 0; j < aggregateKeys.length; j++) {
+						const key = aggregateKeys[j];
+						const parse = span.aggregates[key].column?.decode || Number.parseFloat;
+						currentOutRow[key] = parse(currentRow[keys[j + columnsLength]]);
+					}
+
+					resolve();
+				}, 0);
+			})(row, outRow);
+		}));
+	}
+	span._rowsMap = rowsMap;
+	span._ids = fkIds;
+
+	const many = decodeManyRelations(strategy, span);
+
+	const p = Promise.all(promises).then(() => {
+		keys.splice(0, columnsLength + aggregateKeys.length);
+		return decodeRelations(strategy, span, rows, outRows, keys)
+	});
+	await Promise.all([many, p]);
+	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 decodeManyRelations(strategy, span) {
+	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 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 = () => { };
+
+	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;