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

package/getManyDtoFast.js

@@ -0,0 +1,530 @@
+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]]);
+		}
+
+		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) {
+			fkIds[i] = getIds(outRow);
+			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( decodeManyRelations(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(decodeManyRelations(strategy, span, rows, outRows, keys));
+	// 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 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orange-orm",
-  "version": "4.3.0-beta.3",
+  "version": "4.4.0-beta.0",
   "main": "./src/index.js",
   "browser": "./src/client/index.mjs",
   "bin": {
@@ -104,11 +104,11 @@
   "devDependencies": {
     "@rollup/plugin-commonjs": "^21.0.1",
     "@rollup/plugin-node-resolve": "^13.0.0",
-    "@typescript-eslint/eslint-plugin": "^5.42.1",
-    "@typescript-eslint/parser": "^5.42.1",
+    "@typescript-eslint/eslint-plugin": "^6.x",
+    "@typescript-eslint/parser": "^6.x",
     "@vitest/coverage-v8": "^0.34.1",
     "cors": "^2.8.5",
-    "eslint": "^8.6.0",
+    "eslint": "^8.57.0",
     "eslint-plugin-jest": "^27.1.7",
     "express": "^4.18.2",
     "msnodesqlv8": "^4.1.0",