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

package/dist/index.mjs

@@ -0,0 +1,2573 @@
+'use client'
+import { bgMagentaBright, blue, dim, gray, green, magenta, red, strikethrough, yellow } from "colorette";
+import { deparseSync } from "pgsql-deparser";
+import { z } from "zod";
+import dedent from "dedent";
+
+//#region src/sql/nudges.ts
+function is$1(node, kind) {
+	return kind in node;
+}
+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$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;
+}
+function hasColumnRefInNode(node) {
+	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$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$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$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$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;
+}
+
+//#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 = 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 is(node, kind) {
+	return kind in node;
+}
+function getNodeKind(node) {
+	return Object.keys(node)[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]);
+}
+
+//#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 { 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) => dim(strikethrough(x));
+				skip = true;
+			} else if (parts.length === 2 && tempTables.has(parts[0].text) && !tableMappings.has(parts[0].text)) {
+				color = blue;
+				skip = true;
+			} else color = bgMagentaBright;
+			const queryRepr = highlight.representation;
+			const queryBeforeMatch = currQuery.slice(0, highlight.position.start);
+			const queryAfterToken = currQuery.slice(highlight.position.end);
+			currQuery = `${queryBeforeMatch}${color(queryRepr)}${this.colorizeKeywords(queryAfterToken, color)}`;
+			if (indexRepresentations.has(queryRepr)) skip = true;
+			if (!skip) {
+				indexesToCheck.push(highlight);
+				indexRepresentations.add(queryRepr);
+			}
+		}
+		const referencedTables = [];
+		for (const value of tableMappings.values()) if (!value.alias) referencedTables.push({
+			schema: value.schema,
+			table: value.text
+		});
+		const { tags, queryWithoutTags } = this.extractSqlcommenter(query);
+		const formattedQueryWithoutTags = formattedQuery ? this.extractSqlcommenter(formattedQuery).queryWithoutTags : void 0;
+		return {
+			indexesToCheck,
+			ansiHighlightedQuery: currQuery,
+			referencedTables,
+			shadowedAliases,
+			tags,
+			queryWithoutTags,
+			formattedQueryWithoutTags,
+			nudges
+		};
+	}
+	deriveIndexes(tables, discovered, referencedTables) {
+		/**
+		* 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
+		};
+	}
+};
+
+//#endregion
+//#region src/sql/database.ts
+const PostgresVersion = 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(`
+      savepoint idx_drop;
+      drop index if exists ${index} cascade;
+    `);
+		return true;
+	} catch {
+		await tx.exec(`rollback to idx_drop`);
+		return false;
+	}
+}
+
+//#endregion
+//#region src/sql/indexes.ts
+function isIndexSupported(index) {
+	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;
+}
+
+//#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;
+	}
+};
+
+//#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();
+	}
+};
+_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"
+]));
+
+//#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;
+}
+
+//#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(` 🎉🎉🎉 ${green(`+${deltaPercentage.toFixed(2).padStart(5, "0")}%`)}`);
+		else if (finalCost > baseCost) console.log(`${red(`-${Math.abs(deltaPercentage).toFixed(2).padStart(5, "0")}%`)} ${gray("If there's a better index, we haven't tried it")}`);
+		const baseIndexes = this.findUsedIndexes(baseExplain.Plan);
+		const finalIndexes = this.findUsedIndexes(finalExplain.Plan);
+		const triedIndexes = new Map(toCreate.map((index) => [index.name.toString(), index]));
+		this.replaceUsedIndexesWithDefinition(finalExplain.Plan, triedIndexes);
+		return {
+			kind: "ok",
+			baseCost,
+			finalCost,
+			newIndexes: finalIndexes.newIndexes,
+			existingIndexes: baseIndexes.existingIndexes,
+			triedIndexes,
+			baseExplainPlan: baseExplain.Plan,
+			explainPlan: finalExplain.Plan
+		};
+	}
+	async runWithoutIndexes(builder) {
+		return await this.testQueryWithStats(builder, async (tx) => {
+			await this.dropExistingIndexes(tx);
+		});
+	}
+	/**
+	* Given the current indexes in the optimizer, transform them in some
+	* way to change which indexes will be assumed to exist when optimizing
+	*
+	* @example
+	* ```
+	* // resets indexes
+	* optimizer.transformIndexes(() => [])
+	*
+	* // adds new index
+	* optimizer.transformIndexes(indexes => [...indexes, newIndex])
+	* ```
+	*/
+	transformIndexes(f) {
+		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(green, yellow, magenta, 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;
+			}
+		});
+	}
+};
+_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);
+}
+var RollbackError = class {
+	constructor(value) {
+		this.value = value;
+	}
+};
+const PROCEED = Symbol("PROCEED");
+const SKIP = Symbol("SKIP");
+
+//#endregion
+//#region src/optimizer/statistics.ts
+const StatisticsSource = z.union([z.object({
+	kind: z.literal("path"),
+	path: z.string().min(1)
+}), z.object({ kind: z.literal("inline") })]);
+const ExportedStatsStatistics = z.object({
+	stawidth: z.number(),
+	stainherit: z.boolean().default(false),
+	stadistinct: z.number(),
+	stanullfrac: z.number(),
+	stakind1: z.number().min(0),
+	stakind2: z.number().min(0),
+	stakind3: z.number().min(0),
+	stakind4: z.number().min(0),
+	stakind5: z.number().min(0),
+	staop1: z.string(),
+	staop2: z.string(),
+	staop3: z.string(),
+	staop4: z.string(),
+	staop5: z.string(),
+	stacoll1: z.string(),
+	stacoll2: z.string(),
+	stacoll3: z.string(),
+	stacoll4: z.string(),
+	stacoll5: z.string(),
+	stanumbers1: z.array(z.number()).nullable(),
+	stanumbers2: z.array(z.number()).nullable(),
+	stanumbers3: z.array(z.number()).nullable(),
+	stanumbers4: z.array(z.number()).nullable(),
+	stanumbers5: z.array(z.number()).nullable(),
+	stavalues1: z.array(z.any()).nullable(),
+	stavalues2: z.array(z.any()).nullable(),
+	stavalues3: z.array(z.any()).nullable(),
+	stavalues4: z.array(z.any()).nullable(),
+	stavalues5: z.array(z.any()).nullable()
+});
+const ExportedStatsColumns = z.object({
+	columnName: z.string(),
+	stats: ExportedStatsStatistics.nullable()
+});
+const ExportedStatsIndex = z.object({
+	indexName: z.string(),
+	relpages: z.number(),
+	reltuples: z.number(),
+	relallvisible: z.number(),
+	relallfrozen: z.number().optional()
+});
+const ExportedStatsV1 = z.object({
+	tableName: z.string(),
+	schemaName: z.string(),
+	relpages: z.number(),
+	reltuples: z.number(),
+	relallvisible: z.number(),
+	relallfrozen: z.number().optional(),
+	columns: z.array(ExportedStatsColumns).nullable(),
+	indexes: z.array(ExportedStatsIndex)
+});
+const ExportedStats = z.union([ExportedStatsV1]);
+const StatisticsMode = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("fromAssumption"),
+	reltuples: z.number().min(0),
+	relpages: z.number().min(0)
+}), z.object({
+	kind: z.literal("fromStatisticsExport"),
+	stats: 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`
+    WITH input AS (
+      SELECT
+        c.oid AS starelid,
+        a.attnum AS staattnum,
+        v.stainherit,
+        v.stanullfrac,
+        v.stawidth,
+        v.stadistinct,
+        v.stakind1,
+        v.stakind2,
+        v.stakind3,
+        v.stakind4,
+        v.stakind5,
+        v.staop1,
+        v.staop2,
+        v.staop3,
+        v.staop4,
+        v.staop5,
+        v.stacoll1,
+        v.stacoll2,
+        v.stacoll3,
+        v.stacoll4,
+        v.stacoll5,
+        v.stanumbers1,
+        v.stanumbers2,
+        v.stanumbers3,
+        v.stanumbers4,
+        v.stanumbers5,
+        v.stavalues1,
+        v.stavalues2,
+        v.stavalues3,
+        v.stavalues4,
+        v.stavalues5,
+        _value_type1,
+        _value_type2,
+        _value_type3,
+        _value_type4,
+        _value_type5
+      FROM jsonb_to_recordset($1::jsonb) AS v(
+        schema_name text,
+        table_name text,
+        column_name text,
+        stainherit boolean,
+        stanullfrac real,
+        stawidth integer,
+        stadistinct real,
+        stakind1 real,
+        stakind2 real,
+        stakind3 real,
+        stakind4 real,
+        stakind5 real,
+        staop1 oid,
+        staop2 oid,
+        staop3 oid,
+        staop4 oid,
+        staop5 oid,
+        stacoll1 oid,
+        stacoll2 oid,
+        stacoll3 oid,
+        stacoll4 oid,
+        stacoll5 oid,
+        stanumbers1 real[],
+        stanumbers2 real[],
+        stanumbers3 real[],
+        stanumbers4 real[],
+        stanumbers5 real[],
+        stavalues1 text[],
+        stavalues2 text[],
+        stavalues3 text[],
+        stavalues4 text[],
+        stavalues5 text[],
+        _value_type1 text,
+        _value_type2 text,
+        _value_type3 text,
+        _value_type4 text,
+        _value_type5 text
+      )
+      JOIN pg_class c ON c.relname = v.table_name
+      JOIN pg_namespace n ON n.oid = c.relnamespace AND n.nspname = v.schema_name
+      JOIN pg_attribute a ON a.attrelid = c.oid AND a.attname = v.column_name
+    ),
+    updated AS (
+      UPDATE pg_statistic s
+      SET
+        stanullfrac = i.stanullfrac,
+        stawidth = i.stawidth,
+        stadistinct = i.stadistinct,
+        stakind1 = i.stakind1,
+        stakind2 = i.stakind2,
+        stakind3 = i.stakind3,
+        stakind4 = i.stakind4,
+        stakind5 = i.stakind5,
+        staop1 = i.staop1,
+        staop2 = i.staop2,
+        staop3 = i.staop3,
+        staop4 = i.staop4,
+        staop5 = i.staop5,
+        stacoll1 = i.stacoll1,
+        stacoll2 = i.stacoll2,
+        stacoll3 = i.stacoll3,
+        stacoll4 = i.stacoll4,
+        stacoll5 = i.stacoll5,
+        stanumbers1 = i.stanumbers1,
+        stanumbers2 = i.stanumbers2,
+        stanumbers3 = i.stanumbers3,
+        stanumbers4 = i.stanumbers4,
+        stanumbers5 = i.stanumbers5,
+        stavalues1 = case
+          when i.stavalues1 is null then null
+          else array_in(i.stavalues1::text::cstring, i._value_type1::regtype::oid, -1)
+        end,
+        stavalues2 = case
+          when i.stavalues2 is null then null
+          else array_in(i.stavalues2::text::cstring, i._value_type2::regtype::oid, -1)
+        end,
+        stavalues3 = case
+          when i.stavalues3 is null then null
+          else array_in(i.stavalues3::text::cstring, i._value_type3::regtype::oid, -1)
+        end,
+        stavalues4 = case
+          when i.stavalues4 is null then null
+          else array_in(i.stavalues4::text::cstring, i._value_type4::regtype::oid, -1)
+        end,
+        stavalues5 = case
+          when i.stavalues5 is null then null
+          else array_in(i.stavalues5::text::cstring, i._value_type5::regtype::oid, -1)
+        end
+        -- stavalues1 = i.stavalues1,
+        -- stavalues2 = i.stavalues2,
+        -- stavalues3 = i.stavalues3,
+        -- stavalues4 = i.stavalues4,
+        -- stavalues5 = i.stavalues5
+      FROM input i
+      WHERE s.starelid = i.starelid AND s.staattnum = i.staattnum AND s.stainherit = i.stainherit
+      RETURNING s.starelid, s.staattnum, s.stainherit, s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5
+    ),
+    inserted as (
+      INSERT INTO pg_statistic (
+        starelid, staattnum, stainherit,
+        stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5,
+        stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1, stavalues2, stavalues3, stavalues4, stavalues5
+      )
+      SELECT
+      i.starelid, i.staattnum, i.stainherit,
+      i.stanullfrac, i.stawidth, i.stadistinct,
+      i.stakind1, i.stakind2, i.stakind3, i.stakind4, i.stakind5,
+      i.staop1, i.staop2, i.staop3, i.staop4, i.staop5,
+      i.stacoll1, i.stacoll2, i.stacoll3, i.stacoll4, i.stacoll5,
+      i.stanumbers1, i.stanumbers2, i.stanumbers3, i.stanumbers4, i.stanumbers5,
+      -- i.stavalues1, i.stavalues2, i.stavalues3, i.stavalues4, i.stavalues5,
+      case
+        when i.stavalues1 is null then null
+        else array_in(i.stavalues1::text::cstring, i._value_type1::regtype::oid, -1)
+      end,
+      case
+        when i.stavalues2 is null then null
+        else array_in(i.stavalues2::text::cstring, i._value_type2::regtype::oid, -1)
+      end,
+      case
+        when i.stavalues3 is null then null
+        else array_in(i.stavalues3::text::cstring, i._value_type3::regtype::oid, -1)
+      end,
+      case
+        when i.stavalues4 is null then null
+        else array_in(i.stavalues4::text::cstring, i._value_type4::regtype::oid, -1)
+      end,
+      case
+        when i.stavalues5 is null then null
+        else array_in(i.stavalues5::text::cstring, i._value_type5::regtype::oid, -1)
+      end
+      -- i._value_type1, i._value_type2, i._value_type3, i._value_type4, i._value_type5
+      FROM input i
+      LEFT JOIN updated u
+        ON i.starelid = u.starelid AND i.staattnum = u.staattnum AND i.stainherit = u.stainherit
+      WHERE u.starelid IS NULL
+      returning starelid, staattnum, stainherit, stakind1, stakind2, stakind3, stakind4, stakind5
+    )
+    select * from updated union all (select * from inserted); -- @qd_introspection`;
+			columnStatsUpdatePromise = tx.exec(sql, [columnStatsValues]).catch((err) => {
+				console.error("Something wrong wrong updating column stats");
+				console.error(err);
+				throw err;
+			});
+		}
+		const reltuplesValues = [];
+		for (const table of this.ownMetadata) {
+			if (!table.columns) continue;
+			processedTables.add(`${table.schemaName}.${table.tableName}`);
+			let targetTable;
+			if (this.exportedMetadata) targetTable = this.exportedMetadata.find((m) => m.tableName === table.tableName && m.schemaName === table.schemaName);
+			let reltuples;
+			let relpages;
+			let relallvisible = 0;
+			let relallfrozen;
+			if (targetTable) {
+				reltuples = targetTable.reltuples;
+				relpages = targetTable.relpages;
+				relallvisible = targetTable.relallvisible;
+				relallfrozen = targetTable.relallfrozen;
+			} else if (this.mode.kind === "fromAssumption") {
+				reltuples = this.mode.reltuples;
+				relpages = this.mode.relpages;
+			} else {
+				warnings.tablesNotInExports.push(`${table.schemaName}.${table.tableName}`);
+				reltuples = DEFAULT_RELTUPLES;
+				relpages = DEFAULT_RELPAGES;
+			}
+			reltuplesValues.push({
+				relname: table.tableName,
+				schema_name: table.schemaName,
+				reltuples,
+				relpages,
+				relallfrozen,
+				relallvisible
+			});
+			if (targetTable && targetTable.indexes) for (const index of targetTable.indexes) reltuplesValues.push({
+				relname: index.indexName,
+				schema_name: targetTable.schemaName,
+				reltuples: index.reltuples,
+				relpages: index.relpages,
+				relallfrozen: index.relallfrozen,
+				relallvisible: index.relallvisible
+			});
+		}
+		const reltuplesQuery = dedent`
+        update pg_class p
+        set reltuples = v.reltuples,
+            relpages = v.relpages,
+            -- relallfrozen = case when v.relallfrozen is null then p.relallfrozen else v.relallfrozen end,
+            relallvisible = case when v.relallvisible is null then p.relallvisible else v.relallvisible end
+        from jsonb_to_recordset($1::jsonb)
+            as v(reltuples real, relpages integer, relallfrozen integer, relallvisible integer, relname text, schema_name text)
+        where p.relname = v.relname
+        and p.relnamespace = (select oid from pg_namespace where nspname = v.schema_name)
+        returning p.relname, p.relnamespace, p.reltuples, p.relpages;
+        `;
+		const reltuplesPromise = tx.exec(reltuplesQuery, [reltuplesValues]).catch((err) => {
+			console.error("Something went wrong updating reltuples/relpages");
+			console.error(err);
+			return err;
+		});
+		if (this.exportedMetadata) for (const table of this.exportedMetadata) {
+			const tableExists = processedTables.has(`${table.schemaName}.${table.tableName}`);
+			if (tableExists && table.reltuples === -1) {
+				console.warn(`Table ${table.tableName} has reltuples -1. Your production database is probably not analyzed properly`);
+				warnings.tableNotAnalyzed.push(`${table.schemaName}.${table.tableName}`);
+			}
+			if (tableExists) continue;
+			warnings.tablesNotInTest.push(`${table.schemaName}.${table.tableName}`);
+		}
+		const [statsUpdates, reltuplesUpdates] = await Promise.all([columnStatsUpdatePromise, reltuplesPromise]);
+		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 ${gray(postgresVersion)}`);
+		return (await db.exec(`
+      WITH table_columns AS (
+        SELECT
+          c.table_name,
+          c.table_schema,
+          cl.reltuples,
+          cl.relpages,
+          cl.relallvisible,
+          -- cl.relallfrozen,
+          n.nspname AS schema_name,
+          json_agg(
+            json_build_object(
+              'columnName', c.column_name,
+              'stats', (
+                SELECT json_build_object(
+                  'starelid', s.starelid,
+                  'staattnum', s.staattnum,
+                  'stanullfrac', s.stanullfrac,
+                  'stawidth', s.stawidth,
+                  'stadistinct', s.stadistinct,
+                  'stakind1', s.stakind1, 'staop1', s.staop1, 'stacoll1', s.stacoll1, 'stanumbers1', s.stanumbers1,
+                  'stakind2', s.stakind2, 'staop2', s.staop2, 'stacoll2', s.stacoll2, 'stanumbers2', s.stanumbers2,
+                  'stakind3', s.stakind3, 'staop3', s.staop3, 'stacoll3', s.stacoll3, 'stanumbers3', s.stanumbers3,
+                  'stakind4', s.stakind4, 'staop4', s.staop4, 'stacoll4', s.stacoll4, 'stanumbers4', s.stanumbers4,
+                  'stakind5', s.stakind5, 'staop5', s.staop5, 'stacoll5', s.stacoll5, 'stanumbers5', s.stanumbers5,
+                  'stavalues1', CASE WHEN $1 THEN s.stavalues1 ELSE NULL END,
+                  'stavalues2', CASE WHEN $1 THEN s.stavalues2 ELSE NULL END,
+                  'stavalues3', CASE WHEN $1 THEN s.stavalues3 ELSE NULL END,
+                  'stavalues4', CASE WHEN $1 THEN s.stavalues4 ELSE NULL END,
+                  'stavalues5', CASE WHEN $1 THEN s.stavalues5 ELSE NULL END
+                )
+                FROM pg_statistic s
+                WHERE s.starelid = a.attrelid AND s.staattnum = a.attnum
+              )
+            )
+            ORDER BY c.ordinal_position
+          ) AS columns
+        FROM information_schema.columns c
+        JOIN pg_attribute a
+          ON a.attrelid = (quote_ident(c.table_schema) || '.' || quote_ident(c.table_name))::regclass
+          AND a.attname = c.column_name
+        JOIN pg_class cl
+          ON cl.oid = a.attrelid
+        JOIN pg_namespace n
+          ON n.oid = cl.relnamespace
+        WHERE c.table_name NOT LIKE 'pg_%'
+          AND n.nspname <> 'information_schema'
+          AND c.table_name NOT IN ('pg_stat_statements', 'pg_stat_statements_info')
+        GROUP BY c.table_name, c.table_schema, cl.reltuples, cl.relpages, cl.relallvisible, n.nspname
+      ),
+      table_indexes AS (
+        SELECT
+          t.relname AS table_name,
+          json_agg(
+            json_build_object(
+              'indexName', i.relname,
+              'reltuples', i.reltuples,
+              'relpages', i.relpages,
+              'relallvisible', i.relallvisible
+              -- 'relallfrozen', i.relallfrozen
+            )
+          ) AS indexes
+        FROM pg_class t
+        JOIN pg_index ix ON ix.indrelid = t.oid
+        JOIN pg_class i ON i.oid = ix.indexrelid
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        WHERE t.relname NOT LIKE 'pg_%'
+          AND n.nspname <> 'information_schema'
+        GROUP BY t.relname
+      )
+      SELECT json_agg(
+        json_build_object(
+          'tableName', tc.table_name,
+          'schemaName', tc.table_schema,
+          'reltuples', tc.reltuples,
+          'relpages', tc.relpages,
+          'relallvisible', tc.relallvisible,
+          -- 'relallfrozen', tc.relallfrozen,
+          'columns', tc.columns,
+          'indexes', COALESCE(ti.indexes, '[]'::json)
+        )
+      )
+      FROM table_columns tc
+      LEFT JOIN table_indexes ti
+        ON ti.table_name = tc.table_name;
+      `, [fullDump]))[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,
+              inhrelid::regclass AS partition_table
+          FROM
+              pg_inherits
+      )
+      SELECT
+          n.nspname AS schema_name,
+          COALESCE(pt.parent_table::text, t.relname) AS table_name,
+          i.relname AS index_name,
+          ix.indisprimary as is_primary,
+          ix.indisunique as is_unique,
+          am.amname AS index_type,
+          array_agg(
+              CASE
+                  -- Handle regular columns
+                  WHEN a.attname IS NOT NULL THEN
+                    json_build_object('name', a.attname, 'order',
+                      CASE
+                          WHEN (indoption[array_position(ix.indkey, a.attnum)] & 1) = 1 THEN 'DESC'
+                          ELSE 'ASC'
+                      END,
+                      'opclass', CASE WHEN opc.opcdefault THEN NULL ELSE opc.opcname END)
+                  -- Handle expressions
+                  ELSE
+                      json_build_object('name', pg_get_expr((ix.indexprs)::pg_node_tree, t.oid), 'order',
+                      CASE
+                          WHEN (indoption[array_position(ix.indkey, k.attnum)] & 1) = 1 THEN 'DESC'
+                          ELSE 'ASC'
+                      END,
+                      'opclass', CASE WHEN opc.opcdefault THEN NULL ELSE opc.opcname END)
+              END
+              ORDER BY array_position(ix.indkey, k.attnum)
+          ) AS index_columns
+      FROM
+          pg_class t
+          LEFT JOIN partitioned_tables pt ON t.oid = pt.partition_table
+          JOIN pg_index ix ON t.oid = ix.indrelid
+          JOIN pg_class i ON i.oid = ix.indexrelid
+          JOIN pg_am am ON i.relam = am.oid
+          LEFT JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY k(attnum, ordinality) ON true
+          LEFT JOIN pg_attribute a ON a.attnum = k.attnum AND a.attrelid = t.oid
+          LEFT JOIN pg_opclass opc ON opc.oid = ix.indclass[k.ordinality - 1]
+          JOIN pg_namespace n ON t.relnamespace = n.oid
+      WHERE
+          n.nspname not like 'pg_%' and
+          n.nspname <> 'information_schema'
+      GROUP BY
+          n.nspname, COALESCE(pt.parent_table::text, t.relname), i.relname, am.amname, ix.indisprimary, ix.indisunique
+      ORDER BY
+          COALESCE(pt.parent_table::text, t.relname), i.relname; -- @qd_introspection
+      `);
+	}
+};
+_defineProperty(Statistics, "defaultStatsMode", Object.freeze({
+	kind: "fromAssumption",
+	reltuples: DEFAULT_RELTUPLES,
+	relpages: DEFAULT_RELPAGES
+}));
+
+//#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() {
+		_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()})`;
+		});
+	}
+};
+
+//#endregion
+export { Analyzer, ExportedStats, ExportedStatsColumns, ExportedStatsIndex, ExportedStatsStatistics, ExportedStatsV1, IndexOptimizer, PROCEED, PgIdentifier, PostgresQueryBuilder, PostgresVersion, PssRewriter, SKIP, Statistics, StatisticsMode, StatisticsSource, dropIndex, ignoredIdentifier, isIndexProbablyDroppable, isIndexSupported, parseMajorVersion, parseNudges, parseVersionNudges };
+//# sourceMappingURL=index.mjs.map