@query-doctor/core 0.3.0 → 0.4.1-rc.1

package/dist/index.cjs

@@ -1,1743 +1,2159 @@
 'use client'
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Analyzer: () => Analyzer,
-  ExportedStats: () => ExportedStats,
-  ExportedStatsColumns: () => ExportedStatsColumns,
-  ExportedStatsIndex: () => ExportedStatsIndex,
-  ExportedStatsStatistics: () => ExportedStatsStatistics,
-  ExportedStatsV1: () => ExportedStatsV1,
-  IndexOptimizer: () => IndexOptimizer,
-  PROCEED: () => PROCEED,
-  PgIdentifier: () => PgIdentifier,
-  PostgresQueryBuilder: () => PostgresQueryBuilder,
-  PostgresVersion: () => PostgresVersion,
-  PssRewriter: () => PssRewriter,
-  SKIP: () => SKIP,
-  Statistics: () => Statistics,
-  StatisticsMode: () => StatisticsMode,
-  StatisticsSource: () => StatisticsSource,
-  dropIndex: () => dropIndex,
-  ignoredIdentifier: () => ignoredIdentifier,
-  isIndexProbablyDroppable: () => isIndexProbablyDroppable,
-  isIndexSupported: () => isIndexSupported,
-  parseNudges: () => parseNudges
-});
-module.exports = __toCommonJS(index_exports);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-// src/sql/analyzer.ts
-var import_colorette = require("colorette");
+//#endregion
+let colorette = require("colorette");
+let pgsql_deparser = require("pgsql-deparser");
+let zod = require("zod");
+let dedent = require("dedent");
+dedent = __toESM(dedent);
 
-// src/sql/walker.ts
-var import_pgsql_deparser = require("pgsql-deparser");
-
-// src/sql/nudges.ts
-function is(node, kind) {
-  return kind in node;
+//#region src/sql/nudges.ts
+function is$1(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 isANode$1(node) {
+	if (typeof node !== "object" || node === null) return false;
+	const keys = Object.keys(node);
+	return keys.length === 1 && /^[A-Z]/.test(keys[0]);
 }
+/** Operators that require a GiST index for efficient execution */
+const GIST_OPERATORS = new Set(["&&", "-|-"]);
+/** PostGIS / spatial functions that require a GiST index */
+const SPATIAL_FUNCTIONS = new Set([
+	"st_intersects",
+	"st_contains",
+	"st_within",
+	"st_dwithin",
+	"st_covers",
+	"st_coveredby",
+	"st_crosses",
+	"st_overlaps",
+	"st_touches"
+]);
+const JSONB_EXTRACTION_OPS = new Set([
+	"->>",
+	"->",
+	"#>>",
+	"#>"
+]);
+function getAExprOpName(node) {
+	const nameNode = node.A_Expr.name?.[0];
+	if (nameNode && is$1(nameNode, "String") && nameNode.String.sval) return nameNode.String.sval;
+	return null;
+}
+/**
+* Check if a node is or contains a JSONB extraction expression,
+* unwrapping through TypeCast. Returns the extraction A_Expr if found.
+*/
+function findExtractionExpr(node) {
+	if (is$1(node, "A_Expr")) {
+		const op = getAExprOpName(node);
+		if (op && JSONB_EXTRACTION_OPS.has(op)) {
+			if (node.A_Expr.lexpr && hasColumnRefInNode(node.A_Expr.lexpr)) return node;
+			return null;
+		}
+	}
+	if (is$1(node, "TypeCast") && node.TypeCast.arg) return findExtractionExpr(node.TypeCast.arg);
+	return null;
+}
+const ARITHMETIC_OPERATORS = new Set([
+	"+",
+	"-",
+	"*",
+	"/",
+	"%"
+]);
+const isArithmeticExpr = (node) => {
+	if (!node || typeof node !== "object") return false;
+	if (!isANode$1(node) || !is$1(node, "A_Expr")) return false;
+	if (node.A_Expr.kind !== "AEXPR_OP" || !node.A_Expr.name?.length) return false;
+	const opNode = node.A_Expr.name[0];
+	if (!is$1(opNode, "String") || !opNode.String.sval) return false;
+	return ARITHMETIC_OPERATORS.has(opNode.String.sval);
+};
+const COMPARISON_OPERATORS = new Set([
+	"=",
+	"<",
+	">",
+	"<=",
+	">=",
+	"<>",
+	"!="
+]);
+const findFuncCallsOnColumns = (whereClause) => {
+	const nudges = [];
+	Walker.shallowMatch(whereClause, "FuncCall", (node) => {
+		if (node.FuncCall.args && containsColumnRef(node.FuncCall.args)) nudges.push({
+			kind: "AVOID_FUNCTIONS_ON_COLUMNS_IN_WHERE",
+			severity: "WARNING",
+			message: "Avoid using functions on columns in WHERE clause",
+			location: node.FuncCall.location
+		});
+	});
+	Walker.shallowMatch(whereClause, "CoalesceExpr", (node) => {
+		if (node.CoalesceExpr.args && containsColumnRef(node.CoalesceExpr.args)) nudges.push({
+			kind: "AVOID_FUNCTIONS_ON_COLUMNS_IN_WHERE",
+			severity: "WARNING",
+			message: "Avoid using functions on columns in WHERE clause",
+			location: node.CoalesceExpr.location
+		});
+	});
+	return nudges;
+};
+const findJsonbExtractionInWhere = (whereClause) => {
+	const nudges = [];
+	const seen = /* @__PURE__ */ new Set();
+	function emit(node) {
+		const extraction = findExtractionExpr(node);
+		if (extraction && extraction.A_Expr.location !== void 0 && !seen.has(extraction.A_Expr.location)) {
+			seen.add(extraction.A_Expr.location);
+			nudges.push({
+				kind: "CONSIDER_EXPRESSION_INDEX_FOR_JSONB_EXTRACTION",
+				severity: "INFO",
+				message: "Consider an expression B-tree index for JSONB path extraction",
+				location: extraction.A_Expr.location
+			});
+		}
+	}
+	function walk(node) {
+		if (is$1(node, "A_Expr")) {
+			const op = getAExprOpName(node);
+			if (op && JSONB_EXTRACTION_OPS.has(op)) return;
+			if (node.A_Expr.lexpr) emit(node.A_Expr.lexpr);
+			if (node.A_Expr.rexpr) emit(node.A_Expr.rexpr);
+			return;
+		}
+		if (is$1(node, "BoolExpr") && node.BoolExpr.args) {
+			for (const arg of node.BoolExpr.args) walk(arg);
+			return;
+		}
+		if (is$1(node, "NullTest") && node.NullTest.arg) {
+			emit(node.NullTest.arg);
+			return;
+		}
+		if (is$1(node, "BooleanTest") && node.BooleanTest.arg) {
+			emit(node.BooleanTest.arg);
+			return;
+		}
+		if (is$1(node, "SubLink") && node.SubLink.testexpr) {
+			emit(node.SubLink.testexpr);
+			return;
+		}
+	}
+	walk(whereClause);
+	return nudges;
+};
+const findArithmeticExprsOnColumns = (whereClause) => {
+	const nudges = [];
+	Walker.shallowMatch(whereClause, "A_Expr", (node) => {
+		if (node.A_Expr.kind !== "AEXPR_OP" || !node.A_Expr.name?.length) return;
+		const opNode = node.A_Expr.name[0];
+		if (!is$1(opNode, "String") || !opNode.String.sval) return;
+		if (!COMPARISON_OPERATORS.has(opNode.String.sval)) return;
+		const sides = [node.A_Expr.lexpr, node.A_Expr.rexpr];
+		for (const side of sides) if (side && isArithmeticExpr(side) && hasColumnRefInNode(side)) {
+			const expr = side;
+			nudges.push({
+				kind: "AVOID_EXPRESSIONS_ON_COLUMNS_IN_WHERE",
+				severity: "WARNING",
+				message: "Avoid using arithmetic expressions on columns in WHERE clause",
+				location: expr.A_Expr.location
+			});
+		}
+	});
+	return nudges;
+};
+/**
+* Detect nudges for a single node during AST traversal.
+* Returns an array of nudges found for this node.
+*/
 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;
+	const nudges = [];
+	if (is$1(node, "SelectStmt")) {
+		if (node.SelectStmt.whereClause) {
+			nudges.push(...findFuncCallsOnColumns(node.SelectStmt.whereClause));
+			nudges.push(...findJsonbExtractionInWhere(node.SelectStmt.whereClause));
+			nudges.push(...findArithmeticExprsOnColumns(node.SelectStmt.whereClause));
+		}
+		const star = node.SelectStmt.targetList?.find((target) => {
+			if (!(is$1(target, "ResTarget") && target.ResTarget.val && is$1(target.ResTarget.val, "ColumnRef"))) return false;
+			const fields = target.ResTarget.val.ColumnRef.fields;
+			if (!fields?.some((field) => is$1(field, "A_Star"))) return false;
+			if (fields.length > 1) return false;
+			return true;
+		});
+		if (star) {
+			const fromClause = node.SelectStmt.fromClause;
+			if (!(fromClause && fromClause.length > 0 && fromClause.every((item) => is$1(item, "RangeSubselect")))) nudges.push({
+				kind: "AVOID_SELECT_STAR",
+				severity: "INFO",
+				message: "Avoid using SELECT *",
+				location: star.ResTarget.location
+			});
+		}
+		for (const target of node.SelectStmt.targetList ?? []) if (is$1(target, "ResTarget") && target.ResTarget.val && is$1(target.ResTarget.val, "SubLink") && target.ResTarget.val.SubLink.subLinkType === "EXPR_SUBLINK") nudges.push({
+			kind: "AVOID_SCALAR_SUBQUERY_IN_SELECT",
+			severity: "WARNING",
+			message: "Avoid correlated scalar subqueries in SELECT; consider rewriting as a JOIN",
+			location: target.ResTarget.val.SubLink.location
+		});
+	}
+	if (is$1(node, "SelectStmt")) {
+		if (!stack.some((item) => item === "RangeSubselect" || item === "SubLink" || item === "CommonTableExpr")) {
+			if (node.SelectStmt.fromClause && node.SelectStmt.fromClause.length > 0) {
+				if (node.SelectStmt.fromClause.some((fromItem) => {
+					return is$1(fromItem, "RangeVar") || is$1(fromItem, "JoinExpr") && hasActualTablesInJoin(fromItem);
+				})) {
+					const fromLocation = node.SelectStmt.fromClause.find((item) => is$1(item, "RangeVar"))?.RangeVar.location;
+					if (!node.SelectStmt.whereClause) nudges.push({
+						kind: "MISSING_WHERE_CLAUSE",
+						severity: "INFO",
+						message: "Missing WHERE clause",
+						location: fromLocation
+					});
+					if (!node.SelectStmt.limitCount) nudges.push({
+						kind: "MISSING_LIMIT_CLAUSE",
+						severity: "INFO",
+						message: "Missing LIMIT clause",
+						location: fromLocation
+					});
+				}
+			}
+		}
+	}
+	if (is$1(node, "SelectStmt")) {
+		if (!stack.some((item) => item === "RangeSubselect" || item === "SubLink" || item === "CommonTableExpr") && node.SelectStmt.sortClause && node.SelectStmt.whereClause) {
+			const equalityColumns = collectEqualityConstrainedColumns(node.SelectStmt.whereClause);
+			for (const sortItem of node.SelectStmt.sortClause) {
+				if (!is$1(sortItem, "SortBy") || !sortItem.SortBy.node) continue;
+				const sortNode = sortItem.SortBy.node;
+				if (!is$1(sortNode, "ColumnRef") || !sortNode.ColumnRef.fields) continue;
+				const lastField = sortNode.ColumnRef.fields[sortNode.ColumnRef.fields.length - 1];
+				if (!is$1(lastField, "String")) continue;
+				const sortCol = lastField.String.sval;
+				if (sortCol && equalityColumns.has(sortCol)) nudges.push({
+					kind: "NOOP_ORDER_BY",
+					severity: "INFO",
+					message: "ORDER BY column is constrained to a single value by WHERE clause",
+					location: sortNode.ColumnRef.location
+				});
+			}
+		}
+	}
+	if (is$1(node, "SelectStmt") && node.SelectStmt.sortClause) for (const sortItem of node.SelectStmt.sortClause) {
+		if (!is$1(sortItem, "SortBy")) continue;
+		const sortDir = sortItem.SortBy.sortby_dir ?? "SORTBY_DEFAULT";
+		const sortNulls = sortItem.SortBy.sortby_nulls ?? "SORTBY_NULLS_DEFAULT";
+		if (sortDir === "SORTBY_DESC" && sortNulls === "SORTBY_NULLS_DEFAULT") {
+			if (sortItem.SortBy.node && is$1(sortItem.SortBy.node, "ColumnRef")) {
+				const sortColumnName = getLastColumnRefField(sortItem.SortBy.node);
+				if (!(sortColumnName !== null && whereHasIsNotNull(node.SelectStmt.whereClause, sortColumnName))) nudges.push({
+					kind: "NULLS_FIRST_IN_DESC_ORDER",
+					severity: "INFO",
+					message: "ORDER BY … DESC sorts NULLs first — add NULLS LAST to push them to the end",
+					location: sortItem.SortBy.node.ColumnRef.location
+				});
+			}
+		}
+	}
+	if (is$1(node, "A_Expr")) {
+		const isEqualityOp = node.A_Expr.kind === "AEXPR_OP" && node.A_Expr.name && node.A_Expr.name.length > 0 && is$1(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",
+				location: node.A_Expr.location
+			});
+		}
+		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("%")) {
+				let stringNode;
+				if (is$1(node.A_Expr.rexpr, "A_Const")) stringNode = node.A_Expr.rexpr.A_Const;
+				nudges.push({
+					kind: "AVOID_LEADING_WILDCARD_LIKE",
+					severity: "WARNING",
+					message: "Leading wildcard in LIKE/ILIKE prevents index usage — consider a GIN trigram index (pg_trgm) or full-text search",
+					location: stringNode?.location
+				});
+			}
+		}
+		if (isEqualityOp === false && isLikeOp === false) {
+			const gistOpName = node.A_Expr.kind === "AEXPR_OP" && node.A_Expr.name?.[0] && is$1(node.A_Expr.name[0], "String") && node.A_Expr.name[0].String.sval;
+			if (gistOpName && GIST_OPERATORS.has(gistOpName)) nudges.push({
+				kind: "CONSIDER_GIST_INDEX",
+				severity: "INFO",
+				message: `Operator "${gistOpName}" benefits from a GiST index for efficient execution`,
+				location: node.A_Expr.location
+			});
+		}
+	}
+	if (is$1(node, "SelectStmt") && node.SelectStmt.sortClause) {
+		for (const sortItem of node.SelectStmt.sortClause) if (is$1(sortItem, "SortBy") && sortItem.SortBy.node && is$1(sortItem.SortBy.node, "FuncCall") && sortItem.SortBy.node.FuncCall.funcname?.some((name) => is$1(name, "String") && name.String.sval === "random")) nudges.push({
+			kind: "AVOID_ORDER_BY_RANDOM",
+			severity: "WARNING",
+			message: "Avoid using ORDER BY random()",
+			location: sortItem.SortBy.node.FuncCall.location
+		});
+	}
+	if (is$1(node, "SelectStmt") && node.SelectStmt.distinctClause) nudges.push({
+		kind: "AVOID_DISTINCT_WITHOUT_REASON",
+		severity: "WARNING",
+		message: "Avoid using DISTINCT without a reason"
+	});
+	if (is$1(node, "SelectStmt") && node.SelectStmt.limitOffset) {
+		const offsetNode = node.SelectStmt.limitOffset;
+		const location = isANode$1(offsetNode) && is$1(offsetNode, "A_Const") ? offsetNode.A_Const.location : void 0;
+		nudges.push({
+			kind: "AVOID_OFFSET_FOR_PAGINATION",
+			severity: "INFO",
+			message: "Avoid using OFFSET for pagination",
+			location
+		});
+	}
+	if (is$1(node, "JoinExpr")) {
+		if (!node.JoinExpr.quals) nudges.push({
+			kind: "MISSING_JOIN_CONDITION",
+			severity: "WARNING",
+			message: "Missing JOIN condition"
+		});
+	}
+	if (is$1(node, "SelectStmt") && node.SelectStmt.fromClause && node.SelectStmt.fromClause.length > 1) {
+		const tables = node.SelectStmt.fromClause.filter((item) => is$1(item, "RangeVar"));
+		if (tables.length > 1) nudges.push({
+			kind: "MISSING_JOIN_CONDITION",
+			severity: "WARNING",
+			message: "Missing JOIN condition",
+			location: tables[1].RangeVar.location
+		});
+	}
+	if (is$1(node, "BoolExpr") && node.BoolExpr.boolop === "OR_EXPR") {
+		if (countBoolOrConditions(node) >= 3) nudges.push({
+			kind: "CONSIDER_IN_INSTEAD_OF_MANY_ORS",
+			severity: "WARNING",
+			message: "Consider using IN instead of many ORs",
+			location: node.BoolExpr.location
+		});
+	}
+	if (is$1(node, "BoolExpr") && node.BoolExpr.boolop === "NOT_EXPR") {
+		const args = node.BoolExpr.args;
+		if (args && args.length === 1) {
+			const inner = args[0];
+			if (isANode$1(inner) && is$1(inner, "SubLink") && inner.SubLink.subLinkType === "ANY_SUBLINK") nudges.push({
+				kind: "PREFER_NOT_EXISTS_OVER_NOT_IN",
+				severity: "WARNING",
+				message: "Prefer NOT EXISTS over NOT IN (SELECT ...)",
+				location: inner.SubLink.location
+			});
+		}
+	}
+	if (is$1(node, "SelectStmt") && node.SelectStmt.havingClause) {
+		if (!containsAggregate(node.SelectStmt.havingClause)) {
+			const having = node.SelectStmt.havingClause;
+			let location;
+			if (is$1(having, "A_Expr")) location = having.A_Expr.location;
+			else if (is$1(having, "BoolExpr")) location = having.BoolExpr.location;
+			nudges.push({
+				kind: "PREFER_WHERE_OVER_HAVING_FOR_NON_AGGREGATES",
+				severity: "INFO",
+				message: "Non-aggregate condition in HAVING should be in WHERE",
+				location
+			});
+		}
+	}
+	if (is$1(node, "FuncCall")) {
+		const funcName = node.FuncCall.funcname;
+		if (funcName && funcName.length === 1 && is$1(funcName[0], "String") && funcName[0].String.sval === "count" && node.FuncCall.args && !node.FuncCall.agg_star && !node.FuncCall.agg_distinct) nudges.push({
+			kind: "PREFER_COUNT_STAR_OVER_COUNT_COLUMN",
+			severity: "INFO",
+			message: "Prefer COUNT(*) over COUNT(column) or COUNT(1) — COUNT(*) counts rows without checking for NULLs. If you need to count non-NULL values, COUNT(column) is correct.",
+			location: node.FuncCall.location
+		});
+	}
+	if (is$1(node, "A_Expr") && node.A_Expr.kind === "AEXPR_OP" && node.A_Expr.name && node.A_Expr.name.length > 0) {
+		const opNode = node.A_Expr.name[0];
+		const op = is$1(opNode, "String") ? opNode.String.sval : null;
+		if (op && isExistenceCheckPattern(node.A_Expr.lexpr, node.A_Expr.rexpr, op)) nudges.push({
+			kind: "USE_EXISTS_NOT_COUNT_FOR_EXISTENCE_CHECK",
+			severity: "INFO",
+			message: "Use EXISTS instead of COUNT for existence checks",
+			location: node.A_Expr.location
+		});
+	}
+	if (is$1(node, "FuncCall")) {
+		const funcname = node.FuncCall.funcname?.[0] && is$1(node.FuncCall.funcname[0], "String") && node.FuncCall.funcname[0].String.sval;
+		if (funcname && [
+			"sum",
+			"count",
+			"avg",
+			"min",
+			"max"
+		].includes(funcname.toLowerCase())) {
+			const firstArg = node.FuncCall.args?.[0];
+			if (firstArg && isANode$1(firstArg) && is$1(firstArg, "CaseExpr")) {
+				const caseExpr = firstArg.CaseExpr;
+				if (caseExpr.args && caseExpr.args.length === 1) {
+					const defresult = caseExpr.defresult;
+					if (!defresult || isANode$1(defresult) && is$1(defresult, "A_Const") && (defresult.A_Const.isnull !== void 0 || defresult.A_Const.ival !== void 0 && (defresult.A_Const.ival.ival === 0 || defresult.A_Const.ival.ival === void 0))) nudges.push({
+						kind: "PREFER_FILTER_OVER_CASE_IN_AGGREGATE",
+						severity: "INFO",
+						message: "Use FILTER (WHERE ...) instead of CASE inside aggregate functions",
+						location: node.FuncCall.location
+					});
+				}
+			}
+		}
+	}
+	if (is$1(node, "FuncCall") && node.FuncCall.funcname) {
+		const lastNameNode = node.FuncCall.funcname[node.FuncCall.funcname.length - 1];
+		if (lastNameNode && is$1(lastNameNode, "String") && lastNameNode.String.sval) {
+			const funcName = lastNameNode.String.sval.toLowerCase();
+			if (SPATIAL_FUNCTIONS.has(funcName)) nudges.push({
+				kind: "CONSIDER_GIST_INDEX",
+				severity: "INFO",
+				message: `Spatial function "${lastNameNode.String.sval}" benefits from a GiST index for efficient execution`,
+				location: node.FuncCall.location
+			});
+		}
+	}
+	if (is$1(node, "BoolExpr") && node.BoolExpr.boolop === "NOT_EXPR") {
+		const args = node.BoolExpr.args;
+		if (args && args.length === 1) {
+			const arg = args[0];
+			if (isANode$1(arg) && is$1(arg, "SubLink") && arg.SubLink.subLinkType === "EXISTS_SUBLINK" && arg.SubLink.subselect) {
+				const subselect = arg.SubLink.subselect;
+				if (isANode$1(subselect) && is$1(subselect, "SelectStmt") && subselect.SelectStmt.whereClause) {
+					const where = subselect.SelectStmt.whereClause;
+					if (isANode$1(where) && is$1(where, "BoolExpr") && where.BoolExpr.boolop === "OR_EXPR") nudges.push({
+						kind: "FLATTEN_NOT_EXISTS_OR",
+						severity: "INFO",
+						message: "Consider splitting NOT EXISTS with OR into separate NOT EXISTS joined by AND",
+						location: node.BoolExpr.location
+					});
+				}
+			}
+		}
+	}
+	if (is$1(node, "A_Expr")) {
+		if (node.A_Expr.kind === "AEXPR_IN") {
+			let list;
+			if (node.A_Expr.lexpr && is$1(node.A_Expr.lexpr, "List")) list = node.A_Expr.lexpr.List;
+			else if (node.A_Expr.rexpr && is$1(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",
+				location: node.A_Expr.location
+			});
+		}
+	}
+	if (is$1(node, "SelectStmt") && node.SelectStmt.op === "SETOP_UNION" && !node.SelectStmt.all) nudges.push({
+		kind: "PREFER_UNION_ALL_OVER_UNION",
+		severity: "INFO",
+		message: "UNION removes duplicates with an implicit sort — use UNION ALL if deduplication is not needed"
+	});
+	if (is$1(node, "SelectStmt")) {
+		const subqueryAliases = /* @__PURE__ */ new Set();
+		if (node.SelectStmt.targetList) {
+			for (const target of node.SelectStmt.targetList) if (is$1(target, "ResTarget")) {
+				if (target.ResTarget.val && is$1(target.ResTarget.val, "SubLink")) {
+					if (target.ResTarget.name) subqueryAliases.add(target.ResTarget.name.toLowerCase());
+				}
+			}
+		}
+		if (subqueryAliases.size > 0 && node.SelectStmt.sortClause) {
+			for (const sortBy of node.SelectStmt.sortClause) if (is$1(sortBy, "SortBy") && sortBy.SortBy.node) {
+				if (is$1(sortBy.SortBy.node, "ColumnRef")) {
+					const columnName = extractColumnName(sortBy.SortBy.node);
+					if (columnName && subqueryAliases.has(columnName.toLowerCase())) {
+						nudges.push({
+							kind: "AVOID_SORTING_ON_GENERATED_VALUES",
+							severity: "WARNING",
+							message: "Be careful sorting on values generated dynamically during query execution - these cannot use indexes and contribute to slower query performance."
+						});
+						break;
+					}
+				}
+			}
+		}
+	}
+	return nudges;
 }
 function containsColumnRef(args) {
-  for (const arg of args) {
-    if (hasColumnRefInNode(arg)) {
-      return true;
-    }
-  }
-  return false;
+	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;
+	if (isANode$1(node) && is$1(node, "ColumnRef")) return true;
+	if (typeof node !== "object" || node === null) return false;
+	if (Array.isArray(node)) return node.some((item) => hasColumnRefInNode(item));
+	if (isANode$1(node)) return hasColumnRefInNode(node[Object.keys(node)[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;
+	if (joinExpr.JoinExpr.larg && is$1(joinExpr.JoinExpr.larg, "RangeVar")) return true;
+	if (joinExpr.JoinExpr.larg && is$1(joinExpr.JoinExpr.larg, "JoinExpr")) {
+		if (hasActualTablesInJoin(joinExpr.JoinExpr.larg)) return true;
+	}
+	if (joinExpr.JoinExpr.rarg && is$1(joinExpr.JoinExpr.rarg, "RangeVar")) return true;
+	if (joinExpr.JoinExpr.rarg && is$1(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;
+	if (!node || typeof node !== "object") return false;
+	if (isANode$1(node) && is$1(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;
+	if (!node || typeof node !== "object") return null;
+	if (isANode$1(node) && is$1(node, "A_Const") && node.A_Const.sval) return node.A_Const.sval.sval || null;
+	return null;
+}
+const AGGREGATE_FUNCTIONS = new Set([
+	"count",
+	"sum",
+	"avg",
+	"min",
+	"max",
+	"array_agg",
+	"string_agg",
+	"bool_and",
+	"bool_or",
+	"every"
+]);
+function containsAggregate(node) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) return node.some(containsAggregate);
+	if (isANode$1(node) && is$1(node, "FuncCall")) {
+		const funcname = node.FuncCall.funcname;
+		if (funcname) {
+			for (const f of funcname) if (isANode$1(f) && is$1(f, "String") && AGGREGATE_FUNCTIONS.has(f.String.sval?.toLowerCase() ?? "")) return true;
+		}
+	}
+	if (isANode$1(node)) return containsAggregate(node[Object.keys(node)[0]]);
+	for (const child of Object.values(node)) if (containsAggregate(child)) return true;
+	return false;
+}
+function getLastColumnRefField(columnRef) {
+	const fields = columnRef.ColumnRef.fields;
+	if (!fields || fields.length === 0) return null;
+	const lastField = fields[fields.length - 1];
+	if (isANode$1(lastField) && is$1(lastField, "String")) return lastField.String.sval || null;
+	return null;
+}
+function whereHasIsNotNull(whereClause, columnName) {
+	if (!whereClause) return false;
+	let found = false;
+	Walker.shallowMatch(whereClause, "NullTest", (node) => {
+		if (node.NullTest.nulltesttype === "IS_NOT_NULL" && node.NullTest.arg && is$1(node.NullTest.arg, "ColumnRef")) {
+			if (getLastColumnRefField(node.NullTest.arg) === columnName) found = true;
+		}
+	});
+	return found;
+}
+function isCountFuncCall(node) {
+	if (!node || typeof node !== "object") return false;
+	if (!isANode$1(node) || !is$1(node, "FuncCall")) return false;
+	const fc = node.FuncCall;
+	if (!(fc.funcname?.some((n) => is$1(n, "String") && n.String.sval === "count") ?? false)) return false;
+	if (fc.agg_star) return true;
+	if (fc.args && fc.args.length === 1 && isANode$1(fc.args[0]) && is$1(fc.args[0], "A_Const")) return true;
+	return false;
+}
+function isSubLinkWithCount(node) {
+	if (!node || typeof node !== "object") return false;
+	if (!isANode$1(node) || !is$1(node, "SubLink")) return false;
+	const subselect = node.SubLink.subselect;
+	if (!subselect || !isANode$1(subselect) || !is$1(subselect, "SelectStmt")) return false;
+	const targets = subselect.SelectStmt.targetList;
+	if (!targets || targets.length !== 1) return false;
+	const target = targets[0];
+	if (!isANode$1(target) || !is$1(target, "ResTarget") || !target.ResTarget.val) return false;
+	return isCountFuncCall(target.ResTarget.val);
+}
+function isCountExpression(node) {
+	return isCountFuncCall(node) || isSubLinkWithCount(node);
+}
+function getIntegerConstantValue(node) {
+	if (!node || typeof node !== "object") return null;
+	if (!isANode$1(node) || !is$1(node, "A_Const")) return null;
+	if (node.A_Const.ival === void 0) return null;
+	return node.A_Const.ival.ival ?? 0;
+}
+function isExistenceCheckPattern(lexpr, rexpr, op) {
+	if (isCountExpression(lexpr)) {
+		const val = getIntegerConstantValue(rexpr);
+		if (val !== null) {
+			if (op === ">" && val === 0) return true;
+			if (op === ">=" && val === 1) return true;
+			if ((op === "!=" || op === "<>") && val === 0) return true;
+		}
+	}
+	if (isCountExpression(rexpr)) {
+		const val = getIntegerConstantValue(lexpr);
+		if (val !== null) {
+			if (op === "<" && val === 0) return true;
+			if (op === "<=" && val === 1) return true;
+			if ((op === "!=" || op === "<>") && val === 0) return true;
+		}
+	}
+	return false;
+}
+function collectEqualityConstrainedColumns(whereClause) {
+	const columns = /* @__PURE__ */ new Set();
+	function walk(node) {
+		if (!node || typeof node !== "object") return;
+		if (!isANode$1(node)) return;
+		if (is$1(node, "BoolExpr") && node.BoolExpr.boolop === "AND_EXPR" && node.BoolExpr.args) {
+			for (const arg of node.BoolExpr.args) walk(arg);
+			return;
+		}
+		if (is$1(node, "A_Expr") && node.A_Expr.kind === "AEXPR_OP") {
+			const opName = node.A_Expr.name?.[0];
+			if (opName && is$1(opName, "String") && opName.String.sval === "=") {
+				addColumnIfConstant(node.A_Expr.lexpr, node.A_Expr.rexpr, columns);
+				addColumnIfConstant(node.A_Expr.rexpr, node.A_Expr.lexpr, columns);
+			}
+			return;
+		}
+		if (is$1(node, "A_Expr") && node.A_Expr.kind === "AEXPR_IN") {
+			const listNode = node.A_Expr.rexpr;
+			if (listNode && isANode$1(listNode) && is$1(listNode, "List") && listNode.List.items && listNode.List.items.length === 1) {
+				const colNode = node.A_Expr.lexpr;
+				if (colNode && isANode$1(colNode) && is$1(colNode, "ColumnRef")) {
+					const lastField = colNode.ColumnRef.fields?.[colNode.ColumnRef.fields.length - 1];
+					if (lastField && is$1(lastField, "String") && lastField.String.sval) columns.add(lastField.String.sval);
+				}
+			}
+		}
+	}
+	walk(whereClause);
+	return columns;
+}
+function addColumnIfConstant(colSide, constSide, columns) {
+	if (!colSide || !constSide || typeof colSide !== "object" || typeof constSide !== "object") return;
+	if (!isANode$1(colSide) || !is$1(colSide, "ColumnRef")) return;
+	if (!isANode$1(constSide) || !is$1(constSide, "A_Const") && !is$1(constSide, "ParamRef")) return;
+	const fields = colSide.ColumnRef.fields;
+	if (!fields || fields.length === 0) return;
+	const lastField = fields[fields.length - 1];
+	if (is$1(lastField, "String") && lastField.String.sval) columns.add(lastField.String.sval);
+}
+function extractColumnName(node) {
+	if (!node.ColumnRef.fields || node.ColumnRef.fields.length === 0) return null;
+	const lastField = node.ColumnRef.fields[node.ColumnRef.fields.length - 1];
+	if (is$1(lastField, "String") && lastField.String.sval) return lastField.String.sval;
+	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;
+	if (node.BoolExpr.boolop !== "OR_EXPR" || !node.BoolExpr.args) return 1;
+	let count = 0;
+	for (const arg of node.BoolExpr.args) if (isANode$1(arg) && is$1(arg, "BoolExpr") && arg.BoolExpr.boolop === "OR_EXPR") count += countBoolOrConditions(arg);
+	else count += 1;
+	return count;
+}
+/**
+* Extract the major version number from a PostgreSQL version string.
+* PostgreSQL encodes versions as XXYYZZ where XX is major, YY is minor, ZZ is patch.
+* e.g. "170000" → 17, "160004" → 16, "120000" → 12
+*/
+function parseMajorVersion(versionNum) {
+	return Math.floor(parseInt(versionNum, 10) / 1e4);
+}
+/**
+* Produce version-aware nudges by checking existing nudges against the
+* user's PostgreSQL major version. Returns upgrade recommendations
+* when a query pattern would benefit from a newer version.
+*/
+function parseVersionNudges(nudges, majorVersion) {
+	const versionNudges = [];
+	if (majorVersion < 17 && nudges.some((n) => n.kind === "AVOID_DISTINCT_WITHOUT_REASON")) versionNudges.push({
+		kind: "UPGRADE_DISTINCT_PG17",
+		severity: "INFO",
+		message: "PostgreSQL 17 introduces hash-based DISTINCT, which can significantly speed up queries using DISTINCT"
+	});
+	return versionNudges;
 }
 
-// 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, "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 = (0, import_pgsql_deparser.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);
-      }
-    }
-  }
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/sql/walker.ts
+/**
+* Walks the AST of a sql query and extracts query metadata.
+* This pattern is used to segregate the mutable state that's more common for the
+* AST walking process from the rest of the analyzer.
+*/
+var Walker = class Walker {
+	constructor(query) {
+		this.query = query;
+		_defineProperty(this, "tableMappings", /* @__PURE__ */ new Map());
+		_defineProperty(this, "tempTables", /* @__PURE__ */ new Set());
+		_defineProperty(this, "highlights", []);
+		_defineProperty(this, "indexRepresentations", /* @__PURE__ */ new Set());
+		_defineProperty(this, "indexesToCheck", []);
+		_defineProperty(this, "highlightPositions", /* @__PURE__ */ new Set());
+		_defineProperty(this, "seenReferences", /* @__PURE__ */ new Map());
+		_defineProperty(this, "shadowedAliases", []);
+		_defineProperty(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 (is(node, "CommonTableExpr")) {
+				if (node.CommonTableExpr.ctename) this.tempTables.add(node.CommonTableExpr.ctename);
+			}
+			if (is(node, "RangeSubselect")) {
+				if (node.RangeSubselect.alias?.aliasname) this.tempTables.add(node.RangeSubselect.alias.aliasname);
+			}
+			if (is(node, "NullTest")) {
+				if (node.NullTest.arg && node.NullTest.nulltesttype && is(node.NullTest.arg, "ColumnRef")) this.add(node.NullTest.arg, { where: { nulltest: node.NullTest.nulltesttype } });
+			}
+			if (is(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,
+						quoted: true,
+						alias: aliasName
+					};
+					if (node.RangeVar.schemaname) part.schema = node.RangeVar.schemaname;
+					if (existingMapping) {
+						if (!(node.RangeVar.relname?.startsWith("pg_") ?? false)) 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 (is(node, "SortBy")) {
+				if (node.SortBy.node && is(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 (is(node, "JoinExpr") && node.JoinExpr.quals) {
+				if (is(node.JoinExpr.quals, "A_Expr")) {
+					if (node.JoinExpr.quals.A_Expr.lexpr && is(node.JoinExpr.quals.A_Expr.lexpr, "ColumnRef")) this.add(node.JoinExpr.quals.A_Expr.lexpr);
+					if (node.JoinExpr.quals.A_Expr.rexpr && is(node.JoinExpr.quals.A_Expr.rexpr, "ColumnRef")) this.add(node.JoinExpr.quals.A_Expr.rexpr);
+				}
+			}
+			if (is(node, "A_Expr") && node.A_Expr.kind === "AEXPR_OP") {
+				const opName = node.A_Expr.name?.[0] && is(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 && is(node.A_Expr.lexpr, "ColumnRef")) this.add(node.A_Expr.lexpr, { jsonbOperator });
+					if (node.A_Expr.rexpr && is(node.A_Expr.rexpr, "ColumnRef")) this.add(node.A_Expr.rexpr, { jsonbOperator });
+				}
+				if (opName && (opName === "&&" || opName === "-|-")) {
+					const gistOperator = opName;
+					if (node.A_Expr.lexpr && is(node.A_Expr.lexpr, "ColumnRef")) this.add(node.A_Expr.lexpr, { gistOperator });
+					if (node.A_Expr.rexpr && is(node.A_Expr.rexpr, "ColumnRef")) this.add(node.A_Expr.rexpr, { gistOperator });
+				}
+			}
+			if (is(node, "ColumnRef")) {
+				for (let i = 0; i < stack.length; i++) {
+					if (stack[i] === "returningList" && stack[i + 1] === "ResTarget" && stack[i + 2] === "val" && stack[i + 3] === "ColumnRef") {
+						this.add(node, { ignored: true });
+						return;
+					}
+					if (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 (!is(field, "String") || !field.String.sval) {
+				const out = (0, pgsql_deparser.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) {
+				if (this.query[runningLength] === "\"") 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;
+		if (options?.gistOperator) ref.gistOperator = options.gistOperator;
+		this.highlights.push(ref);
+	}
+	/**
+	* Descend only into shallow combinators of a node such as
+	* - And
+	* - Or
+	* - Not
+	* - ::typecast
+	* without deep traversing into subqueries. Useful for checking members
+	* of a `WHERE` clause
+	*/
+	static shallowMatch(expr, kind, callback) {
+		if (is(expr, kind)) {
+			callback(expr);
+			return;
+		}
+		if (is(expr, "BoolExpr") && expr.BoolExpr.args) {
+			for (const arg of expr.BoolExpr.args) Walker.shallowMatch(arg, kind, callback);
+			return;
+		}
+		if (is(expr, "A_Expr")) {
+			if (expr.A_Expr.lexpr) Walker.shallowMatch(expr.A_Expr.lexpr, kind, callback);
+			if (expr.A_Expr.rexpr) Walker.shallowMatch(expr.A_Expr.rexpr, kind, callback);
+			return;
+		}
+		if (is(expr, "NullTest") && expr.NullTest.arg) {
+			Walker.shallowMatch(expr.NullTest.arg, kind, callback);
+			return;
+		}
+		if (is(expr, "BooleanTest") && expr.BooleanTest.arg) {
+			Walker.shallowMatch(expr.BooleanTest.arg, kind, callback);
+			return;
+		}
+		if (is(expr, "SubLink") && expr.SubLink.testexpr) {
+			Walker.shallowMatch(expr.SubLink.testexpr, kind, callback);
+			return;
+		}
+		if (is(expr, "TypeCast") && expr.TypeCast.arg) {
+			Walker.shallowMatch(expr.TypeCast.arg, kind, callback);
+			return;
+		}
+	}
+	static traverse(node, callback) {
+		Walker.doTraverse(node, [], callback);
+	}
+	static doTraverse(node, stack, callback) {
+		if (isANode(node)) callback(node, [...stack, getNodeKind(node)]);
+		if (typeof node !== "object" || node === null) return;
+		if (Array.isArray(node)) {
+			for (const item of node) if (isANode(item)) Walker.doTraverse(item, stack, callback);
+		} else if (isANode(node)) {
+			const keys = Object.keys(node);
+			Walker.doTraverse(node[keys[0]], [...stack, getNodeKind(node)], callback);
+		} else for (const [key, child] of Object.entries(node)) Walker.doTraverse(child, [...stack, key], callback);
+	}
 };
-function is2(node, kind) {
-  return kind in node;
+function is(node, kind) {
+	return kind in node;
 }
 function getNodeKind(node) {
-  const keys = Object.keys(node);
-  return keys[0];
+	return Object.keys(node)[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]);
+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]);
 }
 
-// src/sql/analyzer.ts
-var ignoredIdentifier = "__qd_placeholder";
+//#endregion
+//#region src/sql/analyzer.ts
+const ignoredIdentifier = "__qd_placeholder";
+/**
+* Analyzes a query and returns a list of column references that
+* should be indexed.
+*
+* This should be instantiated once per analyzed query.
+*/
 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) => (0, import_colorette.dim)((0, import_colorette.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 = import_colorette.blue;
-        skip = true;
-      } else {
-        color = import_colorette.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;
-          }
-          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;
-          }
-          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;
-  }
-  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 };
-  }
+	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 { highlights, indexRepresentations, indexesToCheck, shadowedAliases, tempTables, tableMappings, nudges } = new Walker(query).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) => (0, colorette.dim)((0, colorette.strikethrough)(x));
+				skip = true;
+			} else if (parts.length === 2 && tempTables.has(parts[0].text) && !tableMappings.has(parts[0].text)) {
+				color = colorette.blue;
+				skip = true;
+			} else color = colorette.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) {
+		/**
+		* There are 3 different kinds of parts a col reference can have
+		* {a} = just a column within context. Find out the table
+		* {a, b} = a column reference with a table reference. There's still ambiguity here
+		* with what the schema could be in case there are 2 tables with the same name in different schemas.
+		* {a, b, c} = a column reference with a table reference and a schema reference.
+		* This is the best case scenario.
+		*/
+		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;
+					if (colReference.gistOperator) index.gistOperator = colReference.gistOperator;
+					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;
+					if (colReference.gistOperator) index.gistOperator = colReference.gistOperator;
+					addIndex(index);
+				}
+			} else if (fullReference) {
+				const [schema, table, column] = colReference.parts;
+				const index = {
+					schema: this.normalize(schema),
+					table: this.normalize(table),
+					column: this.normalize(column)
+				};
+				if (colReference.sort) index.sort = colReference.sort;
+				if (colReference.where) index.where = colReference.where;
+				if (colReference.jsonbOperator) index.jsonbOperator = colReference.jsonbOperator;
+				if (colReference.gistOperator) index.gistOperator = colReference.gistOperator;
+				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(/(^\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 : 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
-var import_zod = require("zod");
-var PostgresVersion = import_zod.z.string().brand("PostgresVersion");
+//#endregion
+//#region src/sql/database.ts
+const PostgresVersion = zod.z.string().brand("PostgresVersion");
+/**
+* Drops a disabled index. Rollsback if it fails for any reason
+* @returns Did dropping the index succeed?
+*/
 async function dropIndex(tx, index) {
-  try {
-    await tx.exec(`
+	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;
-  }
+		return true;
+	} catch {
+		await tx.exec(`rollback to idx_drop`);
+		return false;
+	}
 }
 
-// src/sql/indexes.ts
+//#endregion
+//#region src/sql/indexes.ts
 function isIndexSupported(index) {
-  return index.index_type === "btree";
+	return index.index_type === "btree" || index.index_type === "gin" || index.index_type === "gist";
 }
+/**
+* Doesn't necessarily decide whether the index can be dropped but can be
+* used to not even try dropping indexes that _definitely_ cannot be dropped
+*/
 function isIndexProbablyDroppable(index) {
-  return !index.is_primary && !index.is_unique;
+	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;
-  }
+//#endregion
+//#region src/sql/builder.ts
+var PostgresQueryBuilder = class PostgresQueryBuilder {
+	constructor(query) {
+		this.query = query;
+		_defineProperty(this, "commands", {});
+		_defineProperty(this, "isIntrospection", false);
+		_defineProperty(this, "explainFlags", []);
+		_defineProperty(this, "_preamble", 0);
+		_defineProperty(this, "parameters", {});
+		_defineProperty(this, "limitSubstitution", void 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;
+	}
+	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};\n`;
+		}
+		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();
-  }
+//#endregion
+//#region src/sql/pg-identifier.ts
+/**
+* Represents an identifier in postgres that is subject
+* to quoting rules. The {@link toString} rule behaves
+* exactly like calling `select quote_ident($1)` in postgres
+*/
+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-z0-9_]*$/;
+		const match = identifier.match(/^"(.+)"$/);
+		if (match) {
+			const value = match[1];
+			return new PgIdentifier(value, !identifierRegex.test(value) || this.reservedKeywords.has(value.toLowerCase()));
+		}
+		return new PgIdentifier(identifier, !identifierRegex.test(identifier) || this.reservedKeywords.has(identifier.toLowerCase()));
+	}
+	/**
+	* 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"
+_defineProperty(PgIdentifier, "reservedKeywords", 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
-var import_colorette2 = require("colorette");
-
-// src/sql/permutations.ts
+//#endregion
+//#region src/sql/permutations.ts
+/**
+* Create permutations of the array while sorting it from
+* largest permutation to smallest.
+*
+* This is important when generating index permutations as
+* postgres happens to prefer indexes with the latest
+* creation date when the cost of using 2 are the same
+**/
 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;
+	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} ${(0, import_colorette2.green)(`+${deltaPercentage.toFixed(2).padStart(5, "0")}%`)}`
-      );
-    } else if (finalCost > baseCost) {
-      console.log(
-        `${(0, import_colorette2.red)(
-          `-${Math.abs(deltaPercentage).toFixed(2).padStart(5, "0")}%`
-        )} ${(0, import_colorette2.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 permutedIndexes = this.groupPotentialIndexColumnsByTable(rootCandidates);
-    const nextStage = [];
-    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
-        });
-      }
-    }
-    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(import_colorette2.green, import_colorette2.yellow, import_colorette2.magenta, import_colorette2.blue);
-    return { raw, colored };
-  }
-  /**
-   * 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;
-        }
-      }
-    });
-  }
+//#endregion
+//#region 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(` 🎉🎉🎉 ${(0, colorette.green)(`+${deltaPercentage.toFixed(2).padStart(5, "0")}%`)}`);
+		else if (finalCost > baseCost) console.log(`${(0, colorette.red)(`-${Math.abs(deltaPercentage).toFixed(2).padStart(5, "0")}%`)} ${(0, colorette.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) {
+		this.existingIndexes = f(this.existingIndexes);
+		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);
+	}
+	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) {
+				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 && !c.gistOperator);
+		const ginCandidates = rootCandidates.filter((c) => c.jsonbOperator);
+		const gistCandidates = rootCandidates.filter((c) => c.gistOperator);
+		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 columns of permutations) {
+				const schema = PgIdentifier.fromString(rawSchema);
+				const table = PgIdentifier.fromString(rawTable);
+				if (this.indexAlreadyExists(table.toString(), columns)) continue;
+				const indexName = this.indexName();
+				const definition = this.toDefinition({
+					table,
+					schema,
+					columns
+				}).raw;
+				nextStage.push({
+					name: indexName,
+					schema: schema.toString(),
+					table: table.toString(),
+					columns,
+					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 opclass = operators.some((op) => op === "?" || op === "?|" || op === "?&") ? void 0 : "jsonb_path_ops";
+			if (this.ginIndexAlreadyExists(table.toString(), column)) 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
+			});
+		}
+		const gistGroups = this.groupGistCandidatesByColumn(gistCandidates);
+		for (const group of gistGroups.values()) {
+			const { schema: rawSchema, table: rawTable, column } = group;
+			const schema = PgIdentifier.fromString(rawSchema);
+			const table = PgIdentifier.fromString(rawTable);
+			if (this.gistIndexAlreadyExists(table.toString(), column)) continue;
+			const indexName = this.indexName();
+			const candidate = {
+				schema: rawSchema,
+				table: rawTable,
+				column
+			};
+			const definition = this.toGistDefinition({
+				table,
+				schema,
+				column: PgIdentifier.fromString(column)
+			});
+			nextStage.push({
+				name: indexName,
+				schema: schema.toString(),
+				table: table.toString(),
+				columns: [candidate],
+				definition,
+				indexMethod: "gist"
+			});
+		}
+		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);
+			return `${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(", ")})`;
+		};
+		const id = (a) => a;
+		return {
+			raw: make(id, id, id, id),
+			colored: make(colorette.green, colorette.yellow, colorette.magenta, colorette.blue)
+		};
+	}
+	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})`;
+	}
+	toGistDefinition({ schema, table, column }) {
+		let fullyQualifiedTable;
+		if (schema.toString() === "public") fullyQualifiedTable = table;
+		else fullyQualifiedTable = PgIdentifier.fromParts(schema, table);
+		return `${fullyQualifiedTable} using gist (${column})`;
+	}
+	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));
+	}
+	groupGistCandidatesByColumn(candidates) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const c of candidates) {
+			if (!c.gistOperator) continue;
+			const key = `${c.schema}.${c.table}.${c.column}`;
+			if (!groups.has(key)) groups.set(key, {
+				schema: c.schema,
+				table: c.table,
+				column: c.column
+			});
+		}
+		return groups;
+	}
+	gistIndexAlreadyExists(table, column) {
+		return this.existingIndexes.find((index) => index.index_type === "gist" && 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;
+			await dropIndex(tx, PgIdentifier.fromParts(index.schema_name, index.index_name));
+		}
+	}
+	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";
+			default: return "";
+		}
+	}
+	sortDirection(s) {
+		if (!s.dir) return "";
+		switch (s.dir) {
+			case "SORTBY_DESC": return "desc";
+			case "SORTBY_ASC": return "asc";
+			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 explain = (await tx.exec(query, options?.params))[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;
+_defineProperty(IndexOptimizer, "prefix", "__qd_");
 function walkExplain(explain, f) {
-  function go(plan) {
-    f(plan);
-    if (plan.Plans) {
-      for (const p of plan.Plans) {
-        go(p);
-      }
-    }
-  }
-  go(explain);
+	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;
-  }
+	constructor(value) {
+		this.value = value;
+	}
 };
-var PROCEED = Symbol("PROCEED");
-var SKIP = Symbol("SKIP");
+const PROCEED = Symbol("PROCEED");
+const SKIP = Symbol("SKIP");
 
-// src/optimizer/statistics.ts
-var import_colorette3 = require("colorette");
-var import_dedent = __toESM(require("dedent"), 1);
-var import_zod2 = require("zod");
-var StatisticsSource = import_zod2.z.union([
-  import_zod2.z.object({
-    kind: import_zod2.z.literal("path"),
-    path: import_zod2.z.string().min(1)
-  }),
-  import_zod2.z.object({
-    kind: import_zod2.z.literal("inline")
-  })
-]);
-var ExportedStatsStatistics = import_zod2.z.object({
-  stawidth: import_zod2.z.number(),
-  stainherit: import_zod2.z.boolean().default(false),
-  // 0 representing unknown
-  stadistinct: import_zod2.z.number(),
-  // this has no "nullable" state
-  stanullfrac: import_zod2.z.number(),
-  stakind1: import_zod2.z.number().min(0),
-  stakind2: import_zod2.z.number().min(0),
-  stakind3: import_zod2.z.number().min(0),
-  stakind4: import_zod2.z.number().min(0),
-  stakind5: import_zod2.z.number().min(0),
-  staop1: import_zod2.z.string(),
-  staop2: import_zod2.z.string(),
-  staop3: import_zod2.z.string(),
-  staop4: import_zod2.z.string(),
-  staop5: import_zod2.z.string(),
-  stacoll1: import_zod2.z.string(),
-  stacoll2: import_zod2.z.string(),
-  stacoll3: import_zod2.z.string(),
-  stacoll4: import_zod2.z.string(),
-  stacoll5: import_zod2.z.string(),
-  stanumbers1: import_zod2.z.array(import_zod2.z.number()).nullable(),
-  stanumbers2: import_zod2.z.array(import_zod2.z.number()).nullable(),
-  stanumbers3: import_zod2.z.array(import_zod2.z.number()).nullable(),
-  stanumbers4: import_zod2.z.array(import_zod2.z.number()).nullable(),
-  stanumbers5: import_zod2.z.array(import_zod2.z.number()).nullable(),
-  // theoretically... this could only be strings and numbers
-  // but we don't have a crystal ball
-  stavalues1: import_zod2.z.array(import_zod2.z.any()).nullable(),
-  stavalues2: import_zod2.z.array(import_zod2.z.any()).nullable(),
-  stavalues3: import_zod2.z.array(import_zod2.z.any()).nullable(),
-  stavalues4: import_zod2.z.array(import_zod2.z.any()).nullable(),
-  stavalues5: import_zod2.z.array(import_zod2.z.any()).nullable()
+//#endregion
+//#region src/optimizer/statistics.ts
+const StatisticsSource = zod.z.union([zod.z.object({
+	kind: zod.z.literal("path"),
+	path: zod.z.string().min(1)
+}), zod.z.object({ kind: zod.z.literal("inline") })]);
+const ExportedStatsStatistics = zod.z.object({
+	stawidth: zod.z.number(),
+	stainherit: zod.z.boolean().default(false),
+	stadistinct: zod.z.number(),
+	stanullfrac: zod.z.number(),
+	stakind1: zod.z.number().min(0),
+	stakind2: zod.z.number().min(0),
+	stakind3: zod.z.number().min(0),
+	stakind4: zod.z.number().min(0),
+	stakind5: zod.z.number().min(0),
+	staop1: zod.z.string(),
+	staop2: zod.z.string(),
+	staop3: zod.z.string(),
+	staop4: zod.z.string(),
+	staop5: zod.z.string(),
+	stacoll1: zod.z.string(),
+	stacoll2: zod.z.string(),
+	stacoll3: zod.z.string(),
+	stacoll4: zod.z.string(),
+	stacoll5: zod.z.string(),
+	stanumbers1: zod.z.array(zod.z.number()).nullable(),
+	stanumbers2: zod.z.array(zod.z.number()).nullable(),
+	stanumbers3: zod.z.array(zod.z.number()).nullable(),
+	stanumbers4: zod.z.array(zod.z.number()).nullable(),
+	stanumbers5: zod.z.array(zod.z.number()).nullable(),
+	stavalues1: zod.z.array(zod.z.any()).nullable(),
+	stavalues2: zod.z.array(zod.z.any()).nullable(),
+	stavalues3: zod.z.array(zod.z.any()).nullable(),
+	stavalues4: zod.z.array(zod.z.any()).nullable(),
+	stavalues5: zod.z.array(zod.z.any()).nullable()
 });
-var ExportedStatsColumns = import_zod2.z.object({
-  columnName: import_zod2.z.string(),
-  stats: ExportedStatsStatistics.nullable()
+const ExportedStatsColumns = zod.z.object({
+	columnName: zod.z.string(),
+	stats: ExportedStatsStatistics.nullable()
 });
-var ExportedStatsIndex = import_zod2.z.object({
-  indexName: import_zod2.z.string(),
-  relpages: import_zod2.z.number(),
-  reltuples: import_zod2.z.number(),
-  relallvisible: import_zod2.z.number(),
-  relallfrozen: import_zod2.z.number().optional()
+const ExportedStatsIndex = zod.z.object({
+	indexName: zod.z.string(),
+	relpages: zod.z.number(),
+	reltuples: zod.z.number(),
+	relallvisible: zod.z.number(),
+	relallfrozen: zod.z.number().optional()
 });
-var ExportedStatsV1 = import_zod2.z.object({
-  tableName: import_zod2.z.string(),
-  schemaName: import_zod2.z.string(),
-  // can be negative
-  relpages: import_zod2.z.number(),
-  // can be negative
-  reltuples: import_zod2.z.number(),
-  relallvisible: import_zod2.z.number(),
-  // only postgres 18+
-  relallfrozen: import_zod2.z.number().optional(),
-  columns: import_zod2.z.array(ExportedStatsColumns).nullable(),
-  indexes: import_zod2.z.array(ExportedStatsIndex)
+const ExportedStatsV1 = zod.z.object({
+	tableName: zod.z.string(),
+	schemaName: zod.z.string(),
+	relpages: zod.z.number(),
+	reltuples: zod.z.number(),
+	relallvisible: zod.z.number(),
+	relallfrozen: zod.z.number().optional(),
+	columns: zod.z.array(ExportedStatsColumns).nullable(),
+	indexes: zod.z.array(ExportedStatsIndex)
 });
-var ExportedStats = import_zod2.z.union([ExportedStatsV1]);
-var StatisticsMode = import_zod2.z.discriminatedUnion("kind", [
-  import_zod2.z.object({
-    kind: import_zod2.z.literal("fromAssumption"),
-    reltuples: import_zod2.z.number().min(0),
-    relpages: import_zod2.z.number().min(0)
-  }),
-  import_zod2.z.object({
-    kind: import_zod2.z.literal("fromStatisticsExport"),
-    stats: import_zod2.z.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";
-  }
-  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 = import_dedent.default`
+const ExportedStats = zod.z.union([ExportedStatsV1]);
+const StatisticsMode = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("fromAssumption"),
+	reltuples: zod.z.number().min(0),
+	relpages: zod.z.number().min(0)
+}), zod.z.object({
+	kind: zod.z.literal("fromStatisticsExport"),
+	stats: zod.z.array(ExportedStats),
+	source: StatisticsSource
+})]);
+const DEFAULT_RELTUPLES = 1e4;
+const DEFAULT_RELPAGES = 1;
+var Statistics = class Statistics {
+	constructor(db, postgresVersion, ownMetadata, statsMode) {
+		this.db = db;
+		this.postgresVersion = postgresVersion;
+		this.ownMetadata = ownMetadata;
+		_defineProperty(this, "mode", void 0);
+		_defineProperty(this, "exportedMetadata", void 0);
+		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();
+		return new Statistics(db, version, await Statistics.dumpStats(db, version, "full"), 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))
+					});
+				}
+			}
+			/**
+			* Postgres has 5 different slots for storing statistics per column and a potentially unlimited
+			* number of statistic types to choose from. Each code in `stakindN` can mean different things.
+			* Some statistics are just numerical values such as `n_distinct` and `correlation`, meaning
+			* they're only derived from `stanumbersN` and the value of `stanumbersN` is never read.
+			* Others take advantage of the `stavaluesN` columns which use `anyarray` type to store
+			* concrete values internally for things like histogram bounds.
+			* Unfortunately we cannot change anyarrays without a C extension.
+			*
+			* (1) = most common values
+			* (2) = scalar histogram
+			* (3) = correlation <- can change
+			* (4) = most common elements
+			* (5) = distinct elem count histogram <- can change
+			* (6) = length histogram (?) These don't appear in pg_stats
+			* (7) = bounds histogram (?) These don't appear in pg_stats
+			* (N) = potentially many more kinds of statistics. But postgres <=18 only uses these 7.
+			*
+			* What we're doing here is setting ANY statistic we cannot directly control
+			* (anything that relies on stavaluesN) to 0 to make sure the planner isn't influenced by what
+			* what the db collected from the test data.
+			* Because we do our tests with `generic_plan` it seems it's already unlikely that the planner will be
+			* using things like common values or histogram bounds to make the planning decisions we care about.
+			* This is a just in case.
+			*/
+			const sql = dedent.default`
     WITH input AS (
       SELECT
         c.oid AS starelid,
@@ -1920,65 +2336,53 @@ var _Statistics = class _Statistics {
       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 = import_dedent.default`
+			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.default`
         update pg_class p
         set reltuples = v.reltuples,
             relpages = v.relpages,
@@ -1990,48 +2394,29 @@ var _Statistics = class _Statistics {
         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 ${(0, import_colorette3.gray)(postgresVersion)}`);
-    const stats = await db.exec(
-      `
+		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]);
+		if (!(statsUpdates ? statsUpdates.length === columnStatsValues.length : true)) 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 ${(0, colorette.gray)(postgresVersion)}`);
+		return (await db.exec(`
       WITH table_columns AS (
         SELECT
           c.table_name,
@@ -2116,17 +2501,14 @@ var _Statistics = class _Statistics {
       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(`
+      `, [fullDump]))[0].json_agg;
+	}
+	/**
+	* Returns all indexes in the database.
+	* ONLY handles regular btree indexes
+	*/
+	async getExistingIndexes() {
+		return await this.db.exec(`
       WITH partitioned_tables AS (
           SELECT
               inhparent::regclass AS parent_table,
@@ -2149,14 +2531,16 @@ var _Statistics = class _Statistics {
                       CASE
                           WHEN (indoption[array_position(ix.indkey, a.attnum)] & 1) = 1 THEN 'DESC'
                           ELSE 'ASC'
-                      END)
+                      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)
+                      END,
+                      'opclass', CASE WHEN opc.opcdefault THEN NULL ELSE opc.opcname END)
               END
               ORDER BY array_position(ix.indkey, k.attnum)
           ) AS index_columns
@@ -2168,6 +2552,7 @@ var _Statistics = class _Statistics {
           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
@@ -2177,60 +2562,63 @@ var _Statistics = class _Statistics {
       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
+_defineProperty(Statistics, "defaultStatsMode", Object.freeze({
+	kind: "fromAssumption",
+	reltuples: DEFAULT_RELTUPLES,
+	relpages: DEFAULT_RELPAGES
 }));
-var Statistics = _Statistics;
 
-// src/optimizer/pss-rewriter.ts
+//#endregion
+//#region src/optimizer/pss-rewriter.ts
+/**
+* Rewriter for pg_stat_statements queries.
+* Not all queries found in pg_stat_statements can be
+* directly sent back to the database without first being rewritten.
+*/
 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()})`;
-    });
-  }
+	constructor() {
+		_defineProperty(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(" ");
+			if (!this.problematicKeywords.includes(keyword.toLowerCase())) return match;
+			return `(${parameter}::${keyword.toLowerCase()})`;
+		});
+	}
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Analyzer,
-  ExportedStats,
-  ExportedStatsColumns,
-  ExportedStatsIndex,
-  ExportedStatsStatistics,
-  ExportedStatsV1,
-  IndexOptimizer,
-  PROCEED,
-  PgIdentifier,
-  PostgresQueryBuilder,
-  PostgresVersion,
-  PssRewriter,
-  SKIP,
-  Statistics,
-  StatisticsMode,
-  StatisticsSource,
-  dropIndex,
-  ignoredIdentifier,
-  isIndexProbablyDroppable,
-  isIndexSupported,
-  parseNudges
-});
+
+//#endregion
+exports.Analyzer = Analyzer;
+exports.ExportedStats = ExportedStats;
+exports.ExportedStatsColumns = ExportedStatsColumns;
+exports.ExportedStatsIndex = ExportedStatsIndex;
+exports.ExportedStatsStatistics = ExportedStatsStatistics;
+exports.ExportedStatsV1 = ExportedStatsV1;
+exports.IndexOptimizer = IndexOptimizer;
+exports.PROCEED = PROCEED;
+exports.PgIdentifier = PgIdentifier;
+exports.PostgresQueryBuilder = PostgresQueryBuilder;
+exports.PostgresVersion = PostgresVersion;
+exports.PssRewriter = PssRewriter;
+exports.SKIP = SKIP;
+exports.Statistics = Statistics;
+exports.StatisticsMode = StatisticsMode;
+exports.StatisticsSource = StatisticsSource;
+exports.dropIndex = dropIndex;
+exports.ignoredIdentifier = ignoredIdentifier;
+exports.isIndexProbablyDroppable = isIndexProbablyDroppable;
+exports.isIndexSupported = isIndexSupported;
+exports.parseMajorVersion = parseMajorVersion;
+exports.parseNudges = parseNudges;
+exports.parseVersionNudges = parseVersionNudges;
 //# sourceMappingURL=index.cjs.map