@query-doctor/core 0.8.0 → 0.8.1-rc.1

package/dist/index.mjs

@@ -1,2507 +1,12 @@
 "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/ast-utils.ts
-function is(node, kind) {
-	return kind in node;
-}
-function isANode(node) {
-	if (typeof node !== "object" || node === null) return false;
-	const keys = Object.keys(node);
-	return keys.length === 1 && /^[A-Z]/.test(keys[0]);
-}
-function getNodeKind(node) {
-	return Object.keys(node)[0];
-}
-//#endregion
-//#region src/sql/nudges.ts
-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 conditions — prevents index usage",
-			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 conditions — prevents index usage",
-			location: node.CoalesceExpr.location
-		});
-	});
-	Walker.shallowMatch(whereClause, "TypeCast", (node) => {
-		if (node.TypeCast.arg && hasColumnRefInNode(node.TypeCast.arg)) nudges.push({
-			kind: "AVOID_FUNCTIONS_ON_COLUMNS_IN_WHERE",
-			severity: "WARNING",
-			message: "Avoid using functions on columns in WHERE clause",
-			location: node.TypeCast.location
-		});
-	});
-	return nudges;
-};
-/**
-* Detect nudges for a single node during AST traversal.
-* Returns an array of nudges found for this node.
-*/
-function parseNudges(node, stack) {
-	const nudges = [];
-	if (is(node, "SelectStmt")) {
-		if (node.SelectStmt.whereClause) nudges.push(...findFuncCallsOnColumns(node.SelectStmt.whereClause));
-		const star = node.SelectStmt.targetList?.find((target) => {
-			if (!(is(target, "ResTarget") && target.ResTarget.val && is(target.ResTarget.val, "ColumnRef"))) return false;
-			const fields = target.ResTarget.val.ColumnRef.fields;
-			if (!fields?.some((field) => is(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(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(target, "ResTarget") && target.ResTarget.val && is(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(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(fromItem, "RangeVar") || is(fromItem, "JoinExpr") && hasActualTablesInJoin(fromItem);
-				})) {
-					const fromLocation = node.SelectStmt.fromClause.find((item) => is(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(node, "SelectStmt") && node.SelectStmt.sortClause) for (const sortItem of node.SelectStmt.sortClause) {
-		if (!is(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(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(node, "A_Expr")) {
-		if (node.A_Expr.kind === "AEXPR_OP" && node.A_Expr.name && node.A_Expr.name.length > 0 && is(node.A_Expr.name[0], "String") && (node.A_Expr.name[0].String.sval === "=" || node.A_Expr.name[0].String.sval === "!=" || node.A_Expr.name[0].String.sval === "<>")) {
-			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
-			});
-		}
-		if ((node.A_Expr.kind === "AEXPR_LIKE" || node.A_Expr.kind === "AEXPR_ILIKE") && node.A_Expr.rexpr) {
-			const patternString = getStringConstantValue(node.A_Expr.rexpr);
-			if (patternString && patternString.startsWith("%")) {
-				let stringNode;
-				if (is(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 (is(node, "SelectStmt") && node.SelectStmt.sortClause) {
-		for (const sortItem of node.SelectStmt.sortClause) if (is(sortItem, "SortBy") && sortItem.SortBy.node && is(sortItem.SortBy.node, "FuncCall") && sortItem.SortBy.node.FuncCall.funcname?.some((name) => is(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(node, "SelectStmt") && node.SelectStmt.distinctClause) nudges.push({
-		kind: "AVOID_DISTINCT_WITHOUT_REASON",
-		severity: "WARNING",
-		message: "Avoid using DISTINCT without a reason"
-	});
-	if (is(node, "JoinExpr")) {
-		if (node.JoinExpr.quals) nudges.push(...findFuncCallsOnColumns(node.JoinExpr.quals));
-		else if (!node.JoinExpr.usingClause) nudges.push({
-			kind: "MISSING_JOIN_CONDITION",
-			severity: "WARNING",
-			message: "Missing JOIN condition"
-		});
-	}
-	if (is(node, "SelectStmt") && node.SelectStmt.fromClause && node.SelectStmt.fromClause.length > 1) {
-		const tables = node.SelectStmt.fromClause.filter((item) => is(item, "RangeVar"));
-		if (tables.length > 1) {
-			const tableNames = new Set(tables.map((t) => t.RangeVar.alias?.aliasname || t.RangeVar.relname || ""));
-			if (!whereHasCrossTableEquality(node.SelectStmt.whereClause, tableNames)) nudges.push({
-				kind: "MISSING_JOIN_CONDITION",
-				severity: "WARNING",
-				message: "Missing JOIN condition",
-				location: tables[1].RangeVar.location
-			});
-		}
-	}
-	if (is(node, "BoolExpr") && node.BoolExpr.boolop === "OR_EXPR") {
-		if (countBoolOrConditions(node) >= 3 && allOrBranchesReferenceSameColumn(node)) 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(node, "BoolExpr") && node.BoolExpr.boolop === "NOT_EXPR") {
-		const args = node.BoolExpr.args;
-		if (args && args.length === 1) {
-			const inner = args[0];
-			if (isANode(inner) && is(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(node, "FuncCall")) {
-		const funcName = node.FuncCall.funcname;
-		if (funcName && funcName.length === 1 && is(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(node, "SelectStmt") && node.SelectStmt.havingClause) {
-		if (!containsAggregate(node.SelectStmt.havingClause)) {
-			const having = node.SelectStmt.havingClause;
-			let location;
-			if (is(having, "A_Expr")) location = having.A_Expr.location;
-			else if (is(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(node, "FuncCall")) {
-		if (stack.some((item) => item === "whereClause") && node.FuncCall.args) {
-			const name = getFuncName(node);
-			if (name && JSONB_SET_RETURNING_FUNCTIONS.has(name) && containsColumnRef(node.FuncCall.args)) nudges.push({
-				kind: "CONSIDER_JSONB_CONTAINMENT_OPERATOR",
-				severity: "INFO",
-				message: "JSONB set-returning functions (e.g. jsonb_array_elements) cannot be used as an index access path. If the query checks for containment or key existence, GIN-compatible operators (@>, ?, ?|, ?&, @?, @@) may allow index usage.",
-				location: node.FuncCall.location
-			});
-		}
-	}
-	if (is(node, "A_Expr")) {
-		if (node.A_Expr.kind === "AEXPR_IN") {
-			let list;
-			if (node.A_Expr.lexpr && is(node.A_Expr.lexpr, "List")) list = node.A_Expr.lexpr.List;
-			else if (node.A_Expr.rexpr && is(node.A_Expr.rexpr, "List")) list = node.A_Expr.rexpr.List;
-			if (list?.items && list.items.length >= 10) nudges.push({
-				kind: "REPLACE_LARGE_IN_TUPLE_WITH_ANY_ARRAY",
-				message: "`in (...)` queries with large tuples can often be replaced with `= ANY($1)` using a single parameter",
-				severity: "INFO",
-				location: node.A_Expr.location
-			});
-		}
-	}
-	if (is(node, "FuncCall")) {
-		const funcname = node.FuncCall.funcname?.[0] && is(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(firstArg) && is(firstArg, "CaseExpr")) {
-				const caseExpr = firstArg.CaseExpr;
-				if (caseExpr.args && caseExpr.args.length === 1) {
-					const defresult = caseExpr.defresult;
-					if (!defresult || isANode(defresult) && is(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(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(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(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
-		});
-	}
-	return nudges;
-}
-function containsColumnRef(args) {
-	for (const arg of args) if (hasColumnRefInNode(arg)) return true;
-	return false;
-}
-function hasColumnRefInNode(node) {
-	if (isANode(node) && is(node, "ColumnRef")) return true;
-	if (typeof node !== "object" || node === null) return false;
-	if (Array.isArray(node)) return node.some((item) => hasColumnRefInNode(item));
-	if (isANode(node)) return hasColumnRefInNode(node[Object.keys(node)[0]]);
-	for (const child of Object.values(node)) if (hasColumnRefInNode(child)) return true;
-	return false;
-}
-function hasActualTablesInJoin(joinExpr) {
-	if (joinExpr.JoinExpr.larg && is(joinExpr.JoinExpr.larg, "RangeVar")) return true;
-	if (joinExpr.JoinExpr.larg && is(joinExpr.JoinExpr.larg, "JoinExpr")) {
-		if (hasActualTablesInJoin(joinExpr.JoinExpr.larg)) return true;
-	}
-	if (joinExpr.JoinExpr.rarg && is(joinExpr.JoinExpr.rarg, "RangeVar")) return true;
-	if (joinExpr.JoinExpr.rarg && is(joinExpr.JoinExpr.rarg, "JoinExpr")) {
-		if (hasActualTablesInJoin(joinExpr.JoinExpr.rarg)) return true;
-	}
-	return false;
-}
-function isNullConstant(node) {
-	if (!node || typeof node !== "object") return false;
-	if (isANode(node) && is(node, "A_Const")) return node.A_Const.isnull !== void 0;
-	return false;
-}
-function getStringConstantValue(node) {
-	if (!node || typeof node !== "object") return null;
-	if (isANode(node) && is(node, "A_Const") && node.A_Const.sval) return node.A_Const.sval.sval || null;
-	return null;
-}
-const JSONB_SET_RETURNING_FUNCTIONS = new Set([
-	"jsonb_array_elements",
-	"json_array_elements",
-	"jsonb_array_elements_text",
-	"json_array_elements_text",
-	"jsonb_each",
-	"json_each",
-	"jsonb_each_text",
-	"json_each_text"
-]);
-function getFuncName(node) {
-	const names = node.FuncCall.funcname;
-	if (!names || names.length === 0) return null;
-	const last = names[names.length - 1];
-	if (isANode(last) && is(last, "String") && last.String.sval) return last.String.sval;
-	return null;
-}
-function getLastColumnRefField(columnRef) {
-	const fields = columnRef.ColumnRef.fields;
-	if (!fields || fields.length === 0) return null;
-	const lastField = fields[fields.length - 1];
-	if (isANode(lastField) && is(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(node.NullTest.arg, "ColumnRef")) {
-			if (getLastColumnRefField(node.NullTest.arg) === columnName) found = true;
-		}
-	});
-	return found;
-}
-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(node) && is(node, "FuncCall")) {
-		const funcname = node.FuncCall.funcname;
-		if (funcname) {
-			for (const f of funcname) if (isANode(f) && is(f, "String") && AGGREGATE_FUNCTIONS.has(f.String.sval?.toLowerCase() ?? "")) return true;
-		}
-	}
-	if (isANode(node)) return containsAggregate(node[Object.keys(node)[0]]);
-	for (const child of Object.values(node)) if (containsAggregate(child)) return true;
-	return false;
-}
-function countBoolOrConditions(node) {
-	if (node.BoolExpr.boolop !== "OR_EXPR" || !node.BoolExpr.args) return 1;
-	let count = 0;
-	for (const arg of node.BoolExpr.args) if (isANode(arg) && is(arg, "BoolExpr") && arg.BoolExpr.boolop === "OR_EXPR") count += countBoolOrConditions(arg);
-	else count += 1;
-	return count;
-}
-/**
-* Check whether every leaf of a top-level OR expression references the same
-* left-hand column (e.g. `status = 'a' OR status = 'b' OR status = 'c'`).
-* Returns false when ORs span different columns — IN rewrite doesn't apply.
-*/
-function allOrBranchesReferenceSameColumn(node) {
-	const columns = collectOrLeafColumns(node);
-	if (columns.length === 0) return false;
-	return columns.every((col) => col === columns[0]);
-}
-function collectOrLeafColumns(node) {
-	if (node.BoolExpr.boolop !== "OR_EXPR" || !node.BoolExpr.args) return [];
-	const columns = [];
-	for (const arg of node.BoolExpr.args) {
-		if (!isANode(arg)) continue;
-		if (is(arg, "BoolExpr") && arg.BoolExpr.boolop === "OR_EXPR") columns.push(...collectOrLeafColumns(arg));
-		else if (is(arg, "A_Expr")) {
-			const col = getLeftColumnKey(arg);
-			if (col) columns.push(col);
-			else return [];
-		} else return [];
-	}
-	return columns;
-}
-/**
-* Get a string key for the left-hand column of an A_Expr equality comparison.
-* For `t1.col = value` returns `"t1.col"`, for `col = value` returns `"col"`.
-*/
-function getLeftColumnKey(expr) {
-	if (!expr.A_Expr.lexpr || !isANode(expr.A_Expr.lexpr)) return null;
-	if (!is(expr.A_Expr.lexpr, "ColumnRef")) return null;
-	const fields = expr.A_Expr.lexpr.ColumnRef.fields;
-	if (!fields) return null;
-	return fields.filter((f) => isANode(f) && is(f, "String")).map((f) => f.String.sval).join(".");
-}
-/**
-* Check if a WHERE clause contains an equality between columns from different
-* tables (indicating an old-style implicit join condition).
-*/
-function whereHasCrossTableEquality(whereClause, tableNames) {
-	if (!whereClause) return false;
-	if (isANode(whereClause) && is(whereClause, "A_Expr")) {
-		if (whereClause.A_Expr.kind === "AEXPR_OP" && whereClause.A_Expr.name?.some((n) => is(n, "String") && n.String.sval === "=")) {
-			const leftTable = getColumnRefTableQualifier(whereClause.A_Expr.lexpr);
-			const rightTable = getColumnRefTableQualifier(whereClause.A_Expr.rexpr);
-			if (leftTable && rightTable && leftTable !== rightTable && tableNames.has(leftTable) && tableNames.has(rightTable)) return true;
-		}
-	}
-	if (isANode(whereClause) && is(whereClause, "BoolExpr")) {
-		for (const arg of whereClause.BoolExpr.args ?? []) if (isANode(arg) && whereHasCrossTableEquality(arg, tableNames)) return true;
-	}
-	return false;
-}
-/**
-* Extract the table qualifier (first field) from a ColumnRef node.
-* e.g. `t1.uid` → `"t1"`, `uid` → null
-*/
-function getColumnRefTableQualifier(node) {
-	if (!node || !isANode(node) || !is(node, "ColumnRef")) return null;
-	const fields = node.ColumnRef.fields;
-	if (!fields || fields.length < 2) return null;
-	const first = fields[0];
-	if (isANode(first) && is(first, "String")) return first.String.sval || null;
-	return null;
-}
-function isCountFuncCall(node) {
-	if (!node || typeof node !== "object") return false;
-	if (!isANode(node) || !is(node, "FuncCall")) return false;
-	const fc = node.FuncCall;
-	if (!(fc.funcname?.some((n) => is(n, "String") && n.String.sval === "count") ?? false)) return false;
-	if (fc.agg_star) return true;
-	if (fc.args && fc.args.length === 1 && isANode(fc.args[0]) && is(fc.args[0], "A_Const")) return true;
-	return false;
-}
-function isSubLinkWithCount(node) {
-	if (!node || typeof node !== "object") return false;
-	if (!isANode(node) || !is(node, "SubLink")) return false;
-	const subselect = node.SubLink.subselect;
-	if (!subselect || !isANode(subselect) || !is(subselect, "SelectStmt")) return false;
-	const targets = subselect.SelectStmt.targetList;
-	if (!targets || targets.length !== 1) return false;
-	const target = targets[0];
-	if (!isANode(target) || !is(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(node) || !is(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;
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.122.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.122.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.122.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.122.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
-const JSONB_EXTRACTION_OPS = new Set(["->", "->>"]);
-const COMPARISON_OPS = new Set([
-	"=",
-	"<>",
-	"!=",
-	"<",
-	"<=",
-	">",
-	">=",
-	"~~",
-	"~~*",
-	"!~~",
-	"!~~*"
-]);
-/**
-* 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 === "?&" || 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 && COMPARISON_OPS.has(opName)) for (const operand of [node.A_Expr.lexpr, node.A_Expr.rexpr]) {
-					if (!operand) continue;
-					const extraction = extractJsonbPath(operand);
-					if (extraction) this.add(extraction.columnRef, { jsonbExtraction: extraction.expression });
-				}
-			}
-			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?.jsonbExtraction) ref.jsonbExtraction = options.jsonbExtraction;
-		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);
-	}
-};
-/**
-* Given an operand of a comparison (e.g. the left side of `=`), check whether
-* it is a JSONB path extraction expression such as `data->>'email'` or
-* `(data->>'age')::int`.  If so, return the root ColumnRef (for the walker to
-* register) and the full expression string (for use in the expression index).
-*
-* Handles:
-* - `data->>'email'`            — simple extraction
-* - `(data->>'age')::int`       — extraction with cast
-* - `data->'addr'->>'city'`     — chained extraction
-* - `t.data->>'email'`          — table-qualified (strips qualifier from expression)
-*/
-function extractJsonbPath(node) {
-	let exprNode = node;
-	if (is(exprNode, "TypeCast") && exprNode.TypeCast.arg) exprNode = exprNode.TypeCast.arg;
-	if (!is(exprNode, "A_Expr") || exprNode.A_Expr.kind !== "AEXPR_OP") return;
-	const innerOp = exprNode.A_Expr.name?.[0] && is(exprNode.A_Expr.name[0], "String") && exprNode.A_Expr.name[0].String.sval;
-	if (!innerOp || !JSONB_EXTRACTION_OPS.has(innerOp)) return;
-	const rootCol = findRootColumnRef(exprNode);
-	if (!rootCol) return;
-	const cloned = JSON.parse(JSON.stringify(node));
-	stripTableQualifiers(cloned);
-	return {
-		columnRef: rootCol,
-		expression: deparseSync(cloned)
-	};
-}
-/**
-* Walk the left side of a chain of `->` / `->>` operators to find the
-* root ColumnRef (the JSONB column itself).
-*/
-function findRootColumnRef(node) {
-	if (is(node, "ColumnRef")) return node;
-	if (is(node, "A_Expr") && node.A_Expr.lexpr) return findRootColumnRef(node.A_Expr.lexpr);
-	if (is(node, "TypeCast") && node.TypeCast.arg) return findRootColumnRef(node.TypeCast.arg);
-}
-/**
-* Remove table/schema qualifiers from ColumnRef nodes inside the
-* expression so the deparsed expression contains only the column name.
-* e.g.  `t.data->>'email'`  →  `data->>'email'`
-*/
-function stripTableQualifiers(node) {
-	if (typeof node !== "object" || node === null) return;
-	if ("ColumnRef" in node && node.ColumnRef?.fields) {
-		const fields = node.ColumnRef.fields;
-		if (fields.length > 1) node.ColumnRef.fields = [fields[fields.length - 1]];
-		return;
-	}
-	for (const value of Object.values(node)) if (Array.isArray(value)) for (const item of value) stripTableQualifiers(item);
-	else if (typeof value === "object" && value !== null) stripTableQualifiers(value);
-}
-//#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)}`;
-			const reprKey = highlight.jsonbExtraction ? `${queryRepr}::${highlight.jsonbExtraction}` : queryRepr;
-			if (indexRepresentations.has(reprKey)) skip = true;
-			if (!skip) {
-				indexesToCheck.push(highlight);
-				indexRepresentations.add(reprKey);
-			}
-		}
-		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 extractionSuffix = index.jsonbExtraction ? `:"${index.jsonbExtraction}"` : "";
-			const key = `"${index.schema}":"${index.table}":"${index.column}"${extractionSuffix}`;
-			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.jsonbExtraction) index.jsonbExtraction = colReference.jsonbExtraction;
-					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.jsonbExtraction) index.jsonbExtraction = colReference.jsonbExtraction;
-					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.jsonbExtraction) index.jsonbExtraction = colReference.jsonbExtraction;
-				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 afterComment = trimmedQuery.slice(endPosition + 2).trim();
-		if (afterComment && afterComment !== ";") 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");
-/** Zod schema for PostgresExplainStage — validates common fields, passes through variant-specific ones. */
-const PostgresExplainStageSchema = z.lazy(() => z.object({
-	"Node Type": z.string(),
-	"Total Cost": z.number(),
-	"Plan Width": z.number(),
-	"Node Id": z.number().optional(),
-	Plans: z.array(PostgresExplainStageSchema).optional()
-}).passthrough());
-/**
-* 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";
-}
-/**
-* 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 expressionCandidates = rootCandidates.filter((c) => c.jsonbExtraction);
-		const btreeCandidates = rootCandidates.filter((c) => !c.jsonbOperator && !c.jsonbExtraction);
-		const ginCandidates = rootCandidates.filter((c) => c.jsonbOperator);
-		const nextStage = [];
-		const permutedIndexes = this.groupPotentialIndexColumnsByTable(btreeCandidates);
-		for (const permutation of permutedIndexes.values()) {
-			const { table: rawTable, schema: rawSchema, columns } = permutation;
-			const permutations = permutationsWithDescendingLength(columns);
-			for (const 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 !== "@>") ? 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 seenExpressions = /* @__PURE__ */ new Set();
-		for (const candidate of expressionCandidates) {
-			const expression = candidate.jsonbExtraction;
-			const key = `${candidate.schema}.${candidate.table}.${expression}`;
-			if (seenExpressions.has(key)) continue;
-			seenExpressions.add(key);
-			const schema = PgIdentifier.fromString(candidate.schema);
-			const table = PgIdentifier.fromString(candidate.table);
-			const indexName = this.indexName();
-			const definition = this.toExpressionDefinition({
-				table,
-				schema,
-				expression
-			});
-			nextStage.push({
-				name: indexName,
-				schema: schema.toString(),
-				table: table.toString(),
-				columns: [candidate],
-				definition
-			});
-		}
-		return nextStage;
-	}
-	toDefinition({ schema, table, columns }) {
-		const make = (col, order, _where, _keyword) => {
-			let fullyQualifiedTable;
-			if (schema.toString() === "public") fullyQualifiedTable = table;
-			else fullyQualifiedTable = PgIdentifier.fromParts(schema, table);
-			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})`;
-	}
-	toExpressionDefinition({ schema, table, expression }) {
-		let fullyQualifiedTable;
-		if (schema.toString() === "public") fullyQualifiedTable = table;
-		else fullyQualifiedTable = PgIdentifier.fromParts(schema, table);
-		return `${fullyQualifiedTable}((${expression}))`;
-	}
-	groupGinCandidatesByColumn(candidates) {
-		const groups = /* @__PURE__ */ new Map();
-		for (const c of candidates) {
-			if (!c.jsonbOperator) continue;
-			const key = `${c.schema}.${c.table}.${c.column}`;
-			const existing = groups.get(key);
-			if (existing) {
-				if (!existing.operators.includes(c.jsonbOperator)) existing.operators.push(c.jsonbOperator);
-			} else groups.set(key, {
-				schema: c.schema,
-				table: c.table,
-				column: c.column,
-				operators: [c.jsonbOperator]
-			});
-		}
-		return groups;
-	}
-	ginIndexAlreadyExists(table, column) {
-		return this.existingIndexes.find((index) => index.index_type === "gin" && index.table_name === table && index.index_columns.some((c) => c.name === column));
-	}
-	/**
-	* Drop indexes that can be dropped. Ignore the ones that can't
-	*/
-	async dropExistingIndexes(tx) {
-		for (const index of this.existingIndexes) {
-			if (!isIndexProbablyDroppable(index)) continue;
-			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.introspect().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(),
-	attlen: z.number().nullable(),
-	stats: ExportedStatsStatistics.nullable()
-});
-const ExportedStatsIndex = z.object({
-	indexName: z.string(),
-	amname: z.string().default("btree"),
-	relpages: z.number(),
-	reltuples: z.number(),
-	relallvisible: z.number(),
-	relallfrozen: z.number().optional(),
-	fillfactor: z.number().default(90),
-	columns: z.array(z.object({ attlen: z.number().nullable() })).default([])
-});
-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).default([]),
-	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)
-}), z.object({
-	kind: z.literal("fromStatisticsExport"),
-	stats: z.array(ExportedStats),
-	source: StatisticsSource
-})]);
-const DEFAULT_RELTUPLES = 1e4;
-const DEFAULT_RELPAGES = 1;
-const DEFAULT_PAGE_SIZE = 2 ** 13;
-function estimateStawidth(col) {
-	return col.attlen ?? 32;
-}
-function estimateRelpages(reltuples, columns) {
-	const rowWidth = columns.reduce((sum, col) => sum + estimateStawidth(col), 0) + 27;
-	return Math.ceil(reltuples * rowWidth / DEFAULT_PAGE_SIZE);
-}
-function estimateIndexRelpages(reltuples, columns, fillfactor, amname, tableRelpages) {
-	if (amname === "gin") return Math.ceil(tableRelpages * .3);
-	const keyWidth = columns.reduce((sum, col) => sum + estimateStawidth(col) + 16, 0);
-	return Math.ceil(reltuples * keyWidth / DEFAULT_PAGE_SIZE / fillfactor);
-}
-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 }) {
-		return {
-			kind: "fromAssumption",
-			reltuples
-		};
-	}
-	/**
-	* 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 = [];
-		for (const table of this.ownMetadata) {
-			const target = (this.exportedMetadata?.find((m) => m.tableName === table.tableName && m.schemaName === table.schemaName))?.columns ?? table.columns;
-			for (const column of target) {
-				const { stats } = column;
-				if (!stats || this.mode.kind === "fromAssumption") {
-					const stawidth = stats?.stawidth || estimateStawidth(column);
-					columnStatsValues.push({
-						schema_name: table.schemaName,
-						table_name: table.tableName,
-						column_name: column.columnName,
-						stainherit: false,
-						stanullfrac: .04,
-						stawidth,
-						stadistinct: -.9,
-						stakind1: 0,
-						stakind2: 0,
-						stakind3: 3,
-						stakind4: 0,
-						stakind5: 0,
-						stacoll1: "0",
-						stacoll2: "0",
-						stacoll3: "0",
-						stacoll4: "0",
-						stacoll5: "0",
-						staop1: "0",
-						staop2: "0",
-						staop3: "0",
-						staop4: "0",
-						staop5: "0",
-						stanumbers1: null,
-						stanumbers2: null,
-						stanumbers3: [.9],
-						stanumbers4: null,
-						stanumbers5: null,
-						stavalues1: null,
-						stavalues2: null,
-						stavalues3: null,
-						stavalues4: null,
-						stavalues5: null,
-						_value_type1: "real",
-						_value_type2: "real",
-						_value_type3: "real",
-						_value_type4: "real",
-						_value_type5: "real"
-					});
-					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) {
-			processedTables.add(`${table.schemaName}.${table.tableName}`);
-			let targetTable;
-			if (this.exportedMetadata) targetTable = this.exportedMetadata.find((m) => m.tableName === table.tableName && m.schemaName === table.schemaName);
-			else targetTable = table;
-			let reltuples;
-			let relpages;
-			let relallvisible = 0;
-			let relallfrozen;
-			if (this.mode.kind === "fromAssumption") {
-				reltuples = this.mode.reltuples;
-				relpages = estimateRelpages(reltuples, table.columns);
-			} else if (targetTable) {
-				reltuples = targetTable.reltuples;
-				relpages = targetTable.relpages;
-				relallvisible = targetTable.relallvisible;
-				relallfrozen = targetTable.relallfrozen;
-			} 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 (this.mode.kind === "fromAssumption") for (const index of table.indexes) {
-				const indexRelpages = estimateIndexRelpages(this.mode.reltuples, index.columns, index.fillfactor / 100, index.amname, relpages);
-				reltuplesValues.push({
-					relname: index.indexName,
-					schema_name: table.schemaName,
-					reltuples: this.mode.reltuples,
-					relpages: indexRelpages,
-					relallfrozen: 0,
-					relallvisible: indexRelpages
-				});
-			}
-			else if (targetTable) 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)}`);
-		const stats = await db.exec(`
-      WITH table_columns AS (
-        SELECT
-          cl.relname,
-          n.nspname,
-          cl.reltuples,
-          cl.relpages,
-          cl.relallvisible,
-          -- cl.relallfrozen,
-          json_agg(
-            json_build_object(
-              'columnName', a.attname,
-              'attlen', CASE WHEN a.attlen > 0 THEN a.attlen ELSE NULL END,
-              '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 a.attnum
-          ) AS columns
-        FROM pg_class cl
-        JOIN pg_namespace n ON n.oid = cl.relnamespace
-        JOIN pg_attribute a ON a.attrelid = cl.oid AND a.attnum > 0 AND NOT a.attisdropped
-        WHERE cl.relkind = 'r'
-          AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'tiger', 'tiger_data', 'topology')
-          AND cl.relname NOT IN ('pg_stat_statements', 'pg_stat_statements_info')
-        GROUP BY cl.relname, n.nspname, cl.reltuples, cl.relpages, cl.relallvisible
-      ),
-      table_indexes AS (
-        SELECT
-          t.relname AS table_name,
-          json_agg(
-            json_build_object(
-              'indexName', i.relname,
-              'amname', am.amname,
-              'reltuples', i.reltuples,
-              'relpages', i.relpages,
-              'relallvisible', i.relallvisible,
-              -- 'relallfrozen', i.relallfrozen,
-              'fillfactor', COALESCE(
-                (
-                  SELECT (regexp_match(opt, 'fillfactor=(\\d+)'))[1]::integer
-                  FROM unnest(i.reloptions) AS opt
-                  WHERE opt LIKE 'fillfactor=%'
-                  LIMIT 1
-                ),
-                90
-              ),
-              'columns', COALESCE(
-                (
-                  SELECT json_agg(json_build_object(
-                    'attlen', CASE WHEN a.attlen > 0 THEN a.attlen ELSE NULL END
-                  ) ORDER BY col_pos.ord)
-                  FROM unnest(ix.indkey) WITH ORDINALITY AS col_pos(attnum, ord)
-                  JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = col_pos.attnum
-                  WHERE col_pos.attnum > 0
-                ),
-                '[]'::json
-              )
-            )
-          ) 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_am am ON am.oid = i.relam
-        JOIN pg_namespace n ON n.oid = t.relnamespace
-        WHERE t.relname NOT LIKE 'pg_%'
-          AND n.nspname <> 'information_schema'
-          AND n.nspname NOT IN ('tiger', 'tiger_data', 'topology')
-        GROUP BY t.relname
-      )
-      SELECT json_agg(
-        json_build_object(
-          'tableName', tc.relname,
-          'schemaName', tc.nspname,
-          'reltuples', tc.reltuples,
-          'relpages', tc.relpages,
-          'relallvisible', tc.relallvisible,
-          -- 'relallfrozen', tc.relallfrozen,
-          'columns', COALESCE(tc.columns, '[]'::json),
-          'indexes', COALESCE(ti.indexes, '[]'::json)
-        )
-      )
-      FROM table_columns tc
-      LEFT JOIN table_indexes ti
-        ON ti.table_name = tc.relname;
-      `, [fullDump]);
-		return z.array(ExportedStats).parse(stats[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, PostgresExplainStageSchema, PostgresQueryBuilder, PostgresVersion, PssRewriter, SKIP, Statistics, StatisticsMode, StatisticsSource, dropIndex, ignoredIdentifier, isIndexProbablyDroppable, isIndexSupported, parseNudges };
-
-//# sourceMappingURL=index.mjs.map
+import { parseNudges } from "./sql/nudges.mjs";
+import { Analyzer, ignoredIdentifier } from "./sql/analyzer.mjs";
+import { PostgresExplainStageSchema, PostgresVersion, dropIndex } from "./sql/database.mjs";
+import { isIndexProbablyDroppable, isIndexSupported } from "./sql/indexes.mjs";
+import { PostgresQueryBuilder } from "./sql/builder.mjs";
+import { PgIdentifier } from "./sql/pg-identifier.mjs";
+import { IndexOptimizer, PROCEED, SKIP } from "./optimizer/genalgo.mjs";
+import { ExportedStats, ExportedStatsColumns, ExportedStatsIndex, ExportedStatsStatistics, ExportedStatsV1, Statistics, StatisticsMode, StatisticsSource } from "./optimizer/statistics.mjs";
+import { PssRewriter } from "./optimizer/pss-rewriter.mjs";
+import { deriveSentryEnvironment } from "./sentry.mjs";
+export { Analyzer, ExportedStats, ExportedStatsColumns, ExportedStatsIndex, ExportedStatsStatistics, ExportedStatsV1, IndexOptimizer, PROCEED, PgIdentifier, PostgresExplainStageSchema, PostgresQueryBuilder, PostgresVersion, PssRewriter, SKIP, Statistics, StatisticsMode, StatisticsSource, deriveSentryEnvironment, dropIndex, ignoredIdentifier, isIndexProbablyDroppable, isIndexSupported, parseNudges };