perf: partially lift matching from regexp to js (typeorm#9032)

Digging further into typeorm#3857.

See also typeorm#8955, typeorm#8956.

As [previously
discussed](typeorm#3857 (comment)),
the query builder currently suffers from poor performance in two ways:
quadratic numbers of operations with respect to total table/column
counts, and poor constant factor performance (regexps can be expensive
to build/run!)

The constant-factor performance is the more tractable problem: no longer
quadratically looping would be a chunky rewrite of the query builder,
but we can locally refactor to be a bunch cheaper in terms of regexp
operations.

This change cuts the benchmark time here in ~half (yay!).

We achieve this by simplifying the overall replacement regexp (we don't
need our column names in there, since we already have a plain object
where they're the keys to match against) so compilation of that is much
cheaper, plus skipping the need to `escapeRegExp` every column as a
result.

src/query-builder/QueryBuilder.ts

@@ -617,18 +617,27 @@ export abstract class QueryBuilder<Entity> {
                 replacements[column.propertyPath] = column.databaseName;
             }
 
-            const replacementKeys = Object.keys(replacements);
-
-            if (replacementKeys.length) {
-                statement = statement.replace(new RegExp(
-                    `(?<=[ =\(]|^.{0})` +
-                    `${escapeRegExp(replaceAliasNamePrefix)}(${replacementKeys.map(escapeRegExp).join("|")})` +
-                    `(?=[ =\)\,]|.{0}$)`,
-                    "gm"
-                ), (_, p) =>
-                    `${replacementAliasNamePrefix}${this.escape(replacements[p])}`
-                );
-            }
+            statement = statement.replace(
+                new RegExp(
+                    // Avoid a lookbehind here since it's not well supported
+                    `([ =\(]|^.{0})` + // any of ' =(' or start of line
+                        // followed by our prefix, e.g. 'tablename.' or ''
+                        `${escapeRegExp(
+                            replaceAliasNamePrefix,
+                        )}([^ =\(\)\,]+)` + // a possible property name: sequence of anything but ' =(),'
+                        // terminated by ' =),' or end of line
+                        `(?=[ =\)\,]|.{0}$)`,
+                    "gm",
+                ),
+                (match, pre, p) => {
+                    if (replacements[p]) {
+                        return `${pre}${replacementAliasNamePrefix}${this.escape(
+                            replacements[p],
+                        )}`;
+                    }
+                    return match;
+                },
+            );
         }
 
         return statement;

test/benchmark/multiple-joins-querybuilder/multiple-joins-querybuilder.ts

@@ -47,11 +47,11 @@ describe("benchmark > QueryBuilder > wide join", () => {
 
         /**
          * On a M1 macbook air, 5 runs:
-         * 3501ms
-         * 3574ms
-         * 3575ms
-         * 3563ms
-         * 3567ms
+         * 1861ms
+         * 1850ms
+         * 1859ms
+         * 1859ms
+         * 1884ms
          */
     })
 })