@query-doctor/core 0.2.3 → 0.2.5

package/dist/index.cjs

@@ -53,8 +53,7 @@ __export(index_exports, {
   ignoredIdentifier: () => ignoredIdentifier,
   isIndexProbablyDroppable: () => isIndexProbablyDroppable,
   isIndexSupported: () => isIndexSupported,
-  parseNudges: () => parseNudges,
-  permuteWithFeedback: () => permuteWithFeedback
+  parseNudges: () => parseNudges
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -916,7 +915,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);
@@ -1121,6 +1122,24 @@ var PgIdentifier = _PgIdentifier;
 
 // src/optimizer/genalgo.ts
 var import_colorette2 = require("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;
@@ -1222,21 +1241,43 @@ var _IndexOptimizer = class _IndexOptimizer {
   // TODO: this doesn't belong in the optimizer
   indexAlreadyExists(table, columns) {
     return this.existingIndexes.find(
-      (index) => index.index_type === "btree" && index.table_name === table && index.index_columns.length === columns.length && index.index_columns.every((c, i) => columns[i].column === c.name)
+      (index) => index.index_type === "btree" && index.table_name === table && index.index_columns.length === columns.length && index.index_columns.every((c, i) => {
+        if (columns[i].column !== c.name) {
+          return false;
+        }
+        if (columns[i].where) {
+          return false;
+        }
+        if (columns[i].sort) {
+          switch (columns[i].sort.dir) {
+            // Sorting is ASC by default in postgres
+            case "SORTBY_DEFAULT":
+            case "SORTBY_ASC":
+              if (c.order !== "ASC") {
+                return false;
+              }
+              break;
+            case "SORTBY_DESC":
+              if (c.order !== "DESC") {
+                return false;
+              }
+              break;
+          }
+        }
+        return true;
+      })
     );
   }
   /**
    * 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(
@@ -1244,12 +1285,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(),
@@ -1381,7 +1420,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}`);
@@ -1451,21 +1490,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
 var import_colorette3 = require("colorette");
@@ -2182,7 +2206,6 @@ var PssRewriter = class {
   ignoredIdentifier,
   isIndexProbablyDroppable,
   isIndexSupported,
-  parseNudges,
-  permuteWithFeedback
+  parseNudges
 });
 //# sourceMappingURL=index.cjs.map