@query-doctor/core 0.4.2 → 0.5.0

package/dist/index.cjs

@@ -52,6 +52,14 @@ 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;
 };
 /**
@@ -78,6 +86,12 @@ 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")) {
@@ -102,6 +116,22 @@ function parseNudges(node, stack) {
 			}
 		}
 	}
+	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")) {
 		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);
@@ -121,12 +151,20 @@ function parseNudges(node, stack) {
 				nudges.push({
 					kind: "AVOID_LEADING_WILDCARD_LIKE",
 					severity: "WARNING",
-					message: "Avoid using LIKE with leading wildcards",
+					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$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",
@@ -168,6 +206,29 @@ function parseNudges(node, stack) {
 			});
 		}
 	}
+	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, "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, "A_Expr")) {
 		if (node.A_Expr.kind === "AEXPR_IN") {
 			let list;
@@ -181,6 +242,45 @@ function parseNudges(node, stack) {
 			});
 		}
 	}
+	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, "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, "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
+		});
+	}
 	return nudges;
 }
 function containsColumnRef(args) {
@@ -216,6 +316,48 @@ 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;
 }
+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;
+}
+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 countBoolOrConditions(node) {
 	if (node.BoolExpr.boolop !== "OR_EXPR" || !node.BoolExpr.args) return 1;
 	let count = 0;
@@ -223,6 +365,54 @@ function countBoolOrConditions(node) {
 	else count += 1;
 	return count;
 }
+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;
+}
 
 //#endregion
 //#region \0@oxc-project+runtime@0.112.0/helpers/typeof.js
@@ -686,6 +876,11 @@ var Analyzer = class {
 			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 {