@quereus/quereus 0.2.0 → 0.4.0

package/src/planner/analysis/predicate-normalizer.ts

@@ -0,0 +1,237 @@
+import type { ScalarPlanNode } from '../nodes/plan-node.js';
+import { PlanNodeType } from '../nodes/plan-node-type.js';
+import { BinaryOpNode, UnaryOpNode, LiteralNode, BetweenNode } from '../nodes/scalar.js';
+import { ColumnReferenceNode } from '../nodes/reference.js';
+import { InNode } from '../nodes/subquery.js';
+import type * as AST from '../../parser/ast.js';
+
+/**
+ * Normalize a predicate for push-down and constraint extraction.
+ *
+ * Transformations (conservative, no CNF/DNF expansion):
+ * - Push NOT down (De Morgan) for AND/OR and double-negation elimination
+ * - Invert simple comparisons under NOT (>, >=, <, <=)
+ * - Canonicalize nested AND/OR by flattening binary trees
+ * - Normalize child predicates recursively
+ *
+ * Notes:
+ * - We intentionally do NOT distribute OR over AND (to avoid blow-ups)
+ * - NOT of equality becomes "!="; extractor treats it as residual (acceptable)
+ * - NOT of BETWEEN toggles the node's 'not' flag
+ */
+export function normalizePredicate(expr: ScalarPlanNode): ScalarPlanNode {
+    return normalize(expr);
+}
+
+function normalize(node: ScalarPlanNode): ScalarPlanNode {
+    switch (node.nodeType) {
+        case PlanNodeType.UnaryOp: {
+            const u = node as UnaryOpNode;
+            if (u.expression.operator === 'NOT') {
+                return pushNotDown(u.operand);
+            }
+            // Recurse
+            const normalizedOperand = normalize(u.operand);
+            return normalizedOperand === u.operand
+                ? u
+                : new UnaryOpNode(u.scope, u.expression, normalizedOperand);
+        }
+        case PlanNodeType.BinaryOp: {
+            const b = node as BinaryOpNode;
+            const op = b.expression.operator;
+            if (op === 'AND' || op === 'OR') {
+                // Normalize children first
+                const left = normalize(b.left);
+                const right = normalize(b.right);
+                // Flatten nested same-op nodes
+                const parts = collectAssociative(op, [left, right]);
+                if (op === 'OR') {
+                    const collapsed = tryCollapseOrToIn(b.scope, parts);
+                    if (collapsed) return collapsed;
+                }
+                return rebuildAssociative(b.scope, op, parts, b.expression);
+            }
+            // Other binary ops: normalize children only
+            const nLeft = normalize(b.left);
+            const nRight = normalize(b.right);
+            if (nLeft === b.left && nRight === b.right) {
+                return b;
+            }
+            return new BinaryOpNode(b.scope, b.expression, nLeft, nRight);
+        }
+        case PlanNodeType.Between: {
+            // Normalize sub-expressions only
+            const bt = node as BetweenNode;
+            const nExpr = normalize(bt.expr);
+            const nLower = normalize(bt.lower);
+            const nUpper = normalize(bt.upper);
+            if (nExpr === bt.expr && nLower === bt.lower && nUpper === bt.upper) {
+                return bt;
+            }
+            return new BetweenNode(bt.scope, bt.expression, nExpr, nLower, nUpper);
+        }
+        default:
+            return node;
+    }
+}
+
+function pushNotDown(node: ScalarPlanNode): ScalarPlanNode {
+    // NOT over NOT
+    if (node.nodeType === PlanNodeType.UnaryOp) {
+        const u = node as UnaryOpNode;
+        if (u.expression.operator === 'NOT') {
+            return normalize(u.operand);
+        }
+        // NOT over other unary ops: leave as residual NOT(op)
+        const nOp = normalize(u.operand);
+        return nOp === u.operand ? new UnaryOpNode(u.scope, u.expression, nOp) : new UnaryOpNode(u.scope, u.expression, nOp);
+    }
+
+    if (node.nodeType === PlanNodeType.BinaryOp) {
+        const b = node as BinaryOpNode;
+        const op = b.expression.operator;
+        // De Morgan for boolean connectives
+        if (op === 'AND' || op === 'OR') {
+            const negLeft = pushNotDown(b.left);
+            const negRight = pushNotDown(b.right);
+            const flipped = op === 'AND' ? 'OR' : 'AND';
+            const expr: AST.BinaryExpr = { type: 'binary', operator: flipped, left: (b.expression.left as AST.Expression), right: (b.expression.right as AST.Expression) };
+            // Rebuild and normalize/flatten
+            const combined = rebuildAssociative(b.scope, flipped, [negLeft, negRight], expr);
+            return combined;
+        }
+
+        // Invert simple comparisons
+        const inverted = invertComparisonIfPossible(b);
+        if (inverted) {
+            return normalize(inverted);
+        }
+
+        // Otherwise, keep as NOT(binary) by wrapping a NOT
+        const normalizedLeft = normalize(b.left);
+        const normalizedRight = normalize(b.right);
+        const rebuilt = (normalizedLeft === b.left && normalizedRight === b.right)
+            ? b
+            : new BinaryOpNode(b.scope, b.expression, normalizedLeft, normalizedRight);
+        const notAst: AST.UnaryExpr = { type: 'unary', operator: 'NOT', expr: b.expression };
+        return new UnaryOpNode(b.scope, notAst, rebuilt);
+    }
+
+    if (node.nodeType === PlanNodeType.Between) {
+        // Toggle the NOT flag on BETWEEN
+        const bt = node as BetweenNode;
+        const ast: AST.BetweenExpr = { ...bt.expression, not: !bt.expression.not };
+        const nExpr = normalize(bt.expr);
+        const nLower = normalize(bt.lower);
+        const nUpper = normalize(bt.upper);
+        return new BetweenNode(bt.scope, ast, nExpr, nLower, nUpper);
+    }
+
+    // Generic fallback: NOT(expr) as unary
+    const notAst: AST.UnaryExpr = { type: 'unary', operator: 'NOT', expr: (node as any).expression };
+    return new UnaryOpNode((node as any).scope, notAst, normalize(node));
+}
+
+function collectAssociative(op: string, parts: ScalarPlanNode[]): ScalarPlanNode[] {
+    const result: ScalarPlanNode[] = [];
+    for (const p of parts) {
+        if (p.nodeType === PlanNodeType.BinaryOp) {
+            const b = p as BinaryOpNode;
+            if (b.expression.operator === op) {
+                result.push(...collectAssociative(op, [b.left, b.right]));
+                continue;
+            }
+        }
+        result.push(p);
+    }
+    return result;
+}
+
+function rebuildAssociative(scope: any, op: string, parts: ScalarPlanNode[], baseExpr: AST.BinaryExpr): ScalarPlanNode {
+    if (parts.length === 0) {
+        // Degenerate; shouldn't happen
+        return new LiteralNode(scope, { type: 'literal', value: 1 });
+    }
+    if (parts.length === 1) {
+        return parts[0];
+    }
+    // Left-associative rebuild
+    let acc = parts[0];
+    for (let i = 1; i < parts.length; i++) {
+        const right = parts[i];
+        const newAst: AST.BinaryExpr = { type: 'binary', operator: op, left: (acc as any).expression ?? baseExpr.left, right: (right as any).expression ?? baseExpr.right };
+        acc = new BinaryOpNode(scope, newAst, acc, right);
+    }
+    return acc;
+}
+
+function invertComparisonIfPossible(b: BinaryOpNode): ScalarPlanNode | null {
+    const op = b.expression.operator;
+    const flippedOp = flipComparison(op);
+    if (!flippedOp) {
+        return null;
+    }
+    const ast: AST.BinaryExpr = { type: 'binary', operator: flippedOp, left: b.expression.left, right: b.expression.right };
+    return new BinaryOpNode(b.scope, ast, b.left, b.right);
+}
+
+function flipComparison(op: string): string | null {
+    switch (op) {
+        case '>': return '<=';
+        case '>=': return '<';
+        case '<': return '>=';
+        case '<=': return '>';
+        case '=': return '!='; // extractor will treat as residual; acceptable
+        default: return null;
+    }
+}
+
+// Attempt to collapse OR of equalities into an IN list when:
+// - All disjuncts are of the form (col = literal)
+// - The same column is used
+// - Literal list is small (<= 32) to avoid large INs
+function tryCollapseOrToIn(scope: any, disjuncts: ScalarPlanNode[]): ScalarPlanNode | null {
+    const values: LiteralNode[] = [];
+    let column: ColumnReferenceNode | null = null;
+
+    for (const d of disjuncts) {
+        if (d.nodeType !== PlanNodeType.BinaryOp) return null;
+        const b = d as BinaryOpNode;
+        if (b.expression.operator !== '=') return null;
+
+        // Two patterns: col = lit OR lit = col
+        let col: ColumnReferenceNode | null = null;
+        let lit: LiteralNode | null = null;
+        if (b.left.nodeType === PlanNodeType.ColumnReference && b.right.nodeType === PlanNodeType.Literal) {
+            col = b.left as ColumnReferenceNode;
+            lit = b.right as LiteralNode;
+        } else if (b.left.nodeType === PlanNodeType.Literal && b.right.nodeType === PlanNodeType.ColumnReference) {
+            col = b.right as ColumnReferenceNode;
+            lit = b.left as LiteralNode;
+        } else {
+            return null;
+        }
+
+        if (!column) {
+            column = col;
+        } else if (column.attributeId !== col.attributeId) {
+            return null;
+        }
+
+        values.push(lit);
+        if (values.length > 32) return null; // avoid creating huge IN lists
+    }
+
+    if (!column || values.length === 0) return null;
+
+    // Build an InNode with constant values
+    const ast: AST.InExpr = {
+        type: 'in',
+        expr: (column as any).expression,
+        values: values.map(v => (v as any).expression)
+    };
+    const inNode = new InNode((column as any).scope, ast, column, undefined, values);
+    return inNode;
+}
+
+

package/src/planner/building/alter-table.ts

@@ -10,7 +10,8 @@ export function buildAlterTableStmt(
   ctx: PlanningContext,
   stmt: AST.AlterTableStmt,
 ): VoidNode {
-  const tableReference = buildTableReference({ type: 'table', table: stmt.table }, ctx);
+  const tableRetrieve = buildTableReference({ type: 'table', table: stmt.table }, ctx);
+  const tableReference = tableRetrieve.tableRef; // Extract the actual TableReferenceNode
 
   switch (stmt.action.type) {
     case 'addConstraint': {
@@ -40,6 +41,7 @@ export function buildAlterTableStmt(
 
     default:
       throw new QuereusError(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         `Unknown ALTER TABLE action: ${(stmt.action as any).type}`,
         StatusCode.INTERNAL
       );

package/src/planner/building/block.ts

@@ -1,78 +1,93 @@
-import { BlockNode } from '../nodes/block.js';
-import * as AST from '../../parser/ast.js';
-import type { PlanNode } from '../nodes/plan-node.js';
-import { buildSelectStmt } from './select.js';
-import type { PlanningContext } from '../planning-context.js';
-import { buildCreateTableStmt } from './ddl.js';
-import { buildCreateIndexStmt } from './ddl.js';
-import { buildDropTableStmt } from './drop-table.js';
-import { buildCreateViewStmt } from './create-view.js';
-import { buildDropViewStmt } from './drop-view.js';
-import { buildInsertStmt } from './insert.js';
-import { buildUpdateStmt } from './update.js';
-import { buildDeleteStmt } from './delete.js';
-import { buildAlterTableStmt } from './alter-table.js';
-import { buildBeginStmt, buildCommitStmt, buildRollbackStmt, buildSavepointStmt, buildReleaseStmt } from './transaction.js';
-import { buildPragmaStmt } from './pragma.js';
-import { buildValuesStmt } from './select.js';
-import { quereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-
-export function buildBlock(ctx: PlanningContext, statements: AST.Statement[]): BlockNode {
-	const plannedStatements = statements.map((stmt) => {
-		switch (stmt.type) {
-			case 'select':
-				// buildSelectStmt returns a BatchNode, which is a PlanNode.
-				return buildSelectStmt(ctx, stmt as AST.SelectStmt);
-			case 'createTable':
-				return buildCreateTableStmt(ctx, stmt as AST.CreateTableStmt);
-			case 'createIndex':
-				return buildCreateIndexStmt(ctx, stmt as AST.CreateIndexStmt);
-			case 'createView':
-				return buildCreateViewStmt(ctx, stmt as AST.CreateViewStmt);
-			case 'drop':
-				if (stmt.objectType === 'table') {
-					return buildDropTableStmt(ctx, stmt as AST.DropStmt);
-				} else if (stmt.objectType === 'view') {
-					return buildDropViewStmt(ctx, stmt as AST.DropStmt);
-				}
-				break;
-			case 'insert':
-				return buildInsertStmt(ctx, stmt as AST.InsertStmt);
-			case 'update':
-				return buildUpdateStmt(ctx, stmt as AST.UpdateStmt);
-			case 'delete':
-				return buildDeleteStmt(ctx, stmt as AST.DeleteStmt);
-			case 'begin':
-				return buildBeginStmt(ctx, stmt as AST.BeginStmt);
-			case 'commit':
-				return buildCommitStmt(ctx, stmt as AST.CommitStmt);
-			case 'rollback':
-				return buildRollbackStmt(ctx, stmt as AST.RollbackStmt);
-			case 'savepoint':
-				return buildSavepointStmt(ctx, stmt as AST.SavepointStmt);
-			case 'release':
-				return buildReleaseStmt(ctx, stmt as AST.ReleaseStmt);
-			case 'pragma':
-				return buildPragmaStmt(ctx, stmt as AST.PragmaStmt);
-			case 'alterTable':
-				return buildAlterTableStmt(ctx, stmt as AST.AlterTableStmt);
-			case 'values':
-				return buildValuesStmt(ctx, stmt as AST.ValuesStmt);
-			default:
-				// Throw an exception for unsupported statement types
-				quereusError(
-					`Unsupported statement type: ${(stmt as AST.Statement).type}`,
-					StatusCode.UNSUPPORTED,
-					undefined,
-					stmt
-				);
-		}
-	}).filter(p => p !== undefined) as PlanNode[]; // Ensure we only have valid PlanNodes and cast
-
-    // The final BatchNode for the entire batch.
-    // Its scope is batchParameterScope, and it contains all successfully planned statements.
-	return new BlockNode(ctx.scope, plannedStatements, { ...ctx.parameters });
-}
-
-
+import { BlockNode } from '../nodes/block.js';
+import * as AST from '../../parser/ast.js';
+import type { PlanNode } from '../nodes/plan-node.js';
+import { buildSelectStmt } from './select.js';
+import type { PlanningContext } from '../planning-context.js';
+import { buildCreateTableStmt } from './ddl.js';
+import { buildCreateIndexStmt } from './ddl.js';
+import { buildDropTableStmt } from './drop-table.js';
+import { buildCreateViewStmt } from './create-view.js';
+import { buildDropViewStmt } from './drop-view.js';
+import { buildCreateAssertionStmt } from './create-assertion.js';
+import { buildDropAssertionStmt } from './drop-assertion.js';
+import { buildInsertStmt } from './insert.js';
+import { buildUpdateStmt } from './update.js';
+import { buildDeleteStmt } from './delete.js';
+import { buildAlterTableStmt } from './alter-table.js';
+import { buildBeginStmt, buildCommitStmt, buildRollbackStmt, buildSavepointStmt, buildReleaseStmt } from './transaction.js';
+import { buildPragmaStmt } from './pragma.js';
+import { buildValuesStmt } from './select.js';
+import { quereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import { buildDeclareSchemaStmt, buildDiffSchemaStmt, buildApplySchemaStmt, buildExplainSchemaStmt } from './declare-schema.js';
+
+export function buildBlock(ctx: PlanningContext, statements: AST.Statement[]): BlockNode {
+	const plannedStatements = statements.map((stmt) => {
+		switch (stmt.type) {
+			case 'select':
+				// buildSelectStmt returns a BatchNode, which is a PlanNode.
+				return buildSelectStmt(ctx, stmt as AST.SelectStmt);
+			case 'createTable':
+				return buildCreateTableStmt(ctx, stmt as AST.CreateTableStmt);
+			case 'createIndex':
+				return buildCreateIndexStmt(ctx, stmt as AST.CreateIndexStmt);
+			case 'createView':
+				return buildCreateViewStmt(ctx, stmt as AST.CreateViewStmt);
+			case 'createAssertion':
+				return buildCreateAssertionStmt(ctx, stmt as AST.CreateAssertionStmt);
+			case 'drop':
+				if (stmt.objectType === 'table') {
+					return buildDropTableStmt(ctx, stmt as AST.DropStmt);
+				} else if (stmt.objectType === 'view') {
+					return buildDropViewStmt(ctx, stmt as AST.DropStmt);
+				} else if (stmt.objectType === 'assertion') {
+					return buildDropAssertionStmt(ctx, stmt as AST.DropStmt);
+				}
+				break;
+			case 'insert':
+				return buildInsertStmt(ctx, stmt as AST.InsertStmt);
+			case 'update':
+				return buildUpdateStmt(ctx, stmt as AST.UpdateStmt);
+			case 'delete':
+				return buildDeleteStmt(ctx, stmt as AST.DeleteStmt);
+			case 'begin':
+				return buildBeginStmt(ctx, stmt as AST.BeginStmt);
+			case 'commit':
+				return buildCommitStmt(ctx, stmt as AST.CommitStmt);
+			case 'rollback':
+				return buildRollbackStmt(ctx, stmt as AST.RollbackStmt);
+			case 'savepoint':
+				return buildSavepointStmt(ctx, stmt as AST.SavepointStmt);
+			case 'release':
+				return buildReleaseStmt(ctx, stmt as AST.ReleaseStmt);
+			case 'pragma':
+				return buildPragmaStmt(ctx, stmt as AST.PragmaStmt);
+			case 'alterTable':
+				return buildAlterTableStmt(ctx, stmt as AST.AlterTableStmt);
+			case 'values':
+				return buildValuesStmt(ctx, stmt as AST.ValuesStmt);
+			case 'declareSchema':
+				return buildDeclareSchemaStmt(ctx, stmt as unknown as AST.DeclareSchemaStmt);
+			case 'diffSchema':
+				return buildDiffSchemaStmt(ctx, stmt as unknown as AST.DiffSchemaStmt);
+			case 'applySchema':
+				return buildApplySchemaStmt(ctx, stmt as unknown as AST.ApplySchemaStmt);
+			case 'explainSchema':
+				return buildExplainSchemaStmt(ctx, stmt as unknown as AST.ExplainSchemaStmt);
+			default:
+				// Throw an exception for unsupported statement types
+				quereusError(
+					`Unsupported statement type: ${(stmt as AST.Statement).type}`,
+					StatusCode.UNSUPPORTED,
+					undefined,
+					stmt
+				);
+		}
+	}).filter(p => p !== undefined) as PlanNode[]; // Ensure we only have valid PlanNodes and cast
+
+    // The final BatchNode for the entire batch.
+    // Its scope is batchParameterScope, and it contains all successfully planned statements.
+	return new BlockNode(ctx.scope, plannedStatements, { ...ctx.parameters });
+}
+
+