sumak 0.0.9 → 0.0.10

package/dist/normalize/expression.mjs

@@ -0,0 +1,330 @@
+import { DEFAULT_NORMALIZE_OPTIONS } from "./types.mjs";
+
+export function normalizeExpression(expr, opts) {
+	const o = {
+		...DEFAULT_NORMALIZE_OPTIONS,
+		...opts
+	};
+	let result = expr;
+	if (o.simplifyNegation) result = simplifyNegation(result);
+	if (o.foldConstants) result = foldConstants(result);
+	if (o.simplifyTautologies) result = simplifyTautologies(result);
+	if (o.flattenLogical) result = flattenLogical(result);
+	if (o.deduplicatePredicates) result = deduplicatePredicates(result);
+	
+	if (o.simplifyTautologies) result = simplifyTautologies(result);
+	return result;
+}
+
+
+export function toCNF(expr) {
+	const conjuncts = flattenAnd(expr);
+	const clauses = conjuncts.map((c) => flattenOr(c));
+	return { clauses };
+}
+
+export function fromCNF(cnf) {
+	if (cnf.clauses.length === 0) return undefined;
+	const conjuncts = cnf.clauses.map((disjuncts) => {
+		if (disjuncts.length === 0) return undefined;
+		return disjuncts.reduce((acc, d) => ({
+			type: "binary_op",
+			op: "OR",
+			left: acc,
+			right: d
+		}));
+	});
+	const filtered = conjuncts.filter((c) => c !== undefined);
+	if (filtered.length === 0) return undefined;
+	return filtered.reduce((acc, c) => ({
+		type: "binary_op",
+		op: "AND",
+		left: acc,
+		right: c
+	}));
+}
+
+function flattenAnd(expr) {
+	if (expr.type === "binary_op" && expr.op === "AND") {
+		return [...flattenAnd(expr.left), ...flattenAnd(expr.right)];
+	}
+	return [expr];
+}
+function flattenOr(expr) {
+	if (expr.type === "binary_op" && expr.op === "OR") {
+		return [...flattenOr(expr.left), ...flattenOr(expr.right)];
+	}
+	return [expr];
+}
+
+function flattenLogical(expr) {
+	if (expr.type !== "binary_op") return recurse(expr, flattenLogical);
+	const e = expr;
+	if (e.op === "AND") {
+		const parts = flattenAnd(e).map(flattenLogical);
+		return parts.reduce((acc, p) => ({
+			type: "binary_op",
+			op: "AND",
+			left: acc,
+			right: p
+		}));
+	}
+	if (e.op === "OR") {
+		const parts = flattenOr(e).map(flattenLogical);
+		return parts.reduce((acc, p) => ({
+			type: "binary_op",
+			op: "OR",
+			left: acc,
+			right: p
+		}));
+	}
+	return recurse(expr, flattenLogical);
+}
+
+
+function deduplicatePredicates(expr) {
+	if (expr.type !== "binary_op" || expr.op !== "AND") return expr;
+	const parts = flattenAnd(expr);
+	const seen = new Set();
+	const unique = [];
+	for (const p of parts) {
+		const key = exprFingerprint(p);
+		if (!seen.has(key)) {
+			seen.add(key);
+			unique.push(p);
+		}
+	}
+	if (unique.length === 0) return {
+		type: "literal",
+		value: true
+	};
+	return unique.reduce((acc, p) => ({
+		type: "binary_op",
+		op: "AND",
+		left: acc,
+		right: p
+	}));
+}
+
+function simplifyTautologies(expr) {
+	if (expr.type !== "binary_op") return recurse(expr, simplifyTautologies);
+	const e = expr;
+	const left = simplifyTautologies(e.left);
+	const right = simplifyTautologies(e.right);
+	if (e.op === "AND") {
+		
+		if (isTrue(left)) return right;
+		if (isTrue(right)) return left;
+		
+		if (isFalse(left) || isFalse(right)) return {
+			type: "literal",
+			value: false
+		};
+		return {
+			...e,
+			left,
+			right
+		};
+	}
+	if (e.op === "OR") {
+		
+		if (isTrue(left) || isTrue(right)) return {
+			type: "literal",
+			value: true
+		};
+		
+		if (isFalse(left)) return right;
+		if (isFalse(right)) return left;
+		return {
+			...e,
+			left,
+			right
+		};
+	}
+	return {
+		...e,
+		left,
+		right
+	};
+}
+
+function simplifyNegation(expr) {
+	if (expr.type === "unary_op") {
+		const u = expr;
+		if (u.op === "NOT") {
+			const inner = simplifyNegation(u.operand);
+			
+			if (inner.type === "unary_op" && inner.op === "NOT") {
+				return inner.operand;
+			}
+			
+			if (isTrue(inner)) return {
+				type: "literal",
+				value: false
+			};
+			if (isFalse(inner)) return {
+				type: "literal",
+				value: true
+			};
+			
+			if (inner.type === "is_null") {
+				return {
+					...inner,
+					negated: !inner.negated
+				};
+			}
+			return {
+				...u,
+				operand: inner
+			};
+		}
+	}
+	return recurse(expr, simplifyNegation);
+}
+
+function foldConstants(expr) {
+	if (expr.type !== "binary_op") return recurse(expr, foldConstants);
+	const e = expr;
+	const left = foldConstants(e.left);
+	const right = foldConstants(e.right);
+	
+	if (left.type === "literal" && right.type === "literal") {
+		const lv = left.value;
+		const rv = right.value;
+		if (typeof lv === "number" && typeof rv === "number") {
+			const folded = foldNumeric(e.op, lv, rv);
+			if (folded !== undefined) return {
+				type: "literal",
+				value: folded
+			};
+		}
+		
+		if (typeof lv === "string" && typeof rv === "string" && e.op === "||") {
+			return {
+				type: "literal",
+				value: lv + rv
+			};
+		}
+	}
+	
+	if (isComparisonOp(e.op) && left.type === "literal" && right.type !== "literal") {
+		return {
+			type: "binary_op",
+			op: flipComparison(e.op),
+			left: right,
+			right: left
+		};
+	}
+	return {
+		...e,
+		left,
+		right
+	};
+}
+function foldNumeric(op, l, r) {
+	switch (op) {
+		case "+": return l + r;
+		case "-": return l - r;
+		case "*": return l * r;
+		case "/": return r !== 0 ? l / r : undefined;
+		case "%": return r !== 0 ? l % r : undefined;
+		default: return undefined;
+	}
+}
+function isComparisonOp(op) {
+	return op === "=" || op === "!=" || op === "<>" || op === "<" || op === ">" || op === "<=" || op === ">=";
+}
+function flipComparison(op) {
+	switch (op) {
+		case "<": return ">";
+		case ">": return "<";
+		case "<=": return ">=";
+		case ">=": return "<=";
+		default: return op;
+	}
+}
+
+function isTrue(expr) {
+	return expr.type === "literal" && expr.value === true;
+}
+function isFalse(expr) {
+	return expr.type === "literal" && expr.value === false;
+}
+
+function exprFingerprint(expr) {
+	switch (expr.type) {
+		case "column_ref": return `col:${expr.table ?? ""}:${expr.column}`;
+		case "literal": return `lit:${String(expr.value)}`;
+		case "param": return `param:${String(expr.value)}`;
+		case "binary_op": return `bin:${expr.op}:${exprFingerprint(expr.left)}:${exprFingerprint(expr.right)}`;
+		case "unary_op": return `un:${expr.op}:${exprFingerprint(expr.operand)}`;
+		case "is_null": return `isnull:${expr.negated}:${exprFingerprint(expr.expr)}`;
+		case "between": return `between:${expr.negated}:${exprFingerprint(expr.expr)}:${exprFingerprint(expr.low)}:${exprFingerprint(expr.high)}`;
+		case "in":
+			if (Array.isArray(expr.values)) {
+				return `in:${expr.negated}:${exprFingerprint(expr.expr)}:[${expr.values.map(exprFingerprint).join(",")}]`;
+			}
+			return `in:${expr.negated}:${exprFingerprint(expr.expr)}:subq`;
+		case "function_call": return `fn:${expr.name}:${expr.distinct ?? false}:[${expr.args.map(exprFingerprint).join(",")}]`;
+		case "cast": return `cast:${expr.dataType}:${exprFingerprint(expr.expr)}`;
+		case "exists": return `exists:${expr.negated}`;
+		case "star": return `star:${expr.table ?? ""}`;
+		case "raw": return `raw:${expr.sql}`;
+		case "subquery": return `subq:${expr.alias ?? ""}`;
+		default: return `unknown:${expr.type}`;
+	}
+}
+
+function recurse(expr, transform) {
+	switch (expr.type) {
+		case "binary_op": return {
+			...expr,
+			left: transform(expr.left),
+			right: transform(expr.right)
+		};
+		case "unary_op": return {
+			...expr,
+			operand: transform(expr.operand)
+		};
+		case "is_null": return {
+			...expr,
+			expr: transform(expr.expr)
+		};
+		case "between": return {
+			...expr,
+			expr: transform(expr.expr),
+			low: transform(expr.low),
+			high: transform(expr.high)
+		};
+		case "in":
+			if (Array.isArray(expr.values)) {
+				return {
+					...expr,
+					expr: transform(expr.expr),
+					values: expr.values.map(transform)
+				};
+			}
+			return {
+				...expr,
+				expr: transform(expr.expr)
+			};
+		case "cast": return {
+			...expr,
+			expr: transform(expr.expr)
+		};
+		case "function_call": return {
+			...expr,
+			args: expr.args.map(transform)
+		};
+		case "case": return {
+			...expr,
+			operand: expr.operand ? transform(expr.operand) : undefined,
+			whens: expr.whens.map((w) => ({
+				condition: transform(w.condition),
+				result: transform(w.result)
+			})),
+			else_: expr.else_ ? transform(expr.else_) : undefined
+		};
+		default: return expr;
+	}
+}

package/dist/normalize/index.d.mts

@@ -0,0 +1,4 @@
+export { normalizeExpression, toCNF, fromCNF } from "./expression.mjs";
+export { normalizeQuery } from "./query.mjs";
+export type { CNF, NormalizeOptions } from "./types.mjs";
+export { DEFAULT_NORMALIZE_OPTIONS } from "./types.mjs";

package/dist/normalize/index.mjs

@@ -0,0 +1,3 @@
+export { normalizeExpression, toCNF, fromCNF } from "./expression.mjs";
+export { normalizeQuery } from "./query.mjs";
+export { DEFAULT_NORMALIZE_OPTIONS } from "./types.mjs";

package/dist/normalize/query.d.mts

@@ -0,0 +1,14 @@
+import type { ASTNode } from "../ast/nodes.mjs";
+import type { NormalizeOptions } from "./types.mjs";
+/**
+* Normalize a full query AST node.
+*
+* Applies NbE normalization to all expression-bearing parts:
+* - WHERE clauses (SELECT, UPDATE, DELETE)
+* - HAVING clauses (SELECT)
+* - JOIN ON conditions
+* - ON CONFLICT WHERE (INSERT)
+*
+* Leaves non-expression parts (table refs, column lists, ORDER BY) unchanged.
+*/
+export declare function normalizeQuery(node: ASTNode, opts?: NormalizeOptions): ASTNode;

package/dist/normalize/query.mjs

@@ -0,0 +1,126 @@
+import { normalizeExpression } from "./expression.mjs";
+import { DEFAULT_NORMALIZE_OPTIONS } from "./types.mjs";
+
+export function normalizeQuery(node, opts) {
+	const o = {
+		...DEFAULT_NORMALIZE_OPTIONS,
+		...opts
+	};
+	switch (node.type) {
+		case "select": return normalizeSelect(node, o);
+		case "update": return normalizeUpdate(node, o);
+		case "delete": return normalizeDelete(node, o);
+		case "insert": return normalizeInsert(node, o);
+		default: return node;
+	}
+}
+function normalizeSelect(node, opts) {
+	let result = { ...node };
+	
+	if (result.where) {
+		const w = normalizeExpression(result.where, opts);
+		result = {
+			...result,
+			where: w.type === "literal" && w.value === true ? undefined : w
+		};
+	}
+	
+	if (result.having) {
+		const h = normalizeExpression(result.having, opts);
+		result = {
+			...result,
+			having: h.type === "literal" && h.value === true ? undefined : h
+		};
+	}
+	
+	if (result.joins.length > 0) {
+		result = {
+			...result,
+			joins: result.joins.map((j) => {
+				if (!j.on) return j;
+				return {
+					...j,
+					on: normalizeExpression(j.on, opts)
+				};
+			})
+		};
+	}
+	
+	if (result.setOp) {
+		const normalizedSetQuery = normalizeSelect(result.setOp.query, opts);
+		result = {
+			...result,
+			setOp: {
+				...result.setOp,
+				query: normalizedSetQuery
+			}
+		};
+	}
+	
+	if (result.ctes.length > 0) {
+		result = {
+			...result,
+			ctes: result.ctes.map((cte) => ({
+				...cte,
+				query: normalizeSelect(cte.query, opts)
+			}))
+		};
+	}
+	return result;
+}
+function normalizeUpdate(node, opts) {
+	let result = { ...node };
+	if (result.where) {
+		const w = normalizeExpression(result.where, opts);
+		result = {
+			...result,
+			where: w.type === "literal" && w.value === true ? undefined : w
+		};
+	}
+	if (result.joins.length > 0) {
+		result = {
+			...result,
+			joins: result.joins.map((j) => {
+				if (!j.on) return j;
+				return {
+					...j,
+					on: normalizeExpression(j.on, opts)
+				};
+			})
+		};
+	}
+	return result;
+}
+function normalizeDelete(node, opts) {
+	let result = { ...node };
+	if (result.where) {
+		const w = normalizeExpression(result.where, opts);
+		result = {
+			...result,
+			where: w.type === "literal" && w.value === true ? undefined : w
+		};
+	}
+	if (result.joins.length > 0) {
+		result = {
+			...result,
+			joins: result.joins.map((j) => {
+				if (!j.on) return j;
+				return {
+					...j,
+					on: normalizeExpression(j.on, opts)
+				};
+			})
+		};
+	}
+	return result;
+}
+function normalizeInsert(node, opts) {
+	if (!node.onConflict?.where) return node;
+	return {
+		...node,
+		onConflict: {
+			...node.onConflict,
+			where: normalizeExpression(node.onConflict.where, opts)
+		}
+	};
+}

package/dist/normalize/types.d.mts

@@ -0,0 +1,38 @@
+import type { ExpressionNode } from "../ast/nodes.mjs";
+/**
+* Semantic domain for NbE (Normalization by Evaluation).
+*
+* The normalizer evaluates AST nodes into a canonical semantic domain,
+* then reifies them back into normal-form AST nodes.
+*
+* This separates "what the query means" from "how it was written".
+*/
+/**
+* A predicate in conjunctive normal form (CNF).
+* Top-level is AND, each clause is a disjunction (OR) of atoms.
+*
+* Example: `(a = 1 AND b = 2 AND (c = 3 OR c = 4))`
+* → `[[a=1], [b=2], [c=3, c=4]]`
+*
+* This representation makes deduplication and simplification trivial.
+*/
+export interface CNF {
+	/** Each inner array is a disjunction (OR). Top-level is conjunction (AND). */
+	clauses: ExpressionNode[][];
+}
+/**
+* Normalization options.
+*/
+export interface NormalizeOptions {
+	/** Flatten nested AND/OR into CNF. Default: true */
+	flattenLogical?: boolean;
+	/** Remove duplicate predicates. Default: true */
+	deduplicatePredicates?: boolean;
+	/** Simplify tautologies (WHERE true) and contradictions (WHERE false). Default: true */
+	simplifyTautologies?: boolean;
+	/** Fold constant expressions (1 + 2 → 3). Default: true */
+	foldConstants?: boolean;
+	/** Simplify double negation (NOT NOT x → x). Default: true */
+	simplifyNegation?: boolean;
+}
+export declare const DEFAULT_NORMALIZE_OPTIONS: Required<NormalizeOptions>;

package/dist/normalize/types.mjs

@@ -0,0 +1,7 @@
+export const DEFAULT_NORMALIZE_OPTIONS = {
+	flattenLogical: true,
+	deduplicatePredicates: true,
+	simplifyTautologies: true,
+	foldConstants: true,
+	simplifyNegation: true
+};

package/dist/optimize/index.d.mts

@@ -0,0 +1,3 @@
+export { optimize, createRule } from "./optimizer.mjs";
+export { predicatePushdown, subqueryFlattening, removeWhereTrue, BUILTIN_RULES } from "./rules.mjs";
+export type { RewriteRule, OptimizeOptions } from "./types.mjs";

package/dist/optimize/index.mjs

@@ -0,0 +1,2 @@
+export { optimize, createRule } from "./optimizer.mjs";
+export { predicatePushdown, subqueryFlattening, removeWhereTrue, BUILTIN_RULES } from "./rules.mjs";

package/dist/optimize/optimizer.d.mts

@@ -0,0 +1,28 @@
+import type { ASTNode } from "../ast/nodes.mjs";
+import type { NormalizeOptions } from "../normalize/types.mjs";
+import type { OptimizeOptions, RewriteRule } from "./types.mjs";
+/**
+* Full optimization pipeline: Normalize → Rewrite Rules (to fixpoint).
+*
+* The normalizer reduces expressions to canonical form (NbE).
+* The optimizer applies rewrite rules bottom-up until no more changes occur.
+*
+* ```
+* AST → normalize(NbE) → optimize(rules, fixpoint) → optimized AST
+* ```
+*/
+export declare function optimize(node: ASTNode, opts?: OptimizeOptions & {
+	normalize?: NormalizeOptions;
+}): ASTNode;
+/**
+* Create a custom rewrite rule.
+*
+* ```ts
+* const myRule = createRule({
+*   name: "my-optimization",
+*   match: (node) => node.type === "select" && hasPattern(node),
+*   apply: (node) => transformPattern(node),
+* })
+* ```
+*/
+export declare function createRule(rule: RewriteRule): RewriteRule;

package/dist/optimize/optimizer.mjs

@@ -0,0 +1,37 @@
+import { normalizeQuery } from "../normalize/query.mjs";
+import { BUILTIN_RULES } from "./rules.mjs";
+import { DEFAULT_OPTIMIZE_OPTIONS } from "./types.mjs";
+
+export function optimize(node, opts) {
+	
+	let result = normalizeQuery(node, opts?.normalize);
+	
+	const maxIterations = opts?.maxIterations ?? DEFAULT_OPTIMIZE_OPTIONS.maxIterations;
+	const disableSet = new Set(opts?.disableRules ?? []);
+	const rules = (opts?.rules ?? BUILTIN_RULES).filter((r) => !disableSet.has(r.name));
+	for (let i = 0; i < maxIterations; i++) {
+		const next = applyRules(result, rules);
+		if (next === result) break;
+		result = next;
+	}
+	return result;
+}
+
+function applyRules(node, rules) {
+	let result = node;
+	let changed = false;
+	for (const rule of rules) {
+		if (rule.match(result)) {
+			const next = rule.apply(result);
+			if (next !== result) {
+				result = next;
+				changed = true;
+			}
+		}
+	}
+	return changed ? result : node;
+}
+
+export function createRule(rule) {
+	return rule;
+}

package/dist/optimize/rules.d.mts

@@ -0,0 +1,31 @@
+import type { RewriteRule } from "./types.mjs";
+/**
+* Predicate pushdown: push WHERE conditions into JOIN ON when they
+* reference only columns from one side of the join.
+*
+* Before: `SELECT ... FROM a JOIN b ON a.id = b.a_id WHERE b.active = true`
+* After:  `SELECT ... FROM a JOIN b ON a.id = b.a_id AND b.active = true`
+*
+* This helps the database optimizer by reducing the join's input set.
+*/
+export declare const predicatePushdown: RewriteRule;
+/**
+* Remove redundant subquery wrapping when a subquery in FROM
+* is a simple SELECT * with no additional clauses.
+*
+* Before: `SELECT * FROM (SELECT * FROM users) AS u`
+* After:  `SELECT * FROM users`
+*/
+export declare const subqueryFlattening: RewriteRule;
+/**
+* Merge consecutive WHERE conditions that are just literal true.
+* After normalization, this removes vestigial `WHERE true` from plugins.
+*/
+export declare const removeWhereTrue: RewriteRule;
+/**
+* Convert `COUNT(*)` in SELECT with only one table and no GROUP BY
+* to use the table name for clarity (optional cosmetic rule).
+*/
+export declare const mergeConsecutiveLimits: RewriteRule;
+/** All built-in optimization rules. */
+export declare const BUILTIN_RULES: RewriteRule[];