@query-doctor/core 0.2.4 → 0.3.0

package/dist/index.js

@@ -780,6 +780,9 @@ var PostgresQueryBuilder = class _PostgresQueryBuilder {
     __publicField(this, "isIntrospection", false);
     __publicField(this, "explainFlags", []);
     __publicField(this, "_preamble", 0);
+    __publicField(this, "parameters", {});
+    // substitution for `limit $1` -> `limit 5`
+    __publicField(this, "limitSubstitution");
   }
   get preamble() {
     return this._preamble;
@@ -813,6 +816,14 @@ var PostgresQueryBuilder = class _PostgresQueryBuilder {
     this.explainFlags = flags;
     return this;
   }
+  parameterize(parameters) {
+    Object.assign(this.parameters, parameters);
+    return this;
+  }
+  replaceLimit(limit) {
+    this.limitSubstitution = limit;
+    return this;
+  }
   build() {
     let commands = this.generateSetCommands();
     commands += this.generateExplain().query;
@@ -841,14 +852,28 @@ var PostgresQueryBuilder = class _PostgresQueryBuilder {
     return commands;
   }
   generateExplain() {
-    let query = "";
+    let finalQuery = "";
     if (this.explainFlags.length > 0) {
-      query += `explain (${this.explainFlags.join(", ")}) `;
+      finalQuery += `explain (${this.explainFlags.join(", ")}) `;
+    }
+    const query = this.substituteQuery();
+    const semicolon = query.endsWith(";") ? "" : ";";
+    const preamble = finalQuery.length;
+    finalQuery += `${query}${semicolon}`;
+    return { query: finalQuery, preamble };
+  }
+  substituteQuery() {
+    let query = this.query;
+    if (this.limitSubstitution !== void 0) {
+      query = query.replace(
+        /limit\s+\$\d+/g,
+        `limit ${this.limitSubstitution}`
+      );
     }
-    const semicolon = this.query.endsWith(";") ? "" : ";";
-    const preamble = query.length;
-    query += `${this.query}${semicolon}`;
-    return { query, preamble };
+    for (const [key, value] of Object.entries(this.parameters)) {
+      query = query.replaceAll(`\\$${key}`, value.toString());
+    }
+    return query;
   }
 };
 
@@ -866,7 +891,9 @@ var _PgIdentifier = class _PgIdentifier {
     const identifierRegex = /^[a-z_][a-zA-Z0-9_]*$/;
     const match = identifier.match(/^"(.+)"$/);
     if (match) {
-      return new _PgIdentifier(match[1], true);
+      const value = match[1];
+      const quoted2 = !identifierRegex.test(value) || this.reservedKeywords.has(value.toLowerCase());
+      return new _PgIdentifier(value, quoted2);
     }
     const quoted = !identifierRegex.test(identifier) || this.reservedKeywords.has(identifier.toLowerCase());
     return new _PgIdentifier(identifier, quoted);
@@ -1071,6 +1098,24 @@ var PgIdentifier = _PgIdentifier;
 
 // src/optimizer/genalgo.ts
 import { blue as blue2, gray, green, magenta, red, yellow } from "colorette";
+
+// src/sql/permutations.ts
+function permutationsWithDescendingLength(arr) {
+  const collected = [];
+  function collect(path, rest) {
+    for (let i = 0; i < rest.length; i++) {
+      const nextRest = [...rest.slice(0, i), ...rest.slice(i + 1)];
+      const nextPath = [...path, rest[i]];
+      collected.push(nextPath);
+      collect(nextPath, nextRest);
+    }
+  }
+  collect([], arr);
+  collected.sort((a, b) => b.length - a.length);
+  return collected;
+}
+
+// src/optimizer/genalgo.ts
 var _IndexOptimizer = class _IndexOptimizer {
   constructor(db, statistics, existingIndexes, config = {}) {
     this.db = db;
@@ -1203,14 +1248,12 @@ var _IndexOptimizer = class _IndexOptimizer {
    * Derive the list of indexes [tableA(X, Y, Z), tableB(H, I, J)]
    **/
   indexesToCreate(rootCandidates) {
-    const permutedIndexes = this.tableColumnIndexCandidates(rootCandidates);
+    const permutedIndexes = this.groupPotentialIndexColumnsByTable(rootCandidates);
     const nextStage = [];
     for (const permutation of permutedIndexes.values()) {
       const { table: rawTable, schema: rawSchema, columns } = permutation;
-      const permutations = permuteWithFeedback(columns);
-      let iter = permutations.next(PROCEED);
-      while (!iter.done) {
-        const columns2 = iter.value;
+      const permutations = permutationsWithDescendingLength(columns);
+      for (const columns2 of permutations) {
         const schema = PgIdentifier.fromString(rawSchema);
         const table = PgIdentifier.fromString(rawTable);
         const existingIndex = this.indexAlreadyExists(
@@ -1218,12 +1261,10 @@ var _IndexOptimizer = class _IndexOptimizer {
           columns2
         );
         if (existingIndex) {
-          iter = permutations.next(PROCEED);
           continue;
         }
         const indexName = this.indexName();
         const definition = this.toDefinition({ table, schema, columns: columns2 }).raw;
-        iter = permutations.next(PROCEED);
         nextStage.push({
           name: indexName,
           schema: schema.toString(),
@@ -1355,7 +1396,7 @@ var _IndexOptimizer = class _IndexOptimizer {
     }
     throw new Error("Unreachable");
   }
-  tableColumnIndexCandidates(indexes) {
+  groupPotentialIndexColumnsByTable(indexes) {
     const tableColumns = /* @__PURE__ */ new Map();
     for (const index of indexes) {
       const existing = tableColumns.get(`${index.schema}.${index.table}`);
@@ -1425,21 +1466,6 @@ var RollbackError = class {
 };
 var PROCEED = Symbol("PROCEED");
 var SKIP = Symbol("SKIP");
-function* permuteWithFeedback(arr) {
-  function* helper(path, rest) {
-    let i = 0;
-    while (i < rest.length) {
-      const nextPath = [...path, rest[i]];
-      const nextRest = [...rest.slice(0, i), ...rest.slice(i + 1)];
-      const input = yield nextPath;
-      if (input === PROCEED) {
-        yield* helper(nextPath, nextRest);
-      }
-      i++;
-    }
-  }
-  yield* helper([], arr);
-}
 
 // src/optimizer/statistics.ts
 import { gray as gray2 } from "colorette";
@@ -2155,7 +2181,6 @@ export {
   ignoredIdentifier,
   isIndexProbablyDroppable,
   isIndexSupported,
-  parseNudges,
-  permuteWithFeedback
+  parseNudges
 };
 //# sourceMappingURL=index.js.map