@query-doctor/core 0.0.3 → 0.0.4

package/dist/index.cjs

@@ -41,13 +41,17 @@ __export(index_exports, {
   ExportedStatsV1: () => ExportedStatsV1,
   IndexOptimizer: () => IndexOptimizer,
   PROCEED: () => PROCEED,
+  PgIdentifier: () => PgIdentifier,
   PostgresQueryBuilder: () => PostgresQueryBuilder,
   PostgresVersion: () => PostgresVersion,
   SKIP: () => SKIP,
   Statistics: () => Statistics,
   StatisticsMode: () => StatisticsMode,
   StatisticsSource: () => StatisticsSource,
+  dropIndex: () => dropIndex,
   ignoredIdentifier: () => ignoredIdentifier,
+  isIndexProbablyDroppable: () => isIndexProbablyDroppable,
+  isIndexSupported: () => isIndexSupported,
   parseNudges: () => parseNudges,
   permuteWithFeedback: () => permuteWithFeedback
 });
@@ -749,9 +753,26 @@ var Analyzer = class {
 // src/sql/database.ts
 var import_zod = require("zod");
 var PostgresVersion = import_zod.z.string().brand("PostgresVersion");
+async function dropIndex(tx, index) {
+  try {
+    await tx.exec(`
+      savepoint idx_drop;
+      drop index if exists ${index} cascade;
+    `);
+    return true;
+  } catch (error) {
+    await tx.exec(`rollback to idx_drop`);
+    return false;
+  }
+}
 
-// src/optimizer/genalgo.ts
-var import_colorette2 = require("colorette");
+// src/sql/indexes.ts
+function isIndexSupported(index) {
+  return index.index_type === "btree";
+}
+function isIndexProbablyDroppable(index) {
+  return !index.is_primary && !index.is_unique;
+}
 
 // src/sql/builder.ts
 var PostgresQueryBuilder = class _PostgresQueryBuilder {
@@ -833,7 +854,141 @@ var PostgresQueryBuilder = class _PostgresQueryBuilder {
   }
 };
 
+// src/sql/pg-identifier.ts
+var _PgIdentifier = class _PgIdentifier {
+  constructor(value, quoted) {
+    this.value = value;
+    this.quoted = quoted;
+  }
+  static fromString(identifier) {
+    const identifierRegex = /^[a-z_][a-zA-Z0-9_]*$/;
+    const match = identifier.match(/^"(.+)"$/);
+    if (match) {
+      return new _PgIdentifier(match[1], true);
+    }
+    const quoted = !identifierRegex.test(identifier) || this.reservedKeywords.has(identifier.toLowerCase());
+    return new _PgIdentifier(identifier, quoted);
+  }
+  toString() {
+    if (this.quoted) {
+      return `"${this.value.replace(/"/g, '""')}"`;
+    }
+    return this.value;
+  }
+};
+__publicField(_PgIdentifier, "reservedKeywords", /* @__PURE__ */ new Set([
+  "abort",
+  "analyze",
+  "binary",
+  "cluster",
+  "constraint",
+  "copy",
+  "do",
+  "explain",
+  "extend",
+  "listen",
+  "load",
+  "lock",
+  "move",
+  "new",
+  "none",
+  "notify",
+  "offset",
+  "reset",
+  "setof",
+  "show",
+  "unlisten",
+  "until",
+  "vacuum",
+  "verbose",
+  "all",
+  "any",
+  "asc",
+  "between",
+  "bit",
+  "both",
+  "case",
+  "cast",
+  "char",
+  "character",
+  "check",
+  "coalesce",
+  "collate",
+  "column",
+  "constraint",
+  "cross",
+  "current",
+  "current_date",
+  "current_time",
+  "current_timestamp",
+  "current_user",
+  "dec",
+  "decimal",
+  "default",
+  "desc",
+  "distinct",
+  "else",
+  "end",
+  "except",
+  "exists",
+  "extract",
+  "false",
+  "float",
+  "for",
+  "foreign",
+  "from",
+  "full",
+  "global",
+  "group",
+  "having",
+  "in",
+  "inner",
+  "intersect",
+  "into",
+  "is",
+  "join",
+  "leading",
+  "left",
+  "like",
+  "local",
+  "natural",
+  "nchar",
+  "not",
+  "null",
+  "nullif",
+  "numeric",
+  "on",
+  "or",
+  "order",
+  "outer",
+  "overlaps",
+  "position",
+  "precision",
+  "primary",
+  "public",
+  "references",
+  "right",
+  "select",
+  "session_user",
+  "some",
+  "substring",
+  "table",
+  "then",
+  "to",
+  "transaction",
+  "trim",
+  "true",
+  "union",
+  "unique",
+  "user",
+  "varchar",
+  "when",
+  "where"
+]));
+var PgIdentifier = _PgIdentifier;
+
 // src/optimizer/genalgo.ts
+var import_colorette2 = require("colorette");
 var _IndexOptimizer = class _IndexOptimizer {
   constructor(db, statistics, existingIndexes, config = {}) {
     this.db = db;
@@ -841,8 +996,12 @@ var _IndexOptimizer = class _IndexOptimizer {
     this.existingIndexes = existingIndexes;
     this.config = config;
   }
-  async run(builder, indexes) {
-    const baseExplain = await this.runWithoutIndexes(builder);
+  async run(builder, indexes, beforeQuery) {
+    const baseExplain = await this.testQueryWithStats(builder, async (tx) => {
+      if (beforeQuery) {
+        await beforeQuery(tx);
+      }
+    });
     const baseCost = Number(baseExplain.Plan["Total Cost"]);
     if (baseCost === 0) {
       return {
@@ -850,76 +1009,17 @@ var _IndexOptimizer = class _IndexOptimizer {
         explainPlan: baseExplain
       };
     }
-    console.log("Base cost with current indexes", baseCost);
-    const permutedIndexes = this.tableColumnIndexCandidates(indexes);
-    const nextStage = [];
-    const triedIndexes = /* @__PURE__ */ new Map();
-    for (const { table, schema, columns } of permutedIndexes.values()) {
-      const permutations = permuteWithFeedback(columns);
-      let iter = permutations.next(PROCEED);
-      const previousCost = baseCost;
-      while (!iter.done) {
-        const columns2 = iter.value;
-        const existingIndex = this.indexAlreadyExists(table, columns2);
-        if (existingIndex) {
-          console.log(` <${(0, import_colorette2.gray)("skip")}> ${(0, import_colorette2.gray)(existingIndex.index_name)}`);
-          iter = permutations.next(PROCEED);
-          continue;
-        }
-        let indexDefinition = "?";
-        const indexName = this.indexName();
-        const { raw, colored } = this.toDefinition({
-          columns: columns2,
-          schema,
-          table
-        });
-        const shortenedSchema = schema === "public" ? "" : `"${schema}".`;
-        const indexDefinitionClean = `${shortenedSchema}"${table}"(${columns2.map((c) => `"${c.column}"`).join(", ")})`;
-        indexDefinition = colored;
-        const query = PostgresQueryBuilder.createIndex(
-          raw,
-          indexName
-        ).introspect();
-        triedIndexes.set(indexName, {
-          schema,
-          table,
-          columns: columns2,
-          definition: indexDefinitionClean
-        });
-        const explain = await this.testQueryWithStats(builder, async (sql) => {
-          await sql.exec(query.build());
-        });
-        const explainCost = Number(explain.Plan["Total Cost"]);
-        const costDeltaPercentage = (previousCost - explainCost) / previousCost * 100;
-        if (previousCost > explainCost) {
-          console.log(
-            `${(0, import_colorette2.green)(
-              `+${costDeltaPercentage.toFixed(2).padStart(5, "0")}%`
-            )} ${indexDefinition} `
-          );
-          iter = permutations.next(PROCEED);
-        } else {
-          console.log(
-            `${previousCost === explainCost ? ` ${(0, import_colorette2.gray)("00.00%")}` : `${(0, import_colorette2.red)(
-              `-${Math.abs(costDeltaPercentage).toFixed(2).padStart(5, "0")}%`
-            )}`} ${indexDefinition}`
-          );
-          iter = permutations.next(PROCEED);
-        }
-        nextStage.push({
-          name: indexName,
-          schema,
-          table,
-          columns: columns2
-        });
+    const toCreate = this.indexesToCreate(indexes);
+    const finalExplain = await this.testQueryWithStats(builder, async (tx) => {
+      if (beforeQuery) {
+        await beforeQuery(tx);
       }
-    }
-    const finalExplain = await this.testQueryWithStats(builder, async (sql) => {
-      for (const permutation of nextStage) {
-        const indexName = permutation.name;
-        await sql.exec(
-          `create index "${indexName}" on ${this.toDefinition(permutation).raw}; -- @qd_introspection`
-        );
+      for (const permutation of toCreate) {
+        const createIndex = PostgresQueryBuilder.createIndex(
+          this.toDefinition(permutation).raw,
+          permutation.name
+        ).introspect().build();
+        await tx.exec(createIndex);
       }
     });
     const finalCost = Number(finalExplain.Plan["Total Cost"]);
@@ -938,14 +1038,15 @@ var _IndexOptimizer = class _IndexOptimizer {
         )} ${(0, import_colorette2.gray)("If there's a better index, we haven't tried it")}`
       );
     }
-    const { newIndexes, existingIndexes: existingIndexesUsedByQuery } = this.findUsedIndexes(finalExplain.Plan);
+    const baseIndexes = this.findUsedIndexes(baseExplain.Plan);
+    const finalIndexes = this.findUsedIndexes(finalExplain.Plan);
     return {
       kind: "ok",
       baseCost,
       finalCost,
-      newIndexes,
-      existingIndexes: existingIndexesUsedByQuery,
-      triedIndexes,
+      newIndexes: finalIndexes.newIndexes,
+      existingIndexes: baseIndexes.existingIndexes,
+      triedIndexes: new Map(toCreate.map((index) => [index.name, index])),
       baseExplainPlan: baseExplain,
       explainPlan: finalExplain
     };
@@ -969,6 +1070,37 @@ var _IndexOptimizer = class _IndexOptimizer {
       (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)
     );
   }
+  /**
+   * Derive the list of indexes [tableA(X, Y, Z), tableB(H, I, J)]
+   **/
+  indexesToCreate(rootCandidates) {
+    const permutedIndexes = this.tableColumnIndexCandidates(rootCandidates);
+    const nextStage = [];
+    for (const { table, schema, columns } of permutedIndexes.values()) {
+      const permutations = permuteWithFeedback(columns);
+      let iter = permutations.next(PROCEED);
+      while (!iter.done) {
+        const columns2 = iter.value;
+        const existingIndex = this.indexAlreadyExists(table, columns2);
+        if (existingIndex) {
+          iter = permutations.next(PROCEED);
+          continue;
+        }
+        const indexName = this.indexName();
+        const shortenedSchema = schema === "public" ? "" : `"${schema}".`;
+        const indexDefinitionClean = `${shortenedSchema}"${table}"(${columns2.map((c) => `"${c.column}"`).join(", ")})`;
+        iter = permutations.next(PROCEED);
+        nextStage.push({
+          name: indexName,
+          schema,
+          table,
+          columns: columns2,
+          definition: indexDefinitionClean
+        });
+      }
+    }
+    return nextStage;
+  }
   toDefinition(permuted) {
     const make = (col, order, where, keyword) => {
       const baseColumn = `"${permuted.schema}"."${permuted.table}"(${permuted.columns.map((c) => {
@@ -991,16 +1123,15 @@ var _IndexOptimizer = class _IndexOptimizer {
     return { raw, colored };
   }
   /**
-   * Drop indexes that can be dropped (non-primary keys)
+   * Drop indexes that can be dropped. Ignore the ones that can't
    */
   async dropExistingIndexes(tx) {
     for (const index of this.existingIndexes) {
-      if (index.is_primary) {
+      if (!isIndexProbablyDroppable(index)) {
         continue;
       }
-      await tx.exec(
-        `drop index if exists ${index.schema_name}.${index.index_name} cascade`
-      );
+      const indexName = `${index.schema_name}.${index.index_name}`;
+      await dropIndex(tx, indexName);
     }
   }
   whereClause(c, col, keyword) {
@@ -1189,13 +1320,7 @@ var ExportedStatsStatistics = import_zod2.z.object({
 });
 var ExportedStatsColumns = import_zod2.z.object({
   columnName: import_zod2.z.string(),
-  stats: ExportedStatsStatistics.nullable(),
-  dataType: import_zod2.z.string(),
-  isNullable: import_zod2.z.boolean(),
-  numericScale: import_zod2.z.number().nullable(),
-  columnDefault: import_zod2.z.string().nullable(),
-  numericPrecision: import_zod2.z.number().nullable(),
-  characterMaximumLength: import_zod2.z.number().nullable()
+  stats: ExportedStatsStatistics.nullable()
 });
 var ExportedStatsIndex = import_zod2.z.object({
   indexName: import_zod2.z.string(),
@@ -1663,12 +1788,6 @@ var _Statistics = class _Statistics {
           json_agg(
             json_build_object(
               'columnName', c.column_name,
-              'dataType', c.data_type,
-              'isNullable', (c.is_nullable = 'YES')::boolean,
-              'characterMaximumLength', c.character_maximum_length,
-              'numericPrecision', c.numeric_precision,
-              'numericScale', c.numeric_scale,
-              'columnDefault', c.column_default,
               'stats', (
                 SELECT json_build_object(
                   'starelid', s.starelid,
@@ -1764,6 +1883,7 @@ var _Statistics = class _Statistics {
           COALESCE(pt.parent_table::text, t.relname) AS table_name,
           i.relname AS index_name,
           ix.indisprimary as is_primary,
+          ix.indisunique as is_unique,
           am.amname AS index_type,
           array_agg(
               CASE
@@ -1794,9 +1914,10 @@ var _Statistics = class _Statistics {
           LEFT JOIN pg_attribute a ON a.attnum = k.attnum AND a.attrelid = t.oid
           JOIN pg_namespace n ON t.relnamespace = n.oid
       WHERE
-          n.nspname = 'public'
+          n.nspname not like 'pg_%' and
+          n.nspname <> 'information_schema'
       GROUP BY
-          n.nspname, COALESCE(pt.parent_table::text, t.relname), i.relname, am.amname, ix.indisprimary
+          n.nspname, COALESCE(pt.parent_table::text, t.relname), i.relname, am.amname, ix.indisprimary, ix.indisunique
       ORDER BY
           COALESCE(pt.parent_table::text, t.relname), i.relname; -- @qd_introspection
       `);
@@ -1820,13 +1941,17 @@ var Statistics = _Statistics;
   ExportedStatsV1,
   IndexOptimizer,
   PROCEED,
+  PgIdentifier,
   PostgresQueryBuilder,
   PostgresVersion,
   SKIP,
   Statistics,
   StatisticsMode,
   StatisticsSource,
+  dropIndex,
   ignoredIdentifier,
+  isIndexProbablyDroppable,
+  isIndexSupported,
   parseNudges,
   permuteWithFeedback
 });