@query-doctor/core 0.0.3

package/dist/index.js

@@ -0,0 +1,1787 @@
+'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"
+      });
+    }
+  }
+  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) {
+        this.tableMappings.set(node.RangeVar.relname, {
+          text: node.RangeVar.relname,
+          start: node.RangeVar.location,
+          quoted: false
+        });
+        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 (existingMapping) {
+            console.warn(
+              `Ignoring alias ${aliasName} as it shadows an existing mapping. 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, "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;
+    }
+    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(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) {
+    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);
+    }
+    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);
+        const matchingTables = tables.filter((table) => {
+          return table.columns?.some((column2) => {
+            return column2.columnName === referencedColumn;
+          }) ?? false;
+        });
+        for (const table of matchingTables) {
+          const index = {
+            schema: table.schemaName,
+            table: table.tableName,
+            column: referencedColumn
+          };
+          if (colReference.sort) {
+            index.sort = colReference.sort;
+          }
+          if (colReference.where) {
+            index.where = colReference.where;
+          }
+          addIndex(index);
+        }
+      } else if (tableReference) {
+        const [table, column] = colReference.parts;
+        const referencedTable = this.normalize(table);
+        const referencedColumn = this.normalize(column);
+        const matchingTable = tables.find((table2) => {
+          const hasMatchingColumn = table2.columns?.some((column2) => {
+            return column2.columnName === referencedColumn;
+          }) ?? false;
+          return table2.tableName === referencedTable && hasMatchingColumn;
+        });
+        if (matchingTable) {
+          const index = {
+            schema: matchingTable.schemaName,
+            table: referencedTable,
+            column: referencedColumn
+          };
+          if (colReference.sort) {
+            index.sort = colReference.sort;
+          }
+          if (colReference.where) {
+            index.where = colReference.where;
+          }
+          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;
+        }
+        addIndex(index);
+      } else {
+        console.error(
+          "Column reference has too many parts. The query is malformed",
+          colReference
+        );
+        continue;
+      }
+    }
+    return allIndexes;
+  }
+  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);
+    if (!tagString || typeof tagString !== "string") {
+      return { tags: [], queryWithoutTags };
+    }
+    const tags = [];
+    for (const match of tagString.split(",")) {
+      const [key, value] = match.split("=");
+      if (!key || !value) {
+        console.warn(`Invalid sqlcommenter tag: ${match}. 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");
+
+// src/optimizer/genalgo.ts
+import { blue as blue2, gray, green, magenta, red, yellow } from "colorette";
+
+// 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);
+  }
+  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;
+  }
+  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 query = "";
+    if (this.explainFlags.length > 0) {
+      query += `explain (${this.explainFlags.join(", ")}) `;
+    }
+    const semicolon = this.query.endsWith(";") ? "" : ";";
+    const preamble = query.length;
+    query += `${this.query}${semicolon}`;
+    return { query, preamble };
+  }
+};
+
+// 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) {
+    const baseExplain = await this.runWithoutIndexes(builder);
+    const baseCost = Number(baseExplain.Plan["Total Cost"]);
+    if (baseCost === 0) {
+      return {
+        kind: "zero_cost_plan",
+        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(` <${gray("skip")}> ${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(
+            `${green(
+              `+${costDeltaPercentage.toFixed(2).padStart(5, "0")}%`
+            )} ${indexDefinition} `
+          );
+          iter = permutations.next(PROCEED);
+        } else {
+          console.log(
+            `${previousCost === explainCost ? ` ${gray("00.00%")}` : `${red(
+              `-${Math.abs(costDeltaPercentage).toFixed(2).padStart(5, "0")}%`
+            )}`} ${indexDefinition}`
+          );
+          iter = permutations.next(PROCEED);
+        }
+        nextStage.push({
+          name: indexName,
+          schema,
+          table,
+          columns: columns2
+        });
+      }
+    }
+    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`
+        );
+      }
+    });
+    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 { newIndexes, existingIndexes: existingIndexesUsedByQuery } = this.findUsedIndexes(finalExplain.Plan);
+    return {
+      kind: "ok",
+      baseCost,
+      finalCost,
+      newIndexes,
+      existingIndexes: existingIndexesUsedByQuery,
+      triedIndexes,
+      baseExplainPlan: baseExplain,
+      explainPlan: finalExplain
+    };
+  }
+  async runWithoutIndexes(builder) {
+    return await this.testQueryWithStats(builder, async (tx) => {
+      await this.dropExistingIndexes(tx);
+    });
+  }
+  /**
+   * 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() {
+    return _IndexOptimizer.prefix + Math.random().toString(36).substring(2, 16);
+  }
+  // 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)
+    );
+  }
+  toDefinition(permuted) {
+    const make = (col, order, where, keyword) => {
+      const baseColumn = `"${permuted.schema}"."${permuted.table}"(${permuted.columns.map((c) => {
+        const direction = c.sort && this.sortDirection(c.sort);
+        const nulls = c.sort && this.nullsOrder(c.sort);
+        let sort = col(`"${c.column}"`);
+        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 };
+  }
+  /**
+   * Drop indexes that can be dropped (non-primary keys)
+   */
+  async dropExistingIndexes(tx) {
+    for (const index of this.existingIndexes) {
+      if (index.is_primary) {
+        continue;
+      }
+      await tx.exec(
+        `drop index if exists ${index.schema_name}.${index.index_name} cascade`
+      );
+    }
+  }
+  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", "trace"];
+        if (options && !options.genericPlan) {
+          flags.push("analyze");
+        } 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");
+  }
+  tableColumnIndexCandidates(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();
+    function go(plan) {
+      const indexName = plan["Index Name"];
+      if (indexName) {
+        if (indexName.startsWith(_IndexOptimizer.prefix)) {
+          newIndexes.add(indexName);
+        } else {
+          existingIndexes.add(indexName);
+        }
+      }
+      if (plan.Plans) {
+        for (const p of plan.Plans) {
+          go(p);
+        }
+      }
+    }
+    go(explain);
+    return {
+      newIndexes,
+      existingIndexes
+    };
+  }
+};
+__publicField(_IndexOptimizer, "prefix", "__qd_");
+var IndexOptimizer = _IndexOptimizer;
+var RollbackError = class {
+  constructor(value) {
+    this.value = value;
+  }
+};
+var PROCEED = Symbol("PROCEED");
+var SKIP = Symbol("SKIP");
+function* permuteWithFeedback(arr) {
+  function* helper(path, rest) {
+    let i = 0;
+    while (i < rest.length) {
+      const nextPath = [...path, rest[i]];
+      const nextRest = [...rest.slice(0, i), ...rest.slice(i + 1)];
+      const input = yield nextPath;
+      if (input === PROCEED) {
+        yield* helper(nextPath, nextRest);
+      }
+      i++;
+    }
+  }
+  yield* helper([], arr);
+}
+
+// src/optimizer/statistics.ts
+import { gray as gray2 } from "colorette";
+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(),
+  dataType: z2.string(),
+  isNullable: z2.boolean(),
+  numericScale: z2.number().nullable(),
+  columnDefault: z2.string().nullable(),
+  numericPrecision: z2.number().nullable(),
+  characterMaximumLength: z2.number().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);
+  }
+  /**
+   * 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";
+  }
+  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: stats.stavalues1,
+            stavalues2: stats.stavalues2,
+            stavalues3: stats.stavalues3,
+            stavalues4: stats.stavalues4,
+            stavalues5: stats.stavalues5,
+            _value_type1: this.stavalueKind(stats.stavalues1),
+            _value_type2: this.stavalueKind(stats.stavalues2),
+            _value_type3: this.stavalueKind(stats.stavalues3),
+            _value_type4: this.stavalueKind(stats.stavalues4),
+            _value_type5: this.stavalueKind(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,
+              '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,
+                  '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,
+          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)
+                  -- 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)
+              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
+          JOIN pg_namespace n ON t.relnamespace = n.oid
+      WHERE
+          n.nspname = 'public'
+      GROUP BY
+          n.nspname, COALESCE(pt.parent_table::text, t.relname), i.relname, am.amname, ix.indisprimary
+      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;
+export {
+  Analyzer,
+  ExportedStats,
+  ExportedStatsColumns,
+  ExportedStatsIndex,
+  ExportedStatsStatistics,
+  ExportedStatsV1,
+  IndexOptimizer,
+  PROCEED,
+  PostgresQueryBuilder,
+  PostgresVersion,
+  SKIP,
+  Statistics,
+  StatisticsMode,
+  StatisticsSource,
+  ignoredIdentifier,
+  parseNudges,
+  permuteWithFeedback
+};
+//# sourceMappingURL=index.js.map