@query-doctor/core 0.4.0 → 0.4.1-rc.2

package/dist/index.js

@@ -1,2316 +0,0 @@
-'use client'
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/sql/analyzer.ts
-import {
-  bgMagentaBright,
-  blue,
-  dim,
-  strikethrough
-} from "colorette";
-
-// src/sql/walker.ts
-import { deparseSync } from "pgsql-deparser";
-
-// src/sql/nudges.ts
-function is(node, kind) {
-  return kind in node;
-}
-function isANode(node) {
-  if (typeof node !== "object" || node === null) {
-    return false;
-  }
-  const keys = Object.keys(node);
-  return keys.length === 1 && /^[A-Z]/.test(keys[0]);
-}
-function parseNudges(node, stack) {
-  const nudges = [];
-  if (is(node, "A_Star")) {
-    nudges.push({
-      kind: "AVOID_SELECT_STAR",
-      severity: "INFO",
-      message: "Avoid using SELECT *"
-    });
-  }
-  if (is(node, "FuncCall")) {
-    const inWhereClause = stack.some((item) => item === "whereClause");
-    if (inWhereClause && node.FuncCall.args) {
-      const hasColumnRef = containsColumnRef(node.FuncCall.args);
-      if (hasColumnRef) {
-        nudges.push({
-          kind: "AVOID_FUNCTIONS_ON_COLUMNS_IN_WHERE",
-          severity: "WARNING",
-          message: "Avoid using functions on columns in WHERE clause"
-        });
-      }
-    }
-  }
-  if (is(node, "SelectStmt")) {
-    const isSubquery = stack.some(
-      (item) => item === "RangeSubselect" || item === "SubLink" || item === "CommonTableExpr"
-    );
-    if (!isSubquery) {
-      const hasFromClause = node.SelectStmt.fromClause && node.SelectStmt.fromClause.length > 0;
-      if (hasFromClause) {
-        const hasActualTables = node.SelectStmt.fromClause.some((fromItem) => {
-          return is(fromItem, "RangeVar") || is(fromItem, "JoinExpr") && hasActualTablesInJoin(fromItem);
-        });
-        if (hasActualTables) {
-          if (!node.SelectStmt.whereClause) {
-            nudges.push({
-              kind: "MISSING_WHERE_CLAUSE",
-              severity: "INFO",
-              message: "Missing WHERE clause"
-            });
-          }
-          if (!node.SelectStmt.limitCount) {
-            nudges.push({
-              kind: "MISSING_LIMIT_CLAUSE",
-              severity: "INFO",
-              message: "Missing LIMIT clause"
-            });
-          }
-        }
-      }
-    }
-  }
-  if (is(node, "A_Expr")) {
-    const isEqualityOp = node.A_Expr.kind === "AEXPR_OP" && node.A_Expr.name && node.A_Expr.name.length > 0 && is(node.A_Expr.name[0], "String") && (node.A_Expr.name[0].String.sval === "=" || node.A_Expr.name[0].String.sval === "!=" || node.A_Expr.name[0].String.sval === "<>");
-    if (isEqualityOp) {
-      const leftIsNull = isNullConstant(node.A_Expr.lexpr);
-      const rightIsNull = isNullConstant(node.A_Expr.rexpr);
-      if (leftIsNull || rightIsNull) {
-        nudges.push({
-          kind: "USE_IS_NULL_NOT_EQUALS",
-          severity: "WARNING",
-          message: "Use IS NULL instead of = or != or <> for NULL comparisons"
-        });
-      }
-    }
-    const isLikeOp = node.A_Expr.kind === "AEXPR_LIKE" || node.A_Expr.kind === "AEXPR_ILIKE";
-    if (isLikeOp && node.A_Expr.rexpr) {
-      const patternString = getStringConstantValue(node.A_Expr.rexpr);
-      if (patternString && patternString.startsWith("%")) {
-        nudges.push({
-          kind: "AVOID_LEADING_WILDCARD_LIKE",
-          severity: "WARNING",
-          message: "Avoid using LIKE with leading wildcards"
-        });
-      }
-    }
-  }
-  if (is(node, "SelectStmt") && node.SelectStmt.distinctClause) {
-    nudges.push({
-      kind: "AVOID_DISTINCT_WITHOUT_REASON",
-      severity: "WARNING",
-      message: "Avoid using DISTINCT without a reason"
-    });
-  }
-  if (is(node, "JoinExpr")) {
-    if (!node.JoinExpr.quals) {
-      nudges.push({
-        kind: "MISSING_JOIN_CONDITION",
-        severity: "WARNING",
-        message: "Missing JOIN condition"
-      });
-    }
-  }
-  if (is(node, "SelectStmt") && node.SelectStmt.fromClause && node.SelectStmt.fromClause.length > 1) {
-    const tableCount = node.SelectStmt.fromClause.filter(
-      (item) => is(item, "RangeVar")
-    ).length;
-    if (tableCount > 1) {
-      nudges.push({
-        kind: "MISSING_JOIN_CONDITION",
-        severity: "WARNING",
-        message: "Missing JOIN condition"
-      });
-    }
-  }
-  if (is(node, "BoolExpr") && node.BoolExpr.boolop === "OR_EXPR") {
-    const orCount = countBoolOrConditions(node);
-    if (orCount >= 3) {
-      nudges.push({
-        kind: "CONSIDER_IN_INSTEAD_OF_MANY_ORS",
-        severity: "WARNING",
-        message: "Consider using IN instead of many ORs"
-      });
-    }
-  }
-  if (is(node, "A_Expr")) {
-    if (node.A_Expr.kind === "AEXPR_IN") {
-      let list;
-      if (node.A_Expr.lexpr && is(node.A_Expr.lexpr, "List")) {
-        list = node.A_Expr.lexpr.List;
-      } else if (node.A_Expr.rexpr && is(node.A_Expr.rexpr, "List")) {
-        list = node.A_Expr.rexpr.List;
-      }
-      if (list?.items && list.items.length >= 10) {
-        nudges.push({
-          kind: "REPLACE_LARGE_IN_TUPLE_WITH_ANY_ARRAY",
-          message: "`in (...)` queries with large tuples can often be replaced with `= ANY($1)` using a single parameter",
-          severity: "INFO"
-        });
-      }
-    }
-  }
-  return nudges;
-}
-function containsColumnRef(args) {
-  for (const arg of args) {
-    if (hasColumnRefInNode(arg)) {
-      return true;
-    }
-  }
-  return false;
-}
-function hasColumnRefInNode(node) {
-  if (isANode(node) && is(node, "ColumnRef")) {
-    return true;
-  }
-  if (typeof node !== "object" || node === null) {
-    return false;
-  }
-  if (Array.isArray(node)) {
-    return node.some((item) => hasColumnRefInNode(item));
-  }
-  if (isANode(node)) {
-    const keys = Object.keys(node);
-    return hasColumnRefInNode(node[keys[0]]);
-  }
-  for (const child of Object.values(node)) {
-    if (hasColumnRefInNode(child)) {
-      return true;
-    }
-  }
-  return false;
-}
-function hasActualTablesInJoin(joinExpr) {
-  if (joinExpr.JoinExpr.larg && is(joinExpr.JoinExpr.larg, "RangeVar")) {
-    return true;
-  }
-  if (joinExpr.JoinExpr.larg && is(joinExpr.JoinExpr.larg, "JoinExpr")) {
-    if (hasActualTablesInJoin(joinExpr.JoinExpr.larg)) {
-      return true;
-    }
-  }
-  if (joinExpr.JoinExpr.rarg && is(joinExpr.JoinExpr.rarg, "RangeVar")) {
-    return true;
-  }
-  if (joinExpr.JoinExpr.rarg && is(joinExpr.JoinExpr.rarg, "JoinExpr")) {
-    if (hasActualTablesInJoin(joinExpr.JoinExpr.rarg)) {
-      return true;
-    }
-  }
-  return false;
-}
-function isNullConstant(node) {
-  if (!node || typeof node !== "object") {
-    return false;
-  }
-  if (isANode(node) && is(node, "A_Const")) {
-    return node.A_Const.isnull !== void 0;
-  }
-  return false;
-}
-function getStringConstantValue(node) {
-  if (!node || typeof node !== "object") {
-    return null;
-  }
-  if (isANode(node) && is(node, "A_Const") && node.A_Const.sval) {
-    return node.A_Const.sval.sval || null;
-  }
-  return null;
-}
-function countBoolOrConditions(node) {
-  if (node.BoolExpr.boolop !== "OR_EXPR" || !node.BoolExpr.args) {
-    return 1;
-  }
-  let count = 0;
-  for (const arg of node.BoolExpr.args) {
-    if (isANode(arg) && is(arg, "BoolExpr") && arg.BoolExpr.boolop === "OR_EXPR") {
-      count += countBoolOrConditions(arg);
-    } else {
-      count += 1;
-    }
-  }
-  return count;
-}
-
-// src/sql/walker.ts
-var Walker = class _Walker {
-  constructor(query) {
-    this.query = query;
-    __publicField(this, "tableMappings", /* @__PURE__ */ new Map());
-    __publicField(this, "tempTables", /* @__PURE__ */ new Set());
-    __publicField(this, "highlights", []);
-    __publicField(this, "indexRepresentations", /* @__PURE__ */ new Set());
-    __publicField(this, "indexesToCheck", []);
-    __publicField(this, "highlightPositions", /* @__PURE__ */ new Set());
-    // used for tallying the amount of times we see stuff so
-    // we have a better idea of what to start off the algorithm with
-    __publicField(this, "seenReferences", /* @__PURE__ */ new Map());
-    __publicField(this, "shadowedAliases", []);
-    __publicField(this, "nudges", []);
-  }
-  walk(root) {
-    this.tableMappings = /* @__PURE__ */ new Map();
-    this.tempTables = /* @__PURE__ */ new Set();
-    this.highlights = [];
-    this.indexRepresentations = /* @__PURE__ */ new Set();
-    this.indexesToCheck = [];
-    this.highlightPositions = /* @__PURE__ */ new Set();
-    this.seenReferences = /* @__PURE__ */ new Map();
-    this.shadowedAliases = [];
-    this.nudges = [];
-    _Walker.traverse(root, [], (node, stack) => {
-      const nodeNudges = parseNudges(node, stack);
-      this.nudges = [...this.nudges, ...nodeNudges];
-      if (is2(node, "CommonTableExpr")) {
-        if (node.CommonTableExpr.ctename) {
-          this.tempTables.add(node.CommonTableExpr.ctename);
-        }
-      }
-      if (is2(node, "RangeSubselect")) {
-        if (node.RangeSubselect.alias?.aliasname) {
-          this.tempTables.add(node.RangeSubselect.alias.aliasname);
-        }
-      }
-      if (is2(node, "NullTest")) {
-        if (node.NullTest.arg && node.NullTest.nulltesttype && is2(node.NullTest.arg, "ColumnRef")) {
-          this.add(node.NullTest.arg, {
-            where: { nulltest: node.NullTest.nulltesttype }
-          });
-        }
-      }
-      if (is2(node, "RangeVar") && node.RangeVar.relname) {
-        const columnReference = {
-          text: node.RangeVar.relname,
-          start: node.RangeVar.location,
-          quoted: false
-        };
-        if (node.RangeVar.schemaname) {
-          columnReference.schema = node.RangeVar.schemaname;
-        }
-        this.tableMappings.set(node.RangeVar.relname, columnReference);
-        if (node.RangeVar.alias?.aliasname) {
-          const aliasName = node.RangeVar.alias.aliasname;
-          const existingMapping = this.tableMappings.get(aliasName);
-          const part = {
-            text: node.RangeVar.relname,
-            start: node.RangeVar.location,
-            // what goes here? the text here doesn't _really_ exist.
-            // so it can't be quoted or not quoted.
-            // Does it even matter?
-            quoted: true,
-            alias: aliasName
-          };
-          if (node.RangeVar.schemaname) {
-            part.schema = node.RangeVar.schemaname;
-          }
-          if (existingMapping) {
-            const isSystemCatalog = node.RangeVar.relname?.startsWith("pg_") ?? false;
-            if (!isSystemCatalog) {
-              console.warn(
-                `Ignoring alias ${aliasName} as it shadows an existing mapping for ${existingMapping.text}. We currently do not support alias shadowing.`
-              );
-            }
-            this.shadowedAliases.push(part);
-            return;
-          }
-          this.tableMappings.set(aliasName, part);
-        }
-      }
-      if (is2(node, "SortBy")) {
-        if (node.SortBy.node && is2(node.SortBy.node, "ColumnRef")) {
-          this.add(node.SortBy.node, {
-            sort: {
-              dir: node.SortBy.sortby_dir ?? "SORTBY_DEFAULT",
-              nulls: node.SortBy.sortby_nulls ?? "SORTBY_NULLS_DEFAULT"
-            }
-          });
-        }
-      }
-      if (is2(node, "JoinExpr") && node.JoinExpr.quals) {
-        if (is2(node.JoinExpr.quals, "A_Expr")) {
-          if (node.JoinExpr.quals.A_Expr.lexpr && is2(node.JoinExpr.quals.A_Expr.lexpr, "ColumnRef")) {
-            this.add(node.JoinExpr.quals.A_Expr.lexpr);
-          }
-          if (node.JoinExpr.quals.A_Expr.rexpr && is2(node.JoinExpr.quals.A_Expr.rexpr, "ColumnRef")) {
-            this.add(node.JoinExpr.quals.A_Expr.rexpr);
-          }
-        }
-      }
-      if (is2(node, "A_Expr") && node.A_Expr.kind === "AEXPR_OP") {
-        const opName = node.A_Expr.name?.[0] && is2(node.A_Expr.name[0], "String") && node.A_Expr.name[0].String.sval;
-        if (opName && (opName === "@>" || opName === "?" || opName === "?|" || opName === "?&")) {
-          const jsonbOperator = opName;
-          if (node.A_Expr.lexpr && is2(node.A_Expr.lexpr, "ColumnRef")) {
-            this.add(node.A_Expr.lexpr, { jsonbOperator });
-          }
-          if (node.A_Expr.rexpr && is2(node.A_Expr.rexpr, "ColumnRef")) {
-            this.add(node.A_Expr.rexpr, { jsonbOperator });
-          }
-        }
-      }
-      if (is2(node, "ColumnRef")) {
-        for (let i = 0; i < stack.length; i++) {
-          const inReturningList = stack[i] === "returningList" && stack[i + 1] === "ResTarget" && stack[i + 2] === "val" && stack[i + 3] === "ColumnRef";
-          if (inReturningList) {
-            this.add(node, { ignored: true });
-            return;
-          }
-          if (
-            // stack[i] === "SelectStmt" &&
-            stack[i + 1] === "targetList" && stack[i + 2] === "ResTarget" && stack[i + 3] === "val" && stack[i + 4] === "ColumnRef"
-          ) {
-            this.add(node, { ignored: true });
-            return;
-          }
-          if (stack[i] === "FuncCall" && stack[i + 1] === "args") {
-            this.add(node, { ignored: true });
-            return;
-          }
-        }
-        this.add(node);
-      }
-    });
-    return {
-      highlights: this.highlights,
-      indexRepresentations: this.indexRepresentations,
-      indexesToCheck: this.indexesToCheck,
-      shadowedAliases: this.shadowedAliases,
-      tempTables: this.tempTables,
-      tableMappings: this.tableMappings,
-      nudges: this.nudges
-    };
-  }
-  add(node, options) {
-    if (!node.ColumnRef.location) {
-      console.error(`Node did not have a location. Skipping`, node);
-      return;
-    }
-    if (!node.ColumnRef.fields) {
-      console.error(node);
-      throw new Error("Column reference must have fields");
-    }
-    let ignored = options?.ignored ?? false;
-    let runningLength = node.ColumnRef.location;
-    const parts = node.ColumnRef.fields.map(
-      (field, i, length) => {
-        if (!is2(field, "String") || !field.String.sval) {
-          const out = deparseSync(field);
-          ignored = true;
-          return {
-            quoted: out.startsWith('"'),
-            text: out,
-            start: runningLength
-          };
-        }
-        const start = runningLength;
-        const size = field.String.sval?.length ?? 0;
-        let quoted = false;
-        if (node.ColumnRef.location !== void 0) {
-          const boundary = this.query[runningLength];
-          if (boundary === '"') {
-            quoted = true;
-          }
-        }
-        const isLastIteration = i === length.length - 1;
-        runningLength += size + (isLastIteration ? 0 : 1) + (quoted ? 2 : 0);
-        return {
-          text: field.String.sval,
-          start,
-          quoted
-        };
-      }
-    );
-    const end = runningLength;
-    if (this.highlightPositions.has(node.ColumnRef.location)) {
-      return;
-    }
-    this.highlightPositions.add(node.ColumnRef.location);
-    const highlighted = `${this.query.slice(node.ColumnRef.location, end)}`;
-    const seen = this.seenReferences.get(highlighted);
-    if (!ignored) {
-      this.seenReferences.set(highlighted, (seen ?? 0) + 1);
-    }
-    const ref = {
-      frequency: seen ?? 1,
-      representation: highlighted,
-      parts,
-      ignored: ignored ?? false,
-      position: {
-        start: node.ColumnRef.location,
-        end
-      }
-    };
-    if (options?.sort) {
-      ref.sort = options.sort;
-    }
-    if (options?.where) {
-      ref.where = options.where;
-    }
-    if (options?.jsonbOperator) {
-      ref.jsonbOperator = options.jsonbOperator;
-    }
-    this.highlights.push(ref);
-  }
-  static traverse(node, stack, callback) {
-    if (isANode2(node)) {
-      callback(node, [...stack, getNodeKind(node)]);
-    }
-    if (typeof node !== "object" || node === null) {
-      return;
-    }
-    if (Array.isArray(node)) {
-      for (const item of node) {
-        if (isANode2(item)) {
-          _Walker.traverse(item, stack, callback);
-        }
-      }
-    } else if (isANode2(node)) {
-      const keys = Object.keys(node);
-      _Walker.traverse(node[keys[0]], [...stack, getNodeKind(node)], callback);
-    } else {
-      for (const [key, child] of Object.entries(node)) {
-        _Walker.traverse(child, [...stack, key], callback);
-      }
-    }
-  }
-};
-function is2(node, kind) {
-  return kind in node;
-}
-function getNodeKind(node) {
-  const keys = Object.keys(node);
-  return keys[0];
-}
-function isANode2(node) {
-  if (typeof node !== "object" || node === null) {
-    return false;
-  }
-  const keys = Object.keys(node);
-  return keys.length === 1 && /^[A-Z]/.test(keys[0]);
-}
-
-// src/sql/analyzer.ts
-var ignoredIdentifier = "__qd_placeholder";
-var Analyzer = class {
-  constructor(parser) {
-    this.parser = parser;
-  }
-  async analyze(query, formattedQuery) {
-    const ast = await this.parser(query);
-    if (!ast.stmts) {
-      throw new Error(
-        "Query did not have any statements. This should probably never happen?"
-      );
-    }
-    const stmt = ast.stmts[0].stmt;
-    if (!stmt) {
-      throw new Error(
-        "Query did not have any statements. This should probably never happen?"
-      );
-    }
-    const walker = new Walker(query);
-    const {
-      highlights,
-      indexRepresentations,
-      indexesToCheck,
-      shadowedAliases,
-      tempTables,
-      tableMappings,
-      nudges
-    } = walker.walk(stmt);
-    const sortedHighlights = highlights.sort(
-      (a, b) => b.position.end - a.position.end
-    );
-    let currQuery = query;
-    for (const highlight of sortedHighlights) {
-      const parts = this.resolveTableAliases(highlight.parts, tableMappings);
-      if (parts.length === 0) {
-        console.error(highlight);
-        throw new Error("Highlight must have at least one part");
-      }
-      let color;
-      let skip = false;
-      if (highlight.ignored) {
-        color = (x) => dim(strikethrough(x));
-        skip = true;
-      } else if (parts.length === 2 && tempTables.has(parts[0].text) && // sometimes temp tables are aliased as existing tables
-      // we don't want to ignore them if they are
-      !tableMappings.has(parts[0].text)) {
-        color = blue;
-        skip = true;
-      } else {
-        color = bgMagentaBright;
-      }
-      const queryRepr = highlight.representation;
-      const queryBeforeMatch = currQuery.slice(0, highlight.position.start);
-      const queryAfterToken = currQuery.slice(highlight.position.end);
-      currQuery = `${queryBeforeMatch}${color(queryRepr)}${this.colorizeKeywords(
-        queryAfterToken,
-        color
-      )}`;
-      if (indexRepresentations.has(queryRepr)) {
-        skip = true;
-      }
-      if (!skip) {
-        indexesToCheck.push(highlight);
-        indexRepresentations.add(queryRepr);
-      }
-    }
-    const referencedTables = [];
-    for (const value of tableMappings.values()) {
-      if (!value.alias) {
-        referencedTables.push({
-          schema: value.schema,
-          table: value.text
-        });
-      }
-    }
-    const { tags, queryWithoutTags } = this.extractSqlcommenter(query);
-    const formattedQueryWithoutTags = formattedQuery ? this.extractSqlcommenter(formattedQuery).queryWithoutTags : void 0;
-    return {
-      indexesToCheck,
-      ansiHighlightedQuery: currQuery,
-      referencedTables,
-      shadowedAliases,
-      tags,
-      queryWithoutTags,
-      formattedQueryWithoutTags,
-      nudges
-    };
-  }
-  deriveIndexes(tables, discovered, referencedTables) {
-    const allIndexes = [];
-    const seenIndexes = /* @__PURE__ */ new Set();
-    function addIndex(index) {
-      const key = `"${index.schema}":"${index.table}":"${index.column}"`;
-      if (seenIndexes.has(key)) {
-        return;
-      }
-      seenIndexes.add(key);
-      allIndexes.push(index);
-    }
-    const matchingTables = this.filterReferences(referencedTables, tables);
-    for (const colReference of discovered) {
-      const partsCount = colReference.parts.length;
-      const columnOnlyReference = partsCount === 1;
-      const tableReference = partsCount === 2;
-      const fullReference = partsCount === 3;
-      if (columnOnlyReference) {
-        const [column] = colReference.parts;
-        const referencedColumn = this.normalize(column);
-        for (const table of matchingTables) {
-          if (!this.hasColumn(table, referencedColumn)) {
-            continue;
-          }
-          const index = {
-            schema: table.schemaName,
-            table: table.tableName,
-            column: referencedColumn
-          };
-          if (colReference.sort) {
-            index.sort = colReference.sort;
-          }
-          if (colReference.where) {
-            index.where = colReference.where;
-          }
-          if (colReference.jsonbOperator) {
-            index.jsonbOperator = colReference.jsonbOperator;
-          }
-          addIndex(index);
-        }
-      } else if (tableReference) {
-        const [table, column] = colReference.parts;
-        const referencedTable = this.normalize(table);
-        const referencedColumn = this.normalize(column);
-        for (const matchingTable of matchingTables) {
-          if (!this.hasColumn(matchingTable, referencedColumn)) {
-            continue;
-          }
-          const index = {
-            schema: matchingTable.schemaName,
-            table: referencedTable,
-            column: referencedColumn
-          };
-          if (colReference.sort) {
-            index.sort = colReference.sort;
-          }
-          if (colReference.where) {
-            index.where = colReference.where;
-          }
-          if (colReference.jsonbOperator) {
-            index.jsonbOperator = colReference.jsonbOperator;
-          }
-          addIndex(index);
-        }
-      } else if (fullReference) {
-        const [schema, table, column] = colReference.parts;
-        const referencedSchema = this.normalize(schema);
-        const referencedTable = this.normalize(table);
-        const referencedColumn = this.normalize(column);
-        const index = {
-          schema: referencedSchema,
-          table: referencedTable,
-          column: referencedColumn
-        };
-        if (colReference.sort) {
-          index.sort = colReference.sort;
-        }
-        if (colReference.where) {
-          index.where = colReference.where;
-        }
-        if (colReference.jsonbOperator) {
-          index.jsonbOperator = colReference.jsonbOperator;
-        }
-        addIndex(index);
-      } else {
-        console.error(
-          "Column reference has too many parts. The query is malformed",
-          colReference
-        );
-        continue;
-      }
-    }
-    return allIndexes;
-  }
-  filterReferences(referencedTables, tables) {
-    const matchingTables = [];
-    for (const referencedTable of referencedTables) {
-      const refs = tables.filter(({ tableName, schemaName }) => {
-        let schemaMatches = true;
-        if (referencedTable.schema) {
-          schemaMatches = schemaName === referencedTable.schema;
-        }
-        return schemaMatches && tableName === referencedTable.table;
-      });
-      matchingTables.push(...refs);
-    }
-    return matchingTables;
-  }
-  hasColumn(table, columnName) {
-    return table.columns?.some((column) => column.columnName === columnName) ?? false;
-  }
-  colorizeKeywords(query, color) {
-    return query.replace(
-      // eh? This kinda sucks
-      /(^\s+)(asc|desc)?(\s+(nulls first|nulls last))?/i,
-      (_, pre, dir, spaceNulls, nulls) => {
-        return `${pre}${dir ? color(dir) : ""}${nulls ? spaceNulls.replace(nulls, color(nulls)) : ""}`;
-      }
-    ).replace(/(^\s+)(is (null|not null))/i, (_, pre, nulltest) => {
-      return `${pre}${color(nulltest)}`;
-    });
-  }
-  /**
-   * Resolves aliases such as `a.b` to `x.b` if `a` is a known
-   * alias to a table called x.
-   *
-   * Ignores all other combination of parts such as `a.b.c`
-   */
-  resolveTableAliases(parts, tableMappings) {
-    if (parts.length !== 2) {
-      return parts;
-    }
-    const tablePart = parts[0];
-    const mapping = tableMappings.get(tablePart.text);
-    if (mapping) {
-      parts[0] = mapping;
-    }
-    return parts;
-  }
-  normalize(columnReference) {
-    return columnReference.quoted ? columnReference.text : (
-      // postgres automatically lowercases column names if not quoted
-      columnReference.text.toLowerCase()
-    );
-  }
-  extractSqlcommenter(query) {
-    const trimmedQuery = query.trimEnd();
-    const startPosition = trimmedQuery.lastIndexOf("/*");
-    const endPosition = trimmedQuery.lastIndexOf("*/");
-    if (startPosition === -1 || endPosition === -1) {
-      return { tags: [], queryWithoutTags: trimmedQuery };
-    }
-    const queryWithoutTags = trimmedQuery.slice(0, startPosition);
-    const tagString = trimmedQuery.slice(startPosition + 2, endPosition).trim();
-    if (!tagString || typeof tagString !== "string") {
-      return { tags: [], queryWithoutTags };
-    }
-    const tags = [];
-    for (const match of tagString.split(",")) {
-      const [key, value] = match.split("=");
-      if (!key || !value) {
-        if (tags.length > 0) {
-          console.warn(
-            `Invalid sqlcommenter tag: ${match} in comment: ${tagString}. Ignoring`
-          );
-        }
-        continue;
-      }
-      try {
-        let sliceStart = 0;
-        if (value.startsWith("'")) {
-          sliceStart = 1;
-        }
-        let sliceEnd = value.length;
-        if (value.endsWith("'")) {
-          sliceEnd -= 1;
-        }
-        const decoded = decodeURIComponent(value.slice(sliceStart, sliceEnd));
-        tags.push({ key: key.trim(), value: decoded });
-      } catch (err) {
-        console.error(err);
-      }
-    }
-    return { tags, queryWithoutTags };
-  }
-};
-
-// src/sql/database.ts
-import { z } from "zod";
-var PostgresVersion = 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/sql/indexes.ts
-function isIndexSupported(index) {
-  return index.index_type === "btree" || index.index_type === "gin";
-}
-function isIndexProbablyDroppable(index) {
-  return !index.is_primary && !index.is_unique;
-}
-
-// src/sql/builder.ts
-var PostgresQueryBuilder = class _PostgresQueryBuilder {
-  constructor(query) {
-    this.query = query;
-    __publicField(this, "commands", {});
-    __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;
-  }
-  static createIndex(definition, name) {
-    if (name) {
-      return new _PostgresQueryBuilder(
-        `create index "${name}" on ${definition};`
-      );
-    }
-    return new _PostgresQueryBuilder(`create index on ${definition};`);
-  }
-  enable(command, value = true) {
-    const commandString = `enable_${command}`;
-    if (value) {
-      this.commands[commandString] = "on";
-    } else {
-      this.commands[commandString] = "off";
-    }
-    return this;
-  }
-  withQuery(query) {
-    this.query = query;
-    return this;
-  }
-  introspect() {
-    this.isIntrospection = true;
-    return this;
-  }
-  explain(flags) {
-    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;
-    if (this.isIntrospection) {
-      commands += " -- @qd_introspection";
-    }
-    return commands;
-  }
-  /** Return the "set a=b" parts of the command in the query separate from the explain select ... part */
-  buildParts() {
-    const commands = this.generateSetCommands();
-    const explain = this.generateExplain();
-    this._preamble = explain.preamble;
-    if (this.isIntrospection) {
-      explain.query += " -- @qd_introspection";
-    }
-    return { commands, query: explain.query };
-  }
-  generateSetCommands() {
-    let commands = "";
-    for (const key in this.commands) {
-      const value = this.commands[key];
-      commands += `set local ${key}=${value};
-`;
-    }
-    return commands;
-  }
-  generateExplain() {
-    let finalQuery = "";
-    if (this.explainFlags.length > 0) {
-      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}`
-      );
-    }
-    for (const [key, value] of Object.entries(this.parameters)) {
-      query = query.replaceAll(`\\$${key}`, value.toString());
-    }
-    return query;
-  }
-};
-
-// src/sql/pg-identifier.ts
-var _PgIdentifier = class _PgIdentifier {
-  constructor(value, quoted) {
-    this.value = value;
-    this.quoted = quoted;
-  }
-  /**
-   * Constructs an identifier from a single part (column or table name).
-   * When quoting identifiers like `select table.col` use {@link fromParts} instead
-   */
-  static fromString(identifier) {
-    const identifierRegex = /^[a-z_][a-zA-Z0-9_]*$/;
-    const match = identifier.match(/^"(.+)"$/);
-    if (match) {
-      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);
-  }
-  /**
-   * Quotes parts of an identifier like `select schema.table.col`.
-   * A separate function is necessary because postgres will treat
-   * `select "HELLO.WORLD"` as a column name. It has to be like
-   * `select "HELLO"."WORLD"` instead.
-   */
-  static fromParts(...identifiers) {
-    return new _PgIdentifier(
-      identifiers.map((identifier) => {
-        if (typeof identifier === "string") {
-          return _PgIdentifier.fromString(identifier);
-        } else {
-          return identifier;
-        }
-      }).join("."),
-      false
-    );
-  }
-  toString() {
-    if (this.quoted) {
-      return `"${this.value.replace(/"/g, '""')}"`;
-    }
-    return this.value;
-  }
-  toJSON() {
-    return this.toString();
-  }
-};
-// Every keyword that's not explicitly marked as
-// unreserved in src/include/parser/kwlist.h
-__publicField(_PgIdentifier, "reservedKeywords", /* @__PURE__ */ new Set([
-  "all",
-  "analyse",
-  "analyze",
-  "and",
-  "any",
-  "array",
-  "as",
-  "asc",
-  "asymmetric",
-  "authorization",
-  "between",
-  "bigint",
-  "binary",
-  "bit",
-  "boolean",
-  "both",
-  "case",
-  "cast",
-  "char",
-  "character",
-  "check",
-  "coalesce",
-  "collate",
-  "collation",
-  "column",
-  "concurrently",
-  "constraint",
-  "create",
-  "cross",
-  "current_catalog",
-  "current_date",
-  "current_role",
-  "current_schema",
-  "current_time",
-  "current_timestamp",
-  "current_user",
-  "dec",
-  "decimal",
-  "default",
-  "deferrable",
-  "desc",
-  "distinct",
-  "do",
-  "else",
-  "end",
-  "except",
-  "exists",
-  "extract",
-  "false",
-  "fetch",
-  "float",
-  "for",
-  "foreign",
-  "freeze",
-  "from",
-  "full",
-  "grant",
-  "greatest",
-  "group",
-  "grouping",
-  "having",
-  "ilike",
-  "in",
-  "initially",
-  "inner",
-  "inout",
-  "int",
-  "integer",
-  "intersect",
-  "interval",
-  "into",
-  "is",
-  "isnull",
-  "join",
-  "json",
-  "json_array",
-  "json_arrayagg",
-  "json_exists",
-  "json_object",
-  "json_objectagg",
-  "json_query",
-  "json_scalar",
-  "json_serialize",
-  "json_table",
-  "json_value",
-  "lateral",
-  "leading",
-  "least",
-  "left",
-  "like",
-  "limit",
-  "localtime",
-  "localtimestamp",
-  "merge_action",
-  "national",
-  "natural",
-  "nchar",
-  "none",
-  "normalize",
-  "not",
-  "notnull",
-  "null",
-  "nullif",
-  "numeric",
-  "offset",
-  "on",
-  "only",
-  "or",
-  "order",
-  "out",
-  "outer",
-  "overlaps",
-  "overlay",
-  "placing",
-  "position",
-  "precision",
-  "primary",
-  "real",
-  "references",
-  "returning",
-  "right",
-  "row",
-  "select",
-  "session_user",
-  "setof",
-  "similar",
-  "smallint",
-  "some",
-  "substring",
-  "symmetric",
-  "system_user",
-  "table",
-  "tablesample",
-  "then",
-  "time",
-  "timestamp",
-  "to",
-  "trailing",
-  "treat",
-  "trim",
-  "true",
-  "union",
-  "unique",
-  "user",
-  "using",
-  "values",
-  "varchar",
-  "variadic",
-  "verbose",
-  "when",
-  "where",
-  "window",
-  "with",
-  "xmlattributes",
-  "xmlconcat",
-  "xmlelement",
-  "xmlexists",
-  "xmlforest",
-  "xmlnamespaces",
-  "xmlparse",
-  "xmlpi",
-  "xmlroot",
-  "xmlserialize",
-  "xmltable"
-]));
-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;
-    this.statistics = statistics;
-    this.existingIndexes = existingIndexes;
-    this.config = config;
-  }
-  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 {
-        kind: "zero_cost_plan",
-        explainPlan: baseExplain.Plan
-      };
-    }
-    const toCreate = this.indexesToCreate(indexes);
-    const finalExplain = await this.testQueryWithStats(builder, async (tx) => {
-      if (beforeQuery) {
-        await beforeQuery(tx);
-      }
-      for (const permutation of toCreate) {
-        const createIndex = PostgresQueryBuilder.createIndex(
-          permutation.definition,
-          permutation.name
-        ).introspect().build();
-        await tx.exec(createIndex);
-      }
-    });
-    const finalCost = Number(finalExplain.Plan["Total Cost"]);
-    if (this.config.debug) {
-      console.dir(finalExplain, { depth: null });
-    }
-    const deltaPercentage = (baseCost - finalCost) / baseCost * 100;
-    if (finalCost < baseCost) {
-      console.log(
-        ` \u{1F389}\u{1F389}\u{1F389} ${green(`+${deltaPercentage.toFixed(2).padStart(5, "0")}%`)}`
-      );
-    } else if (finalCost > baseCost) {
-      console.log(
-        `${red(
-          `-${Math.abs(deltaPercentage).toFixed(2).padStart(5, "0")}%`
-        )} ${gray("If there's a better index, we haven't tried it")}`
-      );
-    }
-    const baseIndexes = this.findUsedIndexes(baseExplain.Plan);
-    const finalIndexes = this.findUsedIndexes(finalExplain.Plan);
-    const triedIndexes = new Map(
-      toCreate.map((index) => [index.name.toString(), index])
-    );
-    this.replaceUsedIndexesWithDefinition(finalExplain.Plan, triedIndexes);
-    return {
-      kind: "ok",
-      baseCost,
-      finalCost,
-      newIndexes: finalIndexes.newIndexes,
-      existingIndexes: baseIndexes.existingIndexes,
-      triedIndexes,
-      baseExplainPlan: baseExplain.Plan,
-      explainPlan: finalExplain.Plan
-    };
-  }
-  async runWithoutIndexes(builder) {
-    return await this.testQueryWithStats(builder, async (tx) => {
-      await this.dropExistingIndexes(tx);
-    });
-  }
-  /**
-   * Given the current indexes in the optimizer, transform them in some
-   * way to change which indexes will be assumed to exist when optimizing
-   *
-   * @example
-   * ```
-   * // resets indexes
-   * optimizer.transformIndexes(() => [])
-   *
-   * // adds new index
-   * optimizer.transformIndexes(indexes => [...indexes, newIndex])
-   * ```
-   */
-  transformIndexes(f) {
-    const newIndexes = f(this.existingIndexes);
-    this.existingIndexes = newIndexes;
-    return this;
-  }
-  /**
-   * Postgres has a limit of 63 characters for index names.
-   * So we use this to make sure we don't derive it from a list of columns that can
-   * overflow that limit.
-   */
-  indexName() {
-    const indexName = _IndexOptimizer.prefix + Math.random().toString(36).substring(2, 16);
-    return PgIdentifier.fromString(indexName);
-  }
-  // 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) => {
-        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 btreeCandidates = rootCandidates.filter((c) => !c.jsonbOperator);
-    const ginCandidates = rootCandidates.filter((c) => c.jsonbOperator);
-    const nextStage = [];
-    const permutedIndexes = this.groupPotentialIndexColumnsByTable(btreeCandidates);
-    for (const permutation of permutedIndexes.values()) {
-      const { table: rawTable, schema: rawSchema, columns } = permutation;
-      const permutations = permutationsWithDescendingLength(columns);
-      for (const columns2 of permutations) {
-        const schema = PgIdentifier.fromString(rawSchema);
-        const table = PgIdentifier.fromString(rawTable);
-        const existingIndex = this.indexAlreadyExists(
-          table.toString(),
-          columns2
-        );
-        if (existingIndex) {
-          continue;
-        }
-        const indexName = this.indexName();
-        const definition = this.toDefinition({ table, schema, columns: columns2 }).raw;
-        nextStage.push({
-          name: indexName,
-          schema: schema.toString(),
-          table: table.toString(),
-          columns: columns2,
-          definition
-        });
-      }
-    }
-    const ginGroups = this.groupGinCandidatesByColumn(ginCandidates);
-    for (const group of ginGroups.values()) {
-      const { schema: rawSchema, table: rawTable, column, operators } = group;
-      const schema = PgIdentifier.fromString(rawSchema);
-      const table = PgIdentifier.fromString(rawTable);
-      const needsKeyExistence = operators.some(
-        (op) => op === "?" || op === "?|" || op === "?&"
-      );
-      const opclass = needsKeyExistence ? void 0 : "jsonb_path_ops";
-      const existingGin = this.ginIndexAlreadyExists(table.toString(), column);
-      if (existingGin) {
-        continue;
-      }
-      const indexName = this.indexName();
-      const candidate = {
-        schema: rawSchema,
-        table: rawTable,
-        column
-      };
-      const definition = this.toGinDefinition({
-        table,
-        schema,
-        column: PgIdentifier.fromString(column),
-        opclass
-      });
-      nextStage.push({
-        name: indexName,
-        schema: schema.toString(),
-        table: table.toString(),
-        columns: [candidate],
-        definition,
-        indexMethod: "gin",
-        opclass
-      });
-    }
-    return nextStage;
-  }
-  toDefinition({
-    schema,
-    table,
-    columns
-  }) {
-    const make = (col, order, where, keyword) => {
-      let fullyQualifiedTable;
-      if (schema.toString() === "public") {
-        fullyQualifiedTable = table;
-      } else {
-        fullyQualifiedTable = PgIdentifier.fromParts(schema, table);
-      }
-      const baseColumn = `${fullyQualifiedTable}(${columns.map((c) => {
-        const column = PgIdentifier.fromString(c.column);
-        const direction = c.sort && this.sortDirection(c.sort);
-        const nulls = c.sort && this.nullsOrder(c.sort);
-        let sort = col(column.toString());
-        if (direction) {
-          sort += ` ${order(direction)}`;
-        }
-        if (nulls) {
-          sort += ` ${order(nulls)}`;
-        }
-        return sort;
-      }).join(", ")})`;
-      return baseColumn;
-    };
-    const id = (a) => a;
-    const raw = make(id, id, id, id);
-    const colored = make(green, yellow, magenta, blue2);
-    return { raw, colored };
-  }
-  toGinDefinition({
-    schema,
-    table,
-    column,
-    opclass
-  }) {
-    let fullyQualifiedTable;
-    if (schema.toString() === "public") {
-      fullyQualifiedTable = table;
-    } else {
-      fullyQualifiedTable = PgIdentifier.fromParts(schema, table);
-    }
-    const opclassSuffix = opclass ? ` ${opclass}` : "";
-    return `${fullyQualifiedTable} using gin (${column}${opclassSuffix})`;
-  }
-  groupGinCandidatesByColumn(candidates) {
-    const groups = /* @__PURE__ */ new Map();
-    for (const c of candidates) {
-      if (!c.jsonbOperator) continue;
-      const key = `${c.schema}.${c.table}.${c.column}`;
-      const existing = groups.get(key);
-      if (existing) {
-        if (!existing.operators.includes(c.jsonbOperator)) {
-          existing.operators.push(c.jsonbOperator);
-        }
-      } else {
-        groups.set(key, {
-          schema: c.schema,
-          table: c.table,
-          column: c.column,
-          operators: [c.jsonbOperator]
-        });
-      }
-    }
-    return groups;
-  }
-  ginIndexAlreadyExists(table, column) {
-    return this.existingIndexes.find(
-      (index) => index.index_type === "gin" && index.table_name === table && index.index_columns.some((c) => c.name === column)
-    );
-  }
-  /**
-   * Drop indexes that can be dropped. Ignore the ones that can't
-   */
-  async dropExistingIndexes(tx) {
-    for (const index of this.existingIndexes) {
-      if (!isIndexProbablyDroppable(index)) {
-        continue;
-      }
-      const indexName = PgIdentifier.fromParts(
-        index.schema_name,
-        index.index_name
-      );
-      await dropIndex(tx, indexName);
-    }
-  }
-  whereClause(c, col, keyword) {
-    if (!c.where) {
-      return "";
-    }
-    if (c.where.nulltest === "IS_NULL") {
-      return `${col(`"${c.column}"`)} is ${keyword("null")}`;
-    }
-    if (c.where.nulltest === "IS_NOT_NULL") {
-      return `${col(`"${c.column}"`)} is not ${keyword("null")}`;
-    }
-    return "";
-  }
-  nullsOrder(s) {
-    if (!s.nulls) {
-      return "";
-    }
-    switch (s.nulls) {
-      case "SORTBY_NULLS_FIRST":
-        return "nulls first";
-      case "SORTBY_NULLS_LAST":
-        return "nulls last";
-      case "SORTBY_NULLS_DEFAULT":
-      default:
-        return "";
-    }
-  }
-  sortDirection(s) {
-    if (!s.dir) {
-      return "";
-    }
-    switch (s.dir) {
-      case "SORTBY_DESC":
-        return "desc";
-      case "SORTBY_ASC":
-        return "asc";
-      case "SORTBY_DEFAULT":
-      // god help us if we ever run into this
-      case "SORTBY_USING":
-      default:
-        return "";
-    }
-  }
-  async testQueryWithStats(builder, f, options) {
-    try {
-      await this.db.transaction(async (tx) => {
-        await f?.(tx);
-        await this.statistics.restoreStats(tx);
-        const flags = ["format json"];
-        if (options && !options.genericPlan) {
-          flags.push("analyze");
-          if (this.config.trace) {
-            flags.push("trace");
-          }
-        } else {
-          flags.push("generic_plan");
-        }
-        const { commands, query } = builder.explain(flags).buildParts();
-        await tx.exec(commands);
-        const result = await tx.exec(
-          query,
-          options?.params
-        );
-        const explain = result[0]["QUERY PLAN"][0];
-        throw new RollbackError(explain);
-      });
-    } catch (error) {
-      if (error instanceof RollbackError) {
-        return error.value;
-      }
-      throw error;
-    }
-    throw new Error("Unreachable");
-  }
-  groupPotentialIndexColumnsByTable(indexes) {
-    const tableColumns = /* @__PURE__ */ new Map();
-    for (const index of indexes) {
-      const existing = tableColumns.get(`${index.schema}.${index.table}`);
-      if (existing) {
-        existing.columns.push(index);
-      } else {
-        tableColumns.set(`${index.schema}.${index.table}`, {
-          table: index.table,
-          schema: index.schema,
-          columns: [index]
-        });
-      }
-    }
-    return tableColumns;
-  }
-  findUsedIndexes(explain) {
-    const newIndexes = /* @__PURE__ */ new Set();
-    const existingIndexes = /* @__PURE__ */ new Set();
-    const prefix = _IndexOptimizer.prefix;
-    walkExplain(explain, (stage) => {
-      const indexName = stage["Index Name"];
-      if (indexName) {
-        if (indexName.startsWith(prefix)) {
-          newIndexes.add(indexName);
-        } else if (indexName.includes(prefix)) {
-          const actualName = indexName.substring(indexName.indexOf(prefix));
-          newIndexes.add(actualName);
-        } else {
-          existingIndexes.add(indexName);
-        }
-      }
-    });
-    return {
-      newIndexes,
-      existingIndexes
-    };
-  }
-  replaceUsedIndexesWithDefinition(explain, triedIndexes) {
-    walkExplain(explain, (stage) => {
-      const indexName = stage["Index Name"];
-      if (typeof indexName === "string") {
-        const recommendation = triedIndexes.get(indexName);
-        if (recommendation) {
-          stage["Index Name"] = recommendation.definition;
-        }
-      }
-    });
-  }
-};
-__publicField(_IndexOptimizer, "prefix", "__qd_");
-var IndexOptimizer = _IndexOptimizer;
-function walkExplain(explain, f) {
-  function go(plan) {
-    f(plan);
-    if (plan.Plans) {
-      for (const p of plan.Plans) {
-        go(p);
-      }
-    }
-  }
-  go(explain);
-}
-var RollbackError = class {
-  constructor(value) {
-    this.value = value;
-  }
-};
-var PROCEED = Symbol("PROCEED");
-var SKIP = Symbol("SKIP");
-
-// src/optimizer/statistics.ts
-import { gray as gray2 } from "colorette";
-import dedent from "dedent";
-import { z as z2 } from "zod";
-var StatisticsSource = z2.union([
-  z2.object({
-    kind: z2.literal("path"),
-    path: z2.string().min(1)
-  }),
-  z2.object({
-    kind: z2.literal("inline")
-  })
-]);
-var ExportedStatsStatistics = z2.object({
-  stawidth: z2.number(),
-  stainherit: z2.boolean().default(false),
-  // 0 representing unknown
-  stadistinct: z2.number(),
-  // this has no "nullable" state
-  stanullfrac: z2.number(),
-  stakind1: z2.number().min(0),
-  stakind2: z2.number().min(0),
-  stakind3: z2.number().min(0),
-  stakind4: z2.number().min(0),
-  stakind5: z2.number().min(0),
-  staop1: z2.string(),
-  staop2: z2.string(),
-  staop3: z2.string(),
-  staop4: z2.string(),
-  staop5: z2.string(),
-  stacoll1: z2.string(),
-  stacoll2: z2.string(),
-  stacoll3: z2.string(),
-  stacoll4: z2.string(),
-  stacoll5: z2.string(),
-  stanumbers1: z2.array(z2.number()).nullable(),
-  stanumbers2: z2.array(z2.number()).nullable(),
-  stanumbers3: z2.array(z2.number()).nullable(),
-  stanumbers4: z2.array(z2.number()).nullable(),
-  stanumbers5: z2.array(z2.number()).nullable(),
-  // theoretically... this could only be strings and numbers
-  // but we don't have a crystal ball
-  stavalues1: z2.array(z2.any()).nullable(),
-  stavalues2: z2.array(z2.any()).nullable(),
-  stavalues3: z2.array(z2.any()).nullable(),
-  stavalues4: z2.array(z2.any()).nullable(),
-  stavalues5: z2.array(z2.any()).nullable()
-});
-var ExportedStatsColumns = z2.object({
-  columnName: z2.string(),
-  stats: ExportedStatsStatistics.nullable()
-});
-var ExportedStatsIndex = z2.object({
-  indexName: z2.string(),
-  relpages: z2.number(),
-  reltuples: z2.number(),
-  relallvisible: z2.number(),
-  relallfrozen: z2.number().optional()
-});
-var ExportedStatsV1 = z2.object({
-  tableName: z2.string(),
-  schemaName: z2.string(),
-  // can be negative
-  relpages: z2.number(),
-  // can be negative
-  reltuples: z2.number(),
-  relallvisible: z2.number(),
-  // only postgres 18+
-  relallfrozen: z2.number().optional(),
-  columns: z2.array(ExportedStatsColumns).nullable(),
-  indexes: z2.array(ExportedStatsIndex)
-});
-var ExportedStats = z2.union([ExportedStatsV1]);
-var StatisticsMode = z2.discriminatedUnion("kind", [
-  z2.object({
-    kind: z2.literal("fromAssumption"),
-    reltuples: z2.number().min(0),
-    relpages: z2.number().min(0)
-  }),
-  z2.object({
-    kind: z2.literal("fromStatisticsExport"),
-    stats: z2.array(ExportedStats),
-    source: StatisticsSource
-  })
-]);
-var DEFAULT_RELTUPLES = 1e4;
-var DEFAULT_RELPAGES = 1;
-var _Statistics = class _Statistics {
-  constructor(db, postgresVersion, ownMetadata, statsMode) {
-    this.db = db;
-    this.postgresVersion = postgresVersion;
-    this.ownMetadata = ownMetadata;
-    __publicField(this, "mode");
-    __publicField(this, "exportedMetadata");
-    if (statsMode) {
-      this.mode = statsMode;
-      if (statsMode.kind === "fromStatisticsExport") {
-        this.exportedMetadata = statsMode.stats;
-      }
-    } else {
-      this.mode = _Statistics.defaultStatsMode;
-    }
-  }
-  static statsModeFromAssumption({
-    reltuples,
-    relpages
-  }) {
-    return {
-      kind: "fromAssumption",
-      reltuples,
-      relpages
-    };
-  }
-  /**
-   * Create a statistic mode from stats exported from another database
-   **/
-  static statsModeFromExport(stats) {
-    return {
-      kind: "fromStatisticsExport",
-      source: { kind: "inline" },
-      stats
-    };
-  }
-  static async fromPostgres(db, statsMode) {
-    const version = await db.serverNum();
-    const ownStats = await _Statistics.dumpStats(db, version, "full");
-    return new _Statistics(db, version, ownStats, statsMode);
-  }
-  restoreStats(tx) {
-    return this.restoreStats17(tx);
-  }
-  approximateTotalRows() {
-    if (!this.exportedMetadata) {
-      return 0;
-    }
-    let totalRows = 0;
-    for (const table of this.exportedMetadata) {
-      totalRows += table.reltuples;
-    }
-    return totalRows;
-  }
-  /**
-   * We have to cast stavaluesN to the correct type
-   * This derives that type for us so it can be used in `array_in`
-   */
-  stavalueKind(values) {
-    if (!values || values.length === 0) {
-      return null;
-    }
-    const [elem] = values;
-    if (typeof elem === "number") {
-      return "real";
-    } else if (typeof elem === "boolean") {
-      return "boolean";
-    }
-    return "text";
-  }
-  /**
-   * PostgreSQL's anyarray columns in pg_statistic can hold arrays of arrays
-   * for columns with array types (e.g. text[], int4[]). These create
-   * multidimensional arrays that can be "ragged" (sub-arrays with different
-   * lengths). jsonb_to_recordset can't reconstruct ragged multidimensional
-   * arrays from JSON, so we need to drop these values.
-   */
-  static safeStavalues(values) {
-    if (!values || values.length === 0) return values;
-    if (values.some((v) => Array.isArray(v))) {
-      console.warn("Discarding ragged multidimensional stavalues array");
-      return null;
-    }
-    return values;
-  }
-  async restoreStats17(tx) {
-    const warnings = {
-      tablesNotInExports: [],
-      tablesNotInTest: [],
-      tableNotAnalyzed: [],
-      statsMissing: []
-    };
-    const processedTables = /* @__PURE__ */ new Set();
-    let columnStatsUpdatePromise;
-    const columnStatsValues = [];
-    if (this.exportedMetadata) {
-      for (const table of this.ownMetadata) {
-        const targetTable = this.exportedMetadata.find(
-          (m) => m.tableName === table.tableName && m.schemaName === table.schemaName
-        );
-        if (!targetTable?.columns) {
-          continue;
-        }
-        for (const column of targetTable.columns) {
-          const { stats } = column;
-          if (!stats) {
-            continue;
-          }
-          columnStatsValues.push({
-            schema_name: table.schemaName,
-            table_name: table.tableName,
-            column_name: column.columnName,
-            stainherit: stats.stainherit ?? false,
-            stanullfrac: stats.stanullfrac,
-            stawidth: stats.stawidth,
-            stadistinct: stats.stadistinct,
-            stakind1: stats.stakind1,
-            stakind2: stats.stakind2,
-            stakind3: stats.stakind3,
-            stakind4: stats.stakind4,
-            stakind5: stats.stakind5,
-            staop1: stats.staop1,
-            staop2: stats.staop2,
-            staop3: stats.staop3,
-            staop4: stats.staop4,
-            staop5: stats.staop5,
-            stacoll1: stats.stacoll1,
-            stacoll2: stats.stacoll2,
-            stacoll3: stats.stacoll3,
-            stacoll4: stats.stacoll4,
-            stacoll5: stats.stacoll5,
-            stanumbers1: stats.stanumbers1,
-            stanumbers2: stats.stanumbers2,
-            stanumbers3: stats.stanumbers3,
-            stanumbers4: stats.stanumbers4,
-            stanumbers5: stats.stanumbers5,
-            stavalues1: _Statistics.safeStavalues(stats.stavalues1),
-            stavalues2: _Statistics.safeStavalues(stats.stavalues2),
-            stavalues3: _Statistics.safeStavalues(stats.stavalues3),
-            stavalues4: _Statistics.safeStavalues(stats.stavalues4),
-            stavalues5: _Statistics.safeStavalues(stats.stavalues5),
-            _value_type1: this.stavalueKind(
-              _Statistics.safeStavalues(stats.stavalues1)
-            ),
-            _value_type2: this.stavalueKind(
-              _Statistics.safeStavalues(stats.stavalues2)
-            ),
-            _value_type3: this.stavalueKind(
-              _Statistics.safeStavalues(stats.stavalues3)
-            ),
-            _value_type4: this.stavalueKind(
-              _Statistics.safeStavalues(stats.stavalues4)
-            ),
-            _value_type5: this.stavalueKind(
-              _Statistics.safeStavalues(stats.stavalues5)
-            )
-          });
-        }
-      }
-      const sql = dedent`
-    WITH input AS (
-      SELECT
-        c.oid AS starelid,
-        a.attnum AS staattnum,
-        v.stainherit,
-        v.stanullfrac,
-        v.stawidth,
-        v.stadistinct,
-        v.stakind1,
-        v.stakind2,
-        v.stakind3,
-        v.stakind4,
-        v.stakind5,
-        v.staop1,
-        v.staop2,
-        v.staop3,
-        v.staop4,
-        v.staop5,
-        v.stacoll1,
-        v.stacoll2,
-        v.stacoll3,
-        v.stacoll4,
-        v.stacoll5,
-        v.stanumbers1,
-        v.stanumbers2,
-        v.stanumbers3,
-        v.stanumbers4,
-        v.stanumbers5,
-        v.stavalues1,
-        v.stavalues2,
-        v.stavalues3,
-        v.stavalues4,
-        v.stavalues5,
-        _value_type1,
-        _value_type2,
-        _value_type3,
-        _value_type4,
-        _value_type5
-      FROM jsonb_to_recordset($1::jsonb) AS v(
-        schema_name text,
-        table_name text,
-        column_name text,
-        stainherit boolean,
-        stanullfrac real,
-        stawidth integer,
-        stadistinct real,
-        stakind1 real,
-        stakind2 real,
-        stakind3 real,
-        stakind4 real,
-        stakind5 real,
-        staop1 oid,
-        staop2 oid,
-        staop3 oid,
-        staop4 oid,
-        staop5 oid,
-        stacoll1 oid,
-        stacoll2 oid,
-        stacoll3 oid,
-        stacoll4 oid,
-        stacoll5 oid,
-        stanumbers1 real[],
-        stanumbers2 real[],
-        stanumbers3 real[],
-        stanumbers4 real[],
-        stanumbers5 real[],
-        stavalues1 text[],
-        stavalues2 text[],
-        stavalues3 text[],
-        stavalues4 text[],
-        stavalues5 text[],
-        _value_type1 text,
-        _value_type2 text,
-        _value_type3 text,
-        _value_type4 text,
-        _value_type5 text
-      )
-      JOIN pg_class c ON c.relname = v.table_name
-      JOIN pg_namespace n ON n.oid = c.relnamespace AND n.nspname = v.schema_name
-      JOIN pg_attribute a ON a.attrelid = c.oid AND a.attname = v.column_name
-    ),
-    updated AS (
-      UPDATE pg_statistic s
-      SET
-        stanullfrac = i.stanullfrac,
-        stawidth = i.stawidth,
-        stadistinct = i.stadistinct,
-        stakind1 = i.stakind1,
-        stakind2 = i.stakind2,
-        stakind3 = i.stakind3,
-        stakind4 = i.stakind4,
-        stakind5 = i.stakind5,
-        staop1 = i.staop1,
-        staop2 = i.staop2,
-        staop3 = i.staop3,
-        staop4 = i.staop4,
-        staop5 = i.staop5,
-        stacoll1 = i.stacoll1,
-        stacoll2 = i.stacoll2,
-        stacoll3 = i.stacoll3,
-        stacoll4 = i.stacoll4,
-        stacoll5 = i.stacoll5,
-        stanumbers1 = i.stanumbers1,
-        stanumbers2 = i.stanumbers2,
-        stanumbers3 = i.stanumbers3,
-        stanumbers4 = i.stanumbers4,
-        stanumbers5 = i.stanumbers5,
-        stavalues1 = case
-          when i.stavalues1 is null then null
-          else array_in(i.stavalues1::text::cstring, i._value_type1::regtype::oid, -1)
-        end,
-        stavalues2 = case
-          when i.stavalues2 is null then null
-          else array_in(i.stavalues2::text::cstring, i._value_type2::regtype::oid, -1)
-        end,
-        stavalues3 = case
-          when i.stavalues3 is null then null
-          else array_in(i.stavalues3::text::cstring, i._value_type3::regtype::oid, -1)
-        end,
-        stavalues4 = case
-          when i.stavalues4 is null then null
-          else array_in(i.stavalues4::text::cstring, i._value_type4::regtype::oid, -1)
-        end,
-        stavalues5 = case
-          when i.stavalues5 is null then null
-          else array_in(i.stavalues5::text::cstring, i._value_type5::regtype::oid, -1)
-        end
-        -- stavalues1 = i.stavalues1,
-        -- stavalues2 = i.stavalues2,
-        -- stavalues3 = i.stavalues3,
-        -- stavalues4 = i.stavalues4,
-        -- stavalues5 = i.stavalues5
-      FROM input i
-      WHERE s.starelid = i.starelid AND s.staattnum = i.staattnum AND s.stainherit = i.stainherit
-      RETURNING s.starelid, s.staattnum, s.stainherit, s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5
-    ),
-    inserted as (
-      INSERT INTO pg_statistic (
-        starelid, staattnum, stainherit,
-        stanullfrac, stawidth, stadistinct,
-        stakind1, stakind2, stakind3, stakind4, stakind5,
-        staop1, staop2, staop3, staop4, staop5,
-        stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
-        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
-        stavalues1, stavalues2, stavalues3, stavalues4, stavalues5
-      )
-      SELECT
-      i.starelid, i.staattnum, i.stainherit,
-      i.stanullfrac, i.stawidth, i.stadistinct,
-      i.stakind1, i.stakind2, i.stakind3, i.stakind4, i.stakind5,
-      i.staop1, i.staop2, i.staop3, i.staop4, i.staop5,
-      i.stacoll1, i.stacoll2, i.stacoll3, i.stacoll4, i.stacoll5,
-      i.stanumbers1, i.stanumbers2, i.stanumbers3, i.stanumbers4, i.stanumbers5,
-      -- i.stavalues1, i.stavalues2, i.stavalues3, i.stavalues4, i.stavalues5,
-      case
-        when i.stavalues1 is null then null
-        else array_in(i.stavalues1::text::cstring, i._value_type1::regtype::oid, -1)
-      end,
-      case
-        when i.stavalues2 is null then null
-        else array_in(i.stavalues2::text::cstring, i._value_type2::regtype::oid, -1)
-      end,
-      case
-        when i.stavalues3 is null then null
-        else array_in(i.stavalues3::text::cstring, i._value_type3::regtype::oid, -1)
-      end,
-      case
-        when i.stavalues4 is null then null
-        else array_in(i.stavalues4::text::cstring, i._value_type4::regtype::oid, -1)
-      end,
-      case
-        when i.stavalues5 is null then null
-        else array_in(i.stavalues5::text::cstring, i._value_type5::regtype::oid, -1)
-      end
-      -- i._value_type1, i._value_type2, i._value_type3, i._value_type4, i._value_type5
-      FROM input i
-      LEFT JOIN updated u
-        ON i.starelid = u.starelid AND i.staattnum = u.staattnum AND i.stainherit = u.stainherit
-      WHERE u.starelid IS NULL
-      returning starelid, staattnum, stainherit, stakind1, stakind2, stakind3, stakind4, stakind5
-    )
-    select * from updated union all (select * from inserted); -- @qd_introspection`;
-      columnStatsUpdatePromise = tx.exec(sql, [columnStatsValues]).catch((err) => {
-        console.error("Something wrong wrong updating column stats");
-        console.error(err);
-        throw err;
-      });
-    }
-    const reltuplesValues = [];
-    for (const table of this.ownMetadata) {
-      if (!table.columns) {
-        continue;
-      }
-      processedTables.add(`${table.schemaName}.${table.tableName}`);
-      let targetTable;
-      if (this.exportedMetadata) {
-        targetTable = this.exportedMetadata.find(
-          (m) => m.tableName === table.tableName && m.schemaName === table.schemaName
-        );
-      }
-      let reltuples;
-      let relpages;
-      let relallvisible = 0;
-      let relallfrozen;
-      if (targetTable) {
-        reltuples = targetTable.reltuples;
-        relpages = targetTable.relpages;
-        relallvisible = targetTable.relallvisible;
-        relallfrozen = targetTable.relallfrozen;
-      } else if (this.mode.kind === "fromAssumption") {
-        reltuples = this.mode.reltuples;
-        relpages = this.mode.relpages;
-      } else {
-        warnings.tablesNotInExports.push(
-          `${table.schemaName}.${table.tableName}`
-        );
-        reltuples = DEFAULT_RELTUPLES;
-        relpages = DEFAULT_RELPAGES;
-      }
-      reltuplesValues.push({
-        relname: table.tableName,
-        schema_name: table.schemaName,
-        reltuples,
-        relpages,
-        relallfrozen,
-        relallvisible
-      });
-      if (targetTable && targetTable.indexes) {
-        for (const index of targetTable.indexes) {
-          reltuplesValues.push({
-            relname: index.indexName,
-            schema_name: targetTable.schemaName,
-            reltuples: index.reltuples,
-            relpages: index.relpages,
-            relallfrozen: index.relallfrozen,
-            relallvisible: index.relallvisible
-          });
-        }
-      }
-    }
-    const reltuplesQuery = dedent`
-        update pg_class p
-        set reltuples = v.reltuples,
-            relpages = v.relpages,
-            -- relallfrozen = case when v.relallfrozen is null then p.relallfrozen else v.relallfrozen end,
-            relallvisible = case when v.relallvisible is null then p.relallvisible else v.relallvisible end
-        from jsonb_to_recordset($1::jsonb)
-            as v(reltuples real, relpages integer, relallfrozen integer, relallvisible integer, relname text, schema_name text)
-        where p.relname = v.relname
-        and p.relnamespace = (select oid from pg_namespace where nspname = v.schema_name)
-        returning p.relname, p.relnamespace, p.reltuples, p.relpages;
-        `;
-    const reltuplesPromise = tx.exec(reltuplesQuery, [reltuplesValues]).catch((err) => {
-      console.error("Something went wrong updating reltuples/relpages");
-      console.error(err);
-      return err;
-    });
-    if (this.exportedMetadata) {
-      for (const table of this.exportedMetadata) {
-        const tableExists = processedTables.has(
-          `${table.schemaName}.${table.tableName}`
-        );
-        if (tableExists && table.reltuples === -1) {
-          console.warn(
-            `Table ${table.tableName} has reltuples -1. Your production database is probably not analyzed properly`
-          );
-          warnings.tableNotAnalyzed.push(
-            `${table.schemaName}.${table.tableName}`
-          );
-        }
-        if (tableExists) {
-          continue;
-        }
-        warnings.tablesNotInTest.push(`${table.schemaName}.${table.tableName}`);
-      }
-    }
-    const [statsUpdates, reltuplesUpdates] = await Promise.all([
-      columnStatsUpdatePromise,
-      reltuplesPromise
-    ]);
-    const updatedColumnsProperly = statsUpdates ? statsUpdates.length === columnStatsValues.length : true;
-    if (!updatedColumnsProperly) {
-      console.error(`Did not update expected column stats`);
-    }
-    if (reltuplesUpdates.length !== reltuplesValues.length) {
-      console.error(`Did not update expected reltuples/relpages`);
-    }
-    return warnings;
-  }
-  static async dumpStats(db, postgresVersion, kind) {
-    const fullDump = kind === "full";
-    console.log(`dumping stats for postgres ${gray2(postgresVersion)}`);
-    const stats = await db.exec(
-      `
-      WITH table_columns AS (
-        SELECT
-          c.table_name,
-          c.table_schema,
-          cl.reltuples,
-          cl.relpages,
-          cl.relallvisible,
-          -- cl.relallfrozen,
-          n.nspname AS schema_name,
-          json_agg(
-            json_build_object(
-              'columnName', c.column_name,
-              'stats', (
-                SELECT json_build_object(
-                  'starelid', s.starelid,
-                  'staattnum', s.staattnum,
-                  'stanullfrac', s.stanullfrac,
-                  'stawidth', s.stawidth,
-                  'stadistinct', s.stadistinct,
-                  'stakind1', s.stakind1, 'staop1', s.staop1, 'stacoll1', s.stacoll1, 'stanumbers1', s.stanumbers1,
-                  'stakind2', s.stakind2, 'staop2', s.staop2, 'stacoll2', s.stacoll2, 'stanumbers2', s.stanumbers2,
-                  'stakind3', s.stakind3, 'staop3', s.staop3, 'stacoll3', s.stacoll3, 'stanumbers3', s.stanumbers3,
-                  'stakind4', s.stakind4, 'staop4', s.staop4, 'stacoll4', s.stacoll4, 'stanumbers4', s.stanumbers4,
-                  'stakind5', s.stakind5, 'staop5', s.staop5, 'stacoll5', s.stacoll5, 'stanumbers5', s.stanumbers5,
-                  'stavalues1', CASE WHEN $1 THEN s.stavalues1 ELSE NULL END,
-                  'stavalues2', CASE WHEN $1 THEN s.stavalues2 ELSE NULL END,
-                  'stavalues3', CASE WHEN $1 THEN s.stavalues3 ELSE NULL END,
-                  'stavalues4', CASE WHEN $1 THEN s.stavalues4 ELSE NULL END,
-                  'stavalues5', CASE WHEN $1 THEN s.stavalues5 ELSE NULL END
-                )
-                FROM pg_statistic s
-                WHERE s.starelid = a.attrelid AND s.staattnum = a.attnum
-              )
-            )
-            ORDER BY c.ordinal_position
-          ) AS columns
-        FROM information_schema.columns c
-        JOIN pg_attribute a
-          ON a.attrelid = (quote_ident(c.table_schema) || '.' || quote_ident(c.table_name))::regclass
-          AND a.attname = c.column_name
-        JOIN pg_class cl
-          ON cl.oid = a.attrelid
-        JOIN pg_namespace n
-          ON n.oid = cl.relnamespace
-        WHERE c.table_name NOT LIKE 'pg_%'
-          AND n.nspname <> 'information_schema'
-          AND c.table_name NOT IN ('pg_stat_statements', 'pg_stat_statements_info')
-        GROUP BY c.table_name, c.table_schema, cl.reltuples, cl.relpages, cl.relallvisible, n.nspname
-      ),
-      table_indexes AS (
-        SELECT
-          t.relname AS table_name,
-          json_agg(
-            json_build_object(
-              'indexName', i.relname,
-              'reltuples', i.reltuples,
-              'relpages', i.relpages,
-              'relallvisible', i.relallvisible
-              -- 'relallfrozen', i.relallfrozen
-            )
-          ) AS indexes
-        FROM pg_class t
-        JOIN pg_index ix ON ix.indrelid = t.oid
-        JOIN pg_class i ON i.oid = ix.indexrelid
-        JOIN pg_namespace n ON n.oid = t.relnamespace
-        WHERE t.relname NOT LIKE 'pg_%'
-          AND n.nspname <> 'information_schema'
-        GROUP BY t.relname
-      )
-      SELECT json_agg(
-        json_build_object(
-          'tableName', tc.table_name,
-          'schemaName', tc.table_schema,
-          'reltuples', tc.reltuples,
-          'relpages', tc.relpages,
-          'relallvisible', tc.relallvisible,
-          -- 'relallfrozen', tc.relallfrozen,
-          'columns', tc.columns,
-          'indexes', COALESCE(ti.indexes, '[]'::json)
-        )
-      )
-      FROM table_columns tc
-      LEFT JOIN table_indexes ti
-        ON ti.table_name = tc.table_name;
-      `,
-      [fullDump]
-    );
-    return stats[0].json_agg;
-  }
-  /**
-   * Returns all indexes in the database.
-   * ONLY handles regular btree indexes
-   */
-  async getExistingIndexes() {
-    const indexes = await this.db.exec(`
-      WITH partitioned_tables AS (
-          SELECT
-              inhparent::regclass AS parent_table,
-              inhrelid::regclass AS partition_table
-          FROM
-              pg_inherits
-      )
-      SELECT
-          n.nspname AS schema_name,
-          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
-                  -- Handle regular columns
-                  WHEN a.attname IS NOT NULL THEN
-                    json_build_object('name', a.attname, 'order',
-                      CASE
-                          WHEN (indoption[array_position(ix.indkey, a.attnum)] & 1) = 1 THEN 'DESC'
-                          ELSE 'ASC'
-                      END,
-                      'opclass', CASE WHEN opc.opcdefault THEN NULL ELSE opc.opcname END)
-                  -- Handle expressions
-                  ELSE
-                      json_build_object('name', pg_get_expr((ix.indexprs)::pg_node_tree, t.oid), 'order',
-                      CASE
-                          WHEN (indoption[array_position(ix.indkey, k.attnum)] & 1) = 1 THEN 'DESC'
-                          ELSE 'ASC'
-                      END,
-                      'opclass', CASE WHEN opc.opcdefault THEN NULL ELSE opc.opcname END)
-              END
-              ORDER BY array_position(ix.indkey, k.attnum)
-          ) AS index_columns
-      FROM
-          pg_class t
-          LEFT JOIN partitioned_tables pt ON t.oid = pt.partition_table
-          JOIN pg_index ix ON t.oid = ix.indrelid
-          JOIN pg_class i ON i.oid = ix.indexrelid
-          JOIN pg_am am ON i.relam = am.oid
-          LEFT JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY k(attnum, ordinality) ON true
-          LEFT JOIN pg_attribute a ON a.attnum = k.attnum AND a.attrelid = t.oid
-          LEFT JOIN pg_opclass opc ON opc.oid = ix.indclass[k.ordinality - 1]
-          JOIN pg_namespace n ON t.relnamespace = n.oid
-      WHERE
-          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, ix.indisunique
-      ORDER BY
-          COALESCE(pt.parent_table::text, t.relname), i.relname; -- @qd_introspection
-      `);
-    return indexes;
-  }
-};
-// preventing accidental internal mutations
-__publicField(_Statistics, "defaultStatsMode", Object.freeze({
-  kind: "fromAssumption",
-  reltuples: DEFAULT_RELTUPLES,
-  relpages: DEFAULT_RELPAGES
-}));
-var Statistics = _Statistics;
-
-// src/optimizer/pss-rewriter.ts
-var PssRewriter = class {
-  constructor() {
-    __publicField(this, "problematicKeywords", ["interval", "timestamp", "geometry"]);
-  }
-  rewrite(query) {
-    return this.rewriteKeywordWithParameter(query);
-  }
-  rewriteKeywordWithParameter(query) {
-    return query.replace(/\b(\w+) (\$\d+)\b/gi, (match) => {
-      const [keyword, parameter] = match.split(" ");
-      const isProblematicKeyword = this.problematicKeywords.includes(
-        keyword.toLowerCase()
-      );
-      if (!isProblematicKeyword) {
-        return match;
-      }
-      return `(${parameter}::${keyword.toLowerCase()})`;
-    });
-  }
-};
-export {
-  Analyzer,
-  ExportedStats,
-  ExportedStatsColumns,
-  ExportedStatsIndex,
-  ExportedStatsStatistics,
-  ExportedStatsV1,
-  IndexOptimizer,
-  PROCEED,
-  PgIdentifier,
-  PostgresQueryBuilder,
-  PostgresVersion,
-  PssRewriter,
-  SKIP,
-  Statistics,
-  StatisticsMode,
-  StatisticsSource,
-  dropIndex,
-  ignoredIdentifier,
-  isIndexProbablyDroppable,
-  isIndexSupported,
-  parseNudges
-};
-//# sourceMappingURL=index.js.map