@query-doctor/core 0.4.1-rc.3 → 0.4.2

package/dist/index.cjs

@@ -42,70 +42,6 @@ function isANode$1(node) {
 	const keys = Object.keys(node);
 	return keys.length === 1 && /^[A-Z]/.test(keys[0]);
 }
-/** Operators that require a GiST index for efficient execution */
-const GIST_OPERATORS = new Set(["&&", "-|-"]);
-/** PostGIS / spatial functions that require a GiST index */
-const SPATIAL_FUNCTIONS = new Set([
-	"st_intersects",
-	"st_contains",
-	"st_within",
-	"st_dwithin",
-	"st_covers",
-	"st_coveredby",
-	"st_crosses",
-	"st_overlaps",
-	"st_touches"
-]);
-const JSONB_EXTRACTION_OPS = new Set([
-	"->>",
-	"->",
-	"#>>",
-	"#>"
-]);
-function getAExprOpName(node) {
-	const nameNode = node.A_Expr.name?.[0];
-	if (nameNode && is$1(nameNode, "String") && nameNode.String.sval) return nameNode.String.sval;
-	return null;
-}
-/**
-* Check if a node is or contains a JSONB extraction expression,
-* unwrapping through TypeCast. Returns the extraction A_Expr if found.
-*/
-function findExtractionExpr(node) {
-	if (is$1(node, "A_Expr")) {
-		const op = getAExprOpName(node);
-		if (op && JSONB_EXTRACTION_OPS.has(op)) {
-			if (node.A_Expr.lexpr && hasColumnRefInNode(node.A_Expr.lexpr)) return node;
-			return null;
-		}
-	}
-	if (is$1(node, "TypeCast") && node.TypeCast.arg) return findExtractionExpr(node.TypeCast.arg);
-	return null;
-}
-const ARITHMETIC_OPERATORS = new Set([
-	"+",
-	"-",
-	"*",
-	"/",
-	"%"
-]);
-const isArithmeticExpr = (node) => {
-	if (!node || typeof node !== "object") return false;
-	if (!isANode$1(node) || !is$1(node, "A_Expr")) return false;
-	if (node.A_Expr.kind !== "AEXPR_OP" || !node.A_Expr.name?.length) return false;
-	const opNode = node.A_Expr.name[0];
-	if (!is$1(opNode, "String") || !opNode.String.sval) return false;
-	return ARITHMETIC_OPERATORS.has(opNode.String.sval);
-};
-const COMPARISON_OPERATORS = new Set([
-	"=",
-	"<",
-	">",
-	"<=",
-	">=",
-	"<>",
-	"!="
-]);
 const findFuncCallsOnColumns = (whereClause) => {
 	const nudges = [];
 	Walker.shallowMatch(whereClause, "FuncCall", (node) => {
@@ -116,77 +52,6 @@ const findFuncCallsOnColumns = (whereClause) => {
 			location: node.FuncCall.location
 		});
 	});
-	Walker.shallowMatch(whereClause, "CoalesceExpr", (node) => {
-		if (node.CoalesceExpr.args && containsColumnRef(node.CoalesceExpr.args)) nudges.push({
-			kind: "AVOID_FUNCTIONS_ON_COLUMNS_IN_WHERE",
-			severity: "WARNING",
-			message: "Avoid using functions on columns in WHERE clause",
-			location: node.CoalesceExpr.location
-		});
-	});
-	return nudges;
-};
-const findJsonbExtractionInWhere = (whereClause) => {
-	const nudges = [];
-	const seen = /* @__PURE__ */ new Set();
-	function emit(node) {
-		const extraction = findExtractionExpr(node);
-		if (extraction && extraction.A_Expr.location !== void 0 && !seen.has(extraction.A_Expr.location)) {
-			seen.add(extraction.A_Expr.location);
-			nudges.push({
-				kind: "CONSIDER_EXPRESSION_INDEX_FOR_JSONB_EXTRACTION",
-				severity: "INFO",
-				message: "Consider an expression B-tree index for JSONB path extraction",
-				location: extraction.A_Expr.location
-			});
-		}
-	}
-	function walk(node) {
-		if (is$1(node, "A_Expr")) {
-			const op = getAExprOpName(node);
-			if (op && JSONB_EXTRACTION_OPS.has(op)) return;
-			if (node.A_Expr.lexpr) emit(node.A_Expr.lexpr);
-			if (node.A_Expr.rexpr) emit(node.A_Expr.rexpr);
-			return;
-		}
-		if (is$1(node, "BoolExpr") && node.BoolExpr.args) {
-			for (const arg of node.BoolExpr.args) walk(arg);
-			return;
-		}
-		if (is$1(node, "NullTest") && node.NullTest.arg) {
-			emit(node.NullTest.arg);
-			return;
-		}
-		if (is$1(node, "BooleanTest") && node.BooleanTest.arg) {
-			emit(node.BooleanTest.arg);
-			return;
-		}
-		if (is$1(node, "SubLink") && node.SubLink.testexpr) {
-			emit(node.SubLink.testexpr);
-			return;
-		}
-	}
-	walk(whereClause);
-	return nudges;
-};
-const findArithmeticExprsOnColumns = (whereClause) => {
-	const nudges = [];
-	Walker.shallowMatch(whereClause, "A_Expr", (node) => {
-		if (node.A_Expr.kind !== "AEXPR_OP" || !node.A_Expr.name?.length) return;
-		const opNode = node.A_Expr.name[0];
-		if (!is$1(opNode, "String") || !opNode.String.sval) return;
-		if (!COMPARISON_OPERATORS.has(opNode.String.sval)) return;
-		const sides = [node.A_Expr.lexpr, node.A_Expr.rexpr];
-		for (const side of sides) if (side && isArithmeticExpr(side) && hasColumnRefInNode(side)) {
-			const expr = side;
-			nudges.push({
-				kind: "AVOID_EXPRESSIONS_ON_COLUMNS_IN_WHERE",
-				severity: "WARNING",
-				message: "Avoid using arithmetic expressions on columns in WHERE clause",
-				location: expr.A_Expr.location
-			});
-		}
-	});
 	return nudges;
 };
 /**
@@ -196,11 +61,7 @@ const findArithmeticExprsOnColumns = (whereClause) => {
 function parseNudges(node, stack) {
 	const nudges = [];
 	if (is$1(node, "SelectStmt")) {
-		if (node.SelectStmt.whereClause) {
-			nudges.push(...findFuncCallsOnColumns(node.SelectStmt.whereClause));
-			nudges.push(...findJsonbExtractionInWhere(node.SelectStmt.whereClause));
-			nudges.push(...findArithmeticExprsOnColumns(node.SelectStmt.whereClause));
-		}
+		if (node.SelectStmt.whereClause) nudges.push(...findFuncCallsOnColumns(node.SelectStmt.whereClause));
 		const star = node.SelectStmt.targetList?.find((target) => {
 			if (!(is$1(target, "ResTarget") && target.ResTarget.val && is$1(target.ResTarget.val, "ColumnRef"))) return false;
 			const fields = target.ResTarget.val.ColumnRef.fields;
@@ -217,12 +78,6 @@ function parseNudges(node, stack) {
 				location: star.ResTarget.location
 			});
 		}
-		for (const target of node.SelectStmt.targetList ?? []) if (is$1(target, "ResTarget") && target.ResTarget.val && is$1(target.ResTarget.val, "SubLink") && target.ResTarget.val.SubLink.subLinkType === "EXPR_SUBLINK") nudges.push({
-			kind: "AVOID_SCALAR_SUBQUERY_IN_SELECT",
-			severity: "WARNING",
-			message: "Avoid correlated scalar subqueries in SELECT; consider rewriting as a JOIN",
-			location: target.ResTarget.val.SubLink.location
-		});
 	}
 	if (is$1(node, "SelectStmt")) {
 		if (!stack.some((item) => item === "RangeSubselect" || item === "SubLink" || item === "CommonTableExpr")) {
@@ -247,44 +102,8 @@ function parseNudges(node, stack) {
 			}
 		}
 	}
-	if (is$1(node, "SelectStmt")) {
-		if (!stack.some((item) => item === "RangeSubselect" || item === "SubLink" || item === "CommonTableExpr") && node.SelectStmt.sortClause && node.SelectStmt.whereClause) {
-			const equalityColumns = collectEqualityConstrainedColumns(node.SelectStmt.whereClause);
-			for (const sortItem of node.SelectStmt.sortClause) {
-				if (!is$1(sortItem, "SortBy") || !sortItem.SortBy.node) continue;
-				const sortNode = sortItem.SortBy.node;
-				if (!is$1(sortNode, "ColumnRef") || !sortNode.ColumnRef.fields) continue;
-				const lastField = sortNode.ColumnRef.fields[sortNode.ColumnRef.fields.length - 1];
-				if (!is$1(lastField, "String")) continue;
-				const sortCol = lastField.String.sval;
-				if (sortCol && equalityColumns.has(sortCol)) nudges.push({
-					kind: "NOOP_ORDER_BY",
-					severity: "INFO",
-					message: "ORDER BY column is constrained to a single value by WHERE clause",
-					location: sortNode.ColumnRef.location
-				});
-			}
-		}
-	}
-	if (is$1(node, "SelectStmt") && node.SelectStmt.sortClause) for (const sortItem of node.SelectStmt.sortClause) {
-		if (!is$1(sortItem, "SortBy")) continue;
-		const sortDir = sortItem.SortBy.sortby_dir ?? "SORTBY_DEFAULT";
-		const sortNulls = sortItem.SortBy.sortby_nulls ?? "SORTBY_NULLS_DEFAULT";
-		if (sortDir === "SORTBY_DESC" && sortNulls === "SORTBY_NULLS_DEFAULT") {
-			if (sortItem.SortBy.node && is$1(sortItem.SortBy.node, "ColumnRef")) {
-				const sortColumnName = getLastColumnRefField(sortItem.SortBy.node);
-				if (!(sortColumnName !== null && whereHasIsNotNull(node.SelectStmt.whereClause, sortColumnName))) nudges.push({
-					kind: "NULLS_FIRST_IN_DESC_ORDER",
-					severity: "INFO",
-					message: "ORDER BY … DESC sorts NULLs first — add NULLS LAST to push them to the end",
-					location: sortItem.SortBy.node.ColumnRef.location
-				});
-			}
-		}
-	}
 	if (is$1(node, "A_Expr")) {
-		const isEqualityOp = node.A_Expr.kind === "AEXPR_OP" && node.A_Expr.name && node.A_Expr.name.length > 0 && is$1(node.A_Expr.name[0], "String") && (node.A_Expr.name[0].String.sval === "=" || node.A_Expr.name[0].String.sval === "!=" || node.A_Expr.name[0].String.sval === "<>");
-		if (isEqualityOp) {
+		if (node.A_Expr.kind === "AEXPR_OP" && node.A_Expr.name && node.A_Expr.name.length > 0 && is$1(node.A_Expr.name[0], "String") && (node.A_Expr.name[0].String.sval === "=" || node.A_Expr.name[0].String.sval === "!=" || node.A_Expr.name[0].String.sval === "<>")) {
 			const leftIsNull = isNullConstant(node.A_Expr.lexpr);
 			const rightIsNull = isNullConstant(node.A_Expr.rexpr);
 			if (leftIsNull || rightIsNull) nudges.push({
@@ -294,8 +113,7 @@ function parseNudges(node, stack) {
 				location: node.A_Expr.location
 			});
 		}
-		const isLikeOp = node.A_Expr.kind === "AEXPR_LIKE" || node.A_Expr.kind === "AEXPR_ILIKE";
-		if (isLikeOp && node.A_Expr.rexpr) {
+		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;
@@ -303,44 +121,17 @@ function parseNudges(node, stack) {
 				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",
+					message: "Avoid using LIKE with leading wildcards",
 					location: stringNode?.location
 				});
 			}
 		}
-		if (isEqualityOp === false && isLikeOp === false) {
-			const gistOpName = node.A_Expr.kind === "AEXPR_OP" && node.A_Expr.name?.[0] && is$1(node.A_Expr.name[0], "String") && node.A_Expr.name[0].String.sval;
-			if (gistOpName && GIST_OPERATORS.has(gistOpName)) nudges.push({
-				kind: "CONSIDER_GIST_INDEX",
-				severity: "INFO",
-				message: `Operator "${gistOpName}" benefits from a GiST index for efficient execution`,
-				location: node.A_Expr.location
-			});
-		}
-	}
-	if (is$1(node, "SelectStmt") && node.SelectStmt.sortClause) {
-		for (const sortItem of node.SelectStmt.sortClause) if (is$1(sortItem, "SortBy") && sortItem.SortBy.node && is$1(sortItem.SortBy.node, "FuncCall") && sortItem.SortBy.node.FuncCall.funcname?.some((name) => is$1(name, "String") && name.String.sval === "random")) nudges.push({
-			kind: "AVOID_ORDER_BY_RANDOM",
-			severity: "WARNING",
-			message: "Avoid using ORDER BY random()",
-			location: sortItem.SortBy.node.FuncCall.location
-		});
 	}
 	if (is$1(node, "SelectStmt") && node.SelectStmt.distinctClause) nudges.push({
 		kind: "AVOID_DISTINCT_WITHOUT_REASON",
 		severity: "WARNING",
 		message: "Avoid using DISTINCT without a reason"
 	});
-	if (is$1(node, "SelectStmt") && node.SelectStmt.limitOffset) {
-		const offsetNode = node.SelectStmt.limitOffset;
-		const location = isANode$1(offsetNode) && is$1(offsetNode, "A_Const") ? offsetNode.A_Const.location : void 0;
-		nudges.push({
-			kind: "AVOID_OFFSET_FOR_PAGINATION",
-			severity: "INFO",
-			message: "Avoid using OFFSET for pagination",
-			location
-		});
-	}
 	if (is$1(node, "JoinExpr")) {
 		if (!node.JoinExpr.quals) nudges.push({
 			kind: "MISSING_JOIN_CONDITION",
@@ -377,93 +168,6 @@ function parseNudges(node, stack) {
 			});
 		}
 	}
-	if (is$1(node, "SelectStmt") && node.SelectStmt.havingClause) {
-		if (!containsAggregate(node.SelectStmt.havingClause)) {
-			const having = node.SelectStmt.havingClause;
-			let location;
-			if (is$1(having, "A_Expr")) location = having.A_Expr.location;
-			else if (is$1(having, "BoolExpr")) location = having.BoolExpr.location;
-			nudges.push({
-				kind: "PREFER_WHERE_OVER_HAVING_FOR_NON_AGGREGATES",
-				severity: "INFO",
-				message: "Non-aggregate condition in HAVING should be in WHERE",
-				location
-			});
-		}
-	}
-	if (is$1(node, "FuncCall")) {
-		const funcName = node.FuncCall.funcname;
-		if (funcName && funcName.length === 1 && is$1(funcName[0], "String") && funcName[0].String.sval === "count" && node.FuncCall.args && !node.FuncCall.agg_star && !node.FuncCall.agg_distinct) nudges.push({
-			kind: "PREFER_COUNT_STAR_OVER_COUNT_COLUMN",
-			severity: "INFO",
-			message: "Prefer COUNT(*) over COUNT(column) or COUNT(1) — COUNT(*) counts rows without checking for NULLs. If you need to count non-NULL values, COUNT(column) is correct.",
-			location: node.FuncCall.location
-		});
-	}
-	if (is$1(node, "A_Expr") && node.A_Expr.kind === "AEXPR_OP" && node.A_Expr.name && node.A_Expr.name.length > 0) {
-		const opNode = node.A_Expr.name[0];
-		const op = is$1(opNode, "String") ? opNode.String.sval : null;
-		if (op && isExistenceCheckPattern(node.A_Expr.lexpr, node.A_Expr.rexpr, op)) nudges.push({
-			kind: "USE_EXISTS_NOT_COUNT_FOR_EXISTENCE_CHECK",
-			severity: "INFO",
-			message: "Use EXISTS instead of COUNT for existence checks",
-			location: node.A_Expr.location
-		});
-	}
-	if (is$1(node, "FuncCall")) {
-		const funcname = node.FuncCall.funcname?.[0] && is$1(node.FuncCall.funcname[0], "String") && node.FuncCall.funcname[0].String.sval;
-		if (funcname && [
-			"sum",
-			"count",
-			"avg",
-			"min",
-			"max"
-		].includes(funcname.toLowerCase())) {
-			const firstArg = node.FuncCall.args?.[0];
-			if (firstArg && isANode$1(firstArg) && is$1(firstArg, "CaseExpr")) {
-				const caseExpr = firstArg.CaseExpr;
-				if (caseExpr.args && caseExpr.args.length === 1) {
-					const defresult = caseExpr.defresult;
-					if (!defresult || isANode$1(defresult) && is$1(defresult, "A_Const") && (defresult.A_Const.isnull !== void 0 || defresult.A_Const.ival !== void 0 && (defresult.A_Const.ival.ival === 0 || defresult.A_Const.ival.ival === void 0))) nudges.push({
-						kind: "PREFER_FILTER_OVER_CASE_IN_AGGREGATE",
-						severity: "INFO",
-						message: "Use FILTER (WHERE ...) instead of CASE inside aggregate functions",
-						location: node.FuncCall.location
-					});
-				}
-			}
-		}
-	}
-	if (is$1(node, "FuncCall") && node.FuncCall.funcname) {
-		const lastNameNode = node.FuncCall.funcname[node.FuncCall.funcname.length - 1];
-		if (lastNameNode && is$1(lastNameNode, "String") && lastNameNode.String.sval) {
-			const funcName = lastNameNode.String.sval.toLowerCase();
-			if (SPATIAL_FUNCTIONS.has(funcName)) nudges.push({
-				kind: "CONSIDER_GIST_INDEX",
-				severity: "INFO",
-				message: `Spatial function "${lastNameNode.String.sval}" benefits from a GiST index for efficient execution`,
-				location: node.FuncCall.location
-			});
-		}
-	}
-	if (is$1(node, "BoolExpr") && node.BoolExpr.boolop === "NOT_EXPR") {
-		const args = node.BoolExpr.args;
-		if (args && args.length === 1) {
-			const arg = args[0];
-			if (isANode$1(arg) && is$1(arg, "SubLink") && arg.SubLink.subLinkType === "EXISTS_SUBLINK" && arg.SubLink.subselect) {
-				const subselect = arg.SubLink.subselect;
-				if (isANode$1(subselect) && is$1(subselect, "SelectStmt") && subselect.SelectStmt.whereClause) {
-					const where = subselect.SelectStmt.whereClause;
-					if (isANode$1(where) && is$1(where, "BoolExpr") && where.BoolExpr.boolop === "OR_EXPR") nudges.push({
-						kind: "FLATTEN_NOT_EXISTS_OR",
-						severity: "INFO",
-						message: "Consider splitting NOT EXISTS with OR into separate NOT EXISTS joined by AND",
-						location: node.BoolExpr.location
-					});
-				}
-			}
-		}
-	}
 	if (is$1(node, "A_Expr")) {
 		if (node.A_Expr.kind === "AEXPR_IN") {
 			let list;
@@ -477,36 +181,6 @@ function parseNudges(node, stack) {
 			});
 		}
 	}
-	if (is$1(node, "SelectStmt") && node.SelectStmt.op === "SETOP_UNION" && !node.SelectStmt.all) nudges.push({
-		kind: "PREFER_UNION_ALL_OVER_UNION",
-		severity: "INFO",
-		message: "UNION removes duplicates with an implicit sort — use UNION ALL if deduplication is not needed"
-	});
-	if (is$1(node, "SelectStmt")) {
-		const subqueryAliases = /* @__PURE__ */ new Set();
-		if (node.SelectStmt.targetList) {
-			for (const target of node.SelectStmt.targetList) if (is$1(target, "ResTarget")) {
-				if (target.ResTarget.val && is$1(target.ResTarget.val, "SubLink")) {
-					if (target.ResTarget.name) subqueryAliases.add(target.ResTarget.name.toLowerCase());
-				}
-			}
-		}
-		if (subqueryAliases.size > 0 && node.SelectStmt.sortClause) {
-			for (const sortBy of node.SelectStmt.sortClause) if (is$1(sortBy, "SortBy") && sortBy.SortBy.node) {
-				if (is$1(sortBy.SortBy.node, "ColumnRef")) {
-					const columnName = extractColumnName(sortBy.SortBy.node);
-					if (columnName && subqueryAliases.has(columnName.toLowerCase())) {
-						nudges.push({
-							kind: "AVOID_SORTING_ON_GENERATED_VALUES",
-							severity: "WARNING",
-							message: "Be careful sorting on values generated dynamically during query execution - these cannot use indexes and contribute to slower query performance."
-						});
-						break;
-					}
-				}
-			}
-		}
-	}
 	return nudges;
 }
 function containsColumnRef(args) {
@@ -542,142 +216,6 @@ function getStringConstantValue(node) {
 	if (isANode$1(node) && is$1(node, "A_Const") && node.A_Const.sval) return node.A_Const.sval.sval || null;
 	return null;
 }
-const AGGREGATE_FUNCTIONS = new Set([
-	"count",
-	"sum",
-	"avg",
-	"min",
-	"max",
-	"array_agg",
-	"string_agg",
-	"bool_and",
-	"bool_or",
-	"every"
-]);
-function containsAggregate(node) {
-	if (!node || typeof node !== "object") return false;
-	if (Array.isArray(node)) return node.some(containsAggregate);
-	if (isANode$1(node) && is$1(node, "FuncCall")) {
-		const funcname = node.FuncCall.funcname;
-		if (funcname) {
-			for (const f of funcname) if (isANode$1(f) && is$1(f, "String") && AGGREGATE_FUNCTIONS.has(f.String.sval?.toLowerCase() ?? "")) return true;
-		}
-	}
-	if (isANode$1(node)) return containsAggregate(node[Object.keys(node)[0]]);
-	for (const child of Object.values(node)) if (containsAggregate(child)) return true;
-	return false;
-}
-function getLastColumnRefField(columnRef) {
-	const fields = columnRef.ColumnRef.fields;
-	if (!fields || fields.length === 0) return null;
-	const lastField = fields[fields.length - 1];
-	if (isANode$1(lastField) && is$1(lastField, "String")) return lastField.String.sval || null;
-	return null;
-}
-function whereHasIsNotNull(whereClause, columnName) {
-	if (!whereClause) return false;
-	let found = false;
-	Walker.shallowMatch(whereClause, "NullTest", (node) => {
-		if (node.NullTest.nulltesttype === "IS_NOT_NULL" && node.NullTest.arg && is$1(node.NullTest.arg, "ColumnRef")) {
-			if (getLastColumnRefField(node.NullTest.arg) === columnName) found = true;
-		}
-	});
-	return found;
-}
-function isCountFuncCall(node) {
-	if (!node || typeof node !== "object") return false;
-	if (!isANode$1(node) || !is$1(node, "FuncCall")) return false;
-	const fc = node.FuncCall;
-	if (!(fc.funcname?.some((n) => is$1(n, "String") && n.String.sval === "count") ?? false)) return false;
-	if (fc.agg_star) return true;
-	if (fc.args && fc.args.length === 1 && isANode$1(fc.args[0]) && is$1(fc.args[0], "A_Const")) return true;
-	return false;
-}
-function isSubLinkWithCount(node) {
-	if (!node || typeof node !== "object") return false;
-	if (!isANode$1(node) || !is$1(node, "SubLink")) return false;
-	const subselect = node.SubLink.subselect;
-	if (!subselect || !isANode$1(subselect) || !is$1(subselect, "SelectStmt")) return false;
-	const targets = subselect.SelectStmt.targetList;
-	if (!targets || targets.length !== 1) return false;
-	const target = targets[0];
-	if (!isANode$1(target) || !is$1(target, "ResTarget") || !target.ResTarget.val) return false;
-	return isCountFuncCall(target.ResTarget.val);
-}
-function isCountExpression(node) {
-	return isCountFuncCall(node) || isSubLinkWithCount(node);
-}
-function getIntegerConstantValue(node) {
-	if (!node || typeof node !== "object") return null;
-	if (!isANode$1(node) || !is$1(node, "A_Const")) return null;
-	if (node.A_Const.ival === void 0) return null;
-	return node.A_Const.ival.ival ?? 0;
-}
-function isExistenceCheckPattern(lexpr, rexpr, op) {
-	if (isCountExpression(lexpr)) {
-		const val = getIntegerConstantValue(rexpr);
-		if (val !== null) {
-			if (op === ">" && val === 0) return true;
-			if (op === ">=" && val === 1) return true;
-			if ((op === "!=" || op === "<>") && val === 0) return true;
-		}
-	}
-	if (isCountExpression(rexpr)) {
-		const val = getIntegerConstantValue(lexpr);
-		if (val !== null) {
-			if (op === "<" && val === 0) return true;
-			if (op === "<=" && val === 1) return true;
-			if ((op === "!=" || op === "<>") && val === 0) return true;
-		}
-	}
-	return false;
-}
-function collectEqualityConstrainedColumns(whereClause) {
-	const columns = /* @__PURE__ */ new Set();
-	function walk(node) {
-		if (!node || typeof node !== "object") return;
-		if (!isANode$1(node)) return;
-		if (is$1(node, "BoolExpr") && node.BoolExpr.boolop === "AND_EXPR" && node.BoolExpr.args) {
-			for (const arg of node.BoolExpr.args) walk(arg);
-			return;
-		}
-		if (is$1(node, "A_Expr") && node.A_Expr.kind === "AEXPR_OP") {
-			const opName = node.A_Expr.name?.[0];
-			if (opName && is$1(opName, "String") && opName.String.sval === "=") {
-				addColumnIfConstant(node.A_Expr.lexpr, node.A_Expr.rexpr, columns);
-				addColumnIfConstant(node.A_Expr.rexpr, node.A_Expr.lexpr, columns);
-			}
-			return;
-		}
-		if (is$1(node, "A_Expr") && node.A_Expr.kind === "AEXPR_IN") {
-			const listNode = node.A_Expr.rexpr;
-			if (listNode && isANode$1(listNode) && is$1(listNode, "List") && listNode.List.items && listNode.List.items.length === 1) {
-				const colNode = node.A_Expr.lexpr;
-				if (colNode && isANode$1(colNode) && is$1(colNode, "ColumnRef")) {
-					const lastField = colNode.ColumnRef.fields?.[colNode.ColumnRef.fields.length - 1];
-					if (lastField && is$1(lastField, "String") && lastField.String.sval) columns.add(lastField.String.sval);
-				}
-			}
-		}
-	}
-	walk(whereClause);
-	return columns;
-}
-function addColumnIfConstant(colSide, constSide, columns) {
-	if (!colSide || !constSide || typeof colSide !== "object" || typeof constSide !== "object") return;
-	if (!isANode$1(colSide) || !is$1(colSide, "ColumnRef")) return;
-	if (!isANode$1(constSide) || !is$1(constSide, "A_Const") && !is$1(constSide, "ParamRef")) return;
-	const fields = colSide.ColumnRef.fields;
-	if (!fields || fields.length === 0) return;
-	const lastField = fields[fields.length - 1];
-	if (is$1(lastField, "String") && lastField.String.sval) columns.add(lastField.String.sval);
-}
-function extractColumnName(node) {
-	if (!node.ColumnRef.fields || node.ColumnRef.fields.length === 0) return null;
-	const lastField = node.ColumnRef.fields[node.ColumnRef.fields.length - 1];
-	if (is$1(lastField, "String") && lastField.String.sval) return lastField.String.sval;
-	return null;
-}
 function countBoolOrConditions(node) {
 	if (node.BoolExpr.boolop !== "OR_EXPR" || !node.BoolExpr.args) return 1;
 	let count = 0;
@@ -685,28 +223,6 @@ function countBoolOrConditions(node) {
 	else count += 1;
 	return count;
 }
-/**
-* Extract the major version number from a PostgreSQL version string.
-* PostgreSQL encodes versions as XXYYZZ where XX is major, YY is minor, ZZ is patch.
-* e.g. "170000" → 17, "160004" → 16, "120000" → 12
-*/
-function parseMajorVersion(versionNum) {
-	return Math.floor(parseInt(versionNum, 10) / 1e4);
-}
-/**
-* Produce version-aware nudges by checking existing nudges against the
-* user's PostgreSQL major version. Returns upgrade recommendations
-* when a query pattern would benefit from a newer version.
-*/
-function parseVersionNudges(nudges, majorVersion) {
-	const versionNudges = [];
-	if (majorVersion < 17 && nudges.some((n) => n.kind === "AVOID_DISTINCT_WITHOUT_REASON")) versionNudges.push({
-		kind: "UPGRADE_DISTINCT_PG17",
-		severity: "INFO",
-		message: "PostgreSQL 17 introduces hash-based DISTINCT, which can significantly speed up queries using DISTINCT"
-	});
-	return versionNudges;
-}
 
 //#endregion
 //#region \0@oxc-project+runtime@0.112.0/helpers/typeof.js
@@ -837,11 +353,6 @@ var Walker = class Walker {
 					if (node.A_Expr.lexpr && is(node.A_Expr.lexpr, "ColumnRef")) this.add(node.A_Expr.lexpr, { jsonbOperator });
 					if (node.A_Expr.rexpr && is(node.A_Expr.rexpr, "ColumnRef")) this.add(node.A_Expr.rexpr, { jsonbOperator });
 				}
-				if (opName && (opName === "&&" || opName === "-|-")) {
-					const gistOperator = opName;
-					if (node.A_Expr.lexpr && is(node.A_Expr.lexpr, "ColumnRef")) this.add(node.A_Expr.lexpr, { gistOperator });
-					if (node.A_Expr.rexpr && is(node.A_Expr.rexpr, "ColumnRef")) this.add(node.A_Expr.rexpr, { gistOperator });
-				}
 			}
 			if (is(node, "ColumnRef")) {
 				for (let i = 0; i < stack.length; i++) {
@@ -925,7 +436,6 @@ var Walker = class Walker {
 		if (options?.sort) ref.sort = options.sort;
 		if (options?.where) ref.where = options.where;
 		if (options?.jsonbOperator) ref.jsonbOperator = options.jsonbOperator;
-		if (options?.gistOperator) ref.gistOperator = options.gistOperator;
 		this.highlights.push(ref);
 	}
 	/**
@@ -1094,7 +604,6 @@ var Analyzer = class {
 					if (colReference.sort) index.sort = colReference.sort;
 					if (colReference.where) index.where = colReference.where;
 					if (colReference.jsonbOperator) index.jsonbOperator = colReference.jsonbOperator;
-					if (colReference.gistOperator) index.gistOperator = colReference.gistOperator;
 					addIndex(index);
 				}
 			} else if (tableReference) {
@@ -1111,7 +620,6 @@ var Analyzer = class {
 					if (colReference.sort) index.sort = colReference.sort;
 					if (colReference.where) index.where = colReference.where;
 					if (colReference.jsonbOperator) index.jsonbOperator = colReference.jsonbOperator;
-					if (colReference.gistOperator) index.gistOperator = colReference.gistOperator;
 					addIndex(index);
 				}
 			} else if (fullReference) {
@@ -1124,7 +632,6 @@ var Analyzer = class {
 				if (colReference.sort) index.sort = colReference.sort;
 				if (colReference.where) index.where = colReference.where;
 				if (colReference.jsonbOperator) index.jsonbOperator = colReference.jsonbOperator;
-				if (colReference.gistOperator) index.gistOperator = colReference.gistOperator;
 				addIndex(index);
 			} else {
 				console.error("Column reference has too many parts. The query is malformed", colReference);
@@ -1236,7 +743,7 @@ async function dropIndex(tx, index) {
 //#endregion
 //#region src/sql/indexes.ts
 function isIndexSupported(index) {
-	return index.index_type === "btree" || index.index_type === "gin" || index.index_type === "gist";
+	return index.index_type === "btree" || index.index_type === "gin";
 }
 /**
 * Doesn't necessarily decide whether the index can be dropped but can be
@@ -1670,9 +1177,8 @@ var IndexOptimizer = class IndexOptimizer {
 	* Derive the list of indexes [tableA(X, Y, Z), tableB(H, I, J)]
 	**/
 	indexesToCreate(rootCandidates) {
-		const btreeCandidates = rootCandidates.filter((c) => !c.jsonbOperator && !c.gistOperator);
+		const btreeCandidates = rootCandidates.filter((c) => !c.jsonbOperator);
 		const ginCandidates = rootCandidates.filter((c) => c.jsonbOperator);
-		const gistCandidates = rootCandidates.filter((c) => c.gistOperator);
 		const nextStage = [];
 		const permutedIndexes = this.groupPotentialIndexColumnsByTable(btreeCandidates);
 		for (const permutation of permutedIndexes.values()) {
@@ -1726,32 +1232,6 @@ var IndexOptimizer = class IndexOptimizer {
 				opclass
 			});
 		}
-		const gistGroups = this.groupGistCandidatesByColumn(gistCandidates);
-		for (const group of gistGroups.values()) {
-			const { schema: rawSchema, table: rawTable, column } = group;
-			const schema = PgIdentifier.fromString(rawSchema);
-			const table = PgIdentifier.fromString(rawTable);
-			if (this.gistIndexAlreadyExists(table.toString(), column)) continue;
-			const indexName = this.indexName();
-			const candidate = {
-				schema: rawSchema,
-				table: rawTable,
-				column
-			};
-			const definition = this.toGistDefinition({
-				table,
-				schema,
-				column: PgIdentifier.fromString(column)
-			});
-			nextStage.push({
-				name: indexName,
-				schema: schema.toString(),
-				table: table.toString(),
-				columns: [candidate],
-				definition,
-				indexMethod: "gist"
-			});
-		}
 		return nextStage;
 	}
 	toDefinition({ schema, table, columns }) {
@@ -1782,12 +1262,6 @@ var IndexOptimizer = class IndexOptimizer {
 		const opclassSuffix = opclass ? ` ${opclass}` : "";
 		return `${fullyQualifiedTable} using gin (${column}${opclassSuffix})`;
 	}
-	toGistDefinition({ schema, table, column }) {
-		let fullyQualifiedTable;
-		if (schema.toString() === "public") fullyQualifiedTable = table;
-		else fullyQualifiedTable = PgIdentifier.fromParts(schema, table);
-		return `${fullyQualifiedTable} using gist (${column})`;
-	}
 	groupGinCandidatesByColumn(candidates) {
 		const groups = /* @__PURE__ */ new Map();
 		for (const c of candidates) {
@@ -1808,22 +1282,6 @@ var IndexOptimizer = class IndexOptimizer {
 	ginIndexAlreadyExists(table, column) {
 		return this.existingIndexes.find((index) => index.index_type === "gin" && index.table_name === table && index.index_columns.some((c) => c.name === column));
 	}
-	groupGistCandidatesByColumn(candidates) {
-		const groups = /* @__PURE__ */ new Map();
-		for (const c of candidates) {
-			if (!c.gistOperator) continue;
-			const key = `${c.schema}.${c.table}.${c.column}`;
-			if (!groups.has(key)) groups.set(key, {
-				schema: c.schema,
-				table: c.table,
-				column: c.column
-			});
-		}
-		return groups;
-	}
-	gistIndexAlreadyExists(table, column) {
-		return this.existingIndexes.find((index) => index.index_type === "gist" && index.table_name === table && index.index_columns.some((c) => c.name === column));
-	}
 	/**
 	* Drop indexes that can be dropped. Ignore the ones that can't
 	*/
@@ -2618,7 +2076,5 @@ exports.dropIndex = dropIndex;
 exports.ignoredIdentifier = ignoredIdentifier;
 exports.isIndexProbablyDroppable = isIndexProbablyDroppable;
 exports.isIndexSupported = isIndexSupported;
-exports.parseMajorVersion = parseMajorVersion;
 exports.parseNudges = parseNudges;
-exports.parseVersionNudges = parseVersionNudges;
 //# sourceMappingURL=index.cjs.map