@leonardovida-md/drizzle-neo-duckdb 1.1.3 → 1.2.0

package/src/sql/visitors/array-operators.ts

@@ -0,0 +1,214 @@
+/**
+ * AST visitor to transform Postgres array operators to DuckDB functions.
+ */
+
+import type {
+  AST,
+  Binary,
+  ExpressionValue,
+  Select,
+  From,
+  Join,
+} from 'node-sql-parser';
+
+const OPERATOR_MAP: Record<string, { fn: string; swap?: boolean }> = {
+  '@>': { fn: 'array_has_all' },
+  '<@': { fn: 'array_has_all', swap: true },
+  '&&': { fn: 'array_has_any' },
+};
+
+function walkExpression(
+  expr: ExpressionValue | null | undefined,
+  parent?: object,
+  key?: string
+): boolean {
+  if (!expr || typeof expr !== 'object') return false;
+
+  let transformed = false;
+  const exprObj = expr as Record<string, unknown>;
+
+  if ('type' in expr && exprObj.type === 'binary_expr') {
+    const binary = expr as Binary;
+    const mapping = OPERATOR_MAP[binary.operator];
+
+    if (mapping) {
+      const fnExpr = {
+        type: 'function' as const,
+        name: { name: [{ type: 'default', value: mapping.fn }] },
+        args: {
+          type: 'expr_list' as const,
+          value: mapping.swap
+            ? [binary.right, binary.left]
+            : [binary.left, binary.right],
+        },
+      };
+
+      if (parent && key) {
+        (parent as Record<string, unknown>)[key] = fnExpr;
+      }
+      transformed = true;
+    } else {
+      transformed =
+        walkExpression(binary.left as ExpressionValue, binary, 'left') ||
+        transformed;
+      transformed =
+        walkExpression(binary.right as ExpressionValue, binary, 'right') ||
+        transformed;
+    }
+  }
+
+  if ('type' in expr && exprObj.type === 'unary_expr') {
+    if ('expr' in exprObj) {
+      transformed =
+        walkExpression(exprObj.expr as ExpressionValue, exprObj, 'expr') ||
+        transformed;
+    }
+  }
+
+  if ('type' in expr && exprObj.type === 'case') {
+    if ('expr' in exprObj && exprObj.expr) {
+      transformed =
+        walkExpression(exprObj.expr as ExpressionValue, exprObj, 'expr') ||
+        transformed;
+    }
+    if ('args' in exprObj && Array.isArray(exprObj.args)) {
+      for (let i = 0; i < exprObj.args.length; i++) {
+        const whenClause = exprObj.args[i] as Record<string, unknown>;
+        if (whenClause.cond) {
+          transformed =
+            walkExpression(
+              whenClause.cond as ExpressionValue,
+              whenClause,
+              'cond'
+            ) || transformed;
+        }
+        if (whenClause.result) {
+          transformed =
+            walkExpression(
+              whenClause.result as ExpressionValue,
+              whenClause,
+              'result'
+            ) || transformed;
+        }
+      }
+    }
+  }
+
+  if ('args' in expr && exprObj.args) {
+    const args = exprObj.args as Record<string, unknown>;
+    if ('value' in args && Array.isArray(args.value)) {
+      for (let i = 0; i < args.value.length; i++) {
+        transformed =
+          walkExpression(
+            args.value[i] as ExpressionValue,
+            args.value,
+            String(i)
+          ) || transformed;
+      }
+    } else if ('expr' in args) {
+      transformed =
+        walkExpression(args.expr as ExpressionValue, args, 'expr') ||
+        transformed;
+    }
+  }
+
+  if ('ast' in exprObj && exprObj.ast) {
+    const subAst = exprObj.ast as Select;
+    if (subAst.type === 'select') {
+      transformed = walkSelectImpl(subAst) || transformed;
+    }
+  }
+
+  if ('type' in expr && exprObj.type === 'expr_list') {
+    if ('value' in exprObj && Array.isArray(exprObj.value)) {
+      for (let i = 0; i < exprObj.value.length; i++) {
+        transformed =
+          walkExpression(
+            exprObj.value[i] as ExpressionValue,
+            exprObj.value,
+            String(i)
+          ) || transformed;
+      }
+    }
+  }
+
+  return transformed;
+}
+
+function walkFrom(from: From[] | null | undefined): boolean {
+  if (!from || !Array.isArray(from)) return false;
+
+  let transformed = false;
+
+  for (const f of from) {
+    if ('join' in f) {
+      const join = f as Join;
+      transformed = walkExpression(join.on, join, 'on') || transformed;
+    }
+    if ('expr' in f && f.expr && 'ast' in f.expr) {
+      transformed = walkSelectImpl(f.expr.ast) || transformed;
+    }
+  }
+
+  return transformed;
+}
+
+function walkSelectImpl(select: Select): boolean {
+  let transformed = false;
+
+  if (select.with) {
+    for (const cte of select.with) {
+      const cteSelect = cte.stmt?.ast ?? cte.stmt;
+      if (cteSelect && cteSelect.type === 'select') {
+        transformed = walkSelectImpl(cteSelect as Select) || transformed;
+      }
+    }
+  }
+
+  if (Array.isArray(select.from)) {
+    transformed = walkFrom(select.from) || transformed;
+  }
+
+  transformed = walkExpression(select.where, select, 'where') || transformed;
+
+  if (select.having) {
+    if (Array.isArray(select.having)) {
+      for (let i = 0; i < select.having.length; i++) {
+        transformed =
+          walkExpression(select.having[i], select.having, String(i)) ||
+          transformed;
+      }
+    } else {
+      transformed =
+        walkExpression(select.having as ExpressionValue, select, 'having') ||
+        transformed;
+    }
+  }
+
+  if (Array.isArray(select.columns)) {
+    for (const col of select.columns) {
+      if ('expr' in col) {
+        transformed = walkExpression(col.expr, col, 'expr') || transformed;
+      }
+    }
+  }
+
+  if (select._next) {
+    transformed = walkSelectImpl(select._next) || transformed;
+  }
+
+  return transformed;
+}
+
+export function transformArrayOperators(ast: AST | AST[]): boolean {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+
+  for (const stmt of statements) {
+    if (stmt.type === 'select') {
+      transformed = walkSelectImpl(stmt as Select) || transformed;
+    }
+  }
+
+  return transformed;
+}

package/src/sql/visitors/column-qualifier.ts

@@ -0,0 +1,278 @@
+/**
+ * AST visitor to qualify unqualified column references in JOIN ON clauses.
+ */
+
+import type {
+  AST,
+  Binary,
+  ColumnRefItem,
+  ExpressionValue,
+  Select,
+  From,
+  Join,
+  OrderBy,
+  Column,
+} from 'node-sql-parser';
+
+type TableSource = {
+  name: string;
+  alias: string | null;
+};
+
+function getTableSource(from: From): TableSource | null {
+  if ('table' in from && from.table) {
+    return {
+      name: from.table,
+      alias: from.as ?? null,
+    };
+  }
+  if ('expr' in from && from.as) {
+    return {
+      name: from.as,
+      alias: from.as,
+    };
+  }
+  return null;
+}
+
+function getQualifier(source: TableSource): string {
+  return source.alias ?? source.name;
+}
+
+function isUnqualifiedColumnRef(expr: ExpressionValue): expr is ColumnRefItem {
+  return (
+    typeof expr === 'object' &&
+    expr !== null &&
+    'type' in expr &&
+    expr.type === 'column_ref' &&
+    !('table' in expr && expr.table)
+  );
+}
+
+function getColumnName(col: ColumnRefItem): string | null {
+  if (typeof col.column === 'string') {
+    return col.column;
+  }
+  if (col.column && 'expr' in col.column && col.column.expr?.value) {
+    return String(col.column.expr.value);
+  }
+  return null;
+}
+
+function walkOnClause(
+  expr: Binary | null | undefined,
+  leftSource: string,
+  rightSource: string,
+  ambiguousColumns: Set<string>
+): boolean {
+  if (!expr || typeof expr !== 'object') return false;
+
+  let transformed = false;
+
+  if (expr.type === 'binary_expr') {
+    if (expr.operator === '=') {
+      const left = expr.left as ExpressionValue;
+      const right = expr.right as ExpressionValue;
+
+      if (isUnqualifiedColumnRef(left) && isUnqualifiedColumnRef(right)) {
+        const leftColName = getColumnName(left);
+        const rightColName = getColumnName(right);
+
+        if (leftColName && rightColName && leftColName === rightColName) {
+          left.table = leftSource;
+          right.table = rightSource;
+
+          ambiguousColumns.add(leftColName);
+          transformed = true;
+        }
+      }
+    }
+
+    if (expr.operator === 'AND' || expr.operator === 'OR') {
+      transformed =
+        walkOnClause(
+          expr.left as Binary,
+          leftSource,
+          rightSource,
+          ambiguousColumns
+        ) || transformed;
+      transformed =
+        walkOnClause(
+          expr.right as Binary,
+          leftSource,
+          rightSource,
+          ambiguousColumns
+        ) || transformed;
+    }
+  }
+
+  return transformed;
+}
+
+function qualifyAmbiguousInExpression(
+  expr: ExpressionValue | null | undefined,
+  defaultQualifier: string,
+  ambiguousColumns: Set<string>
+): boolean {
+  if (!expr || typeof expr !== 'object') return false;
+
+  let transformed = false;
+
+  if (isUnqualifiedColumnRef(expr)) {
+    const colName = getColumnName(expr);
+    if (colName && ambiguousColumns.has(colName)) {
+      expr.table = defaultQualifier;
+      transformed = true;
+    }
+    return transformed;
+  }
+
+  if ('type' in expr && expr.type === 'binary_expr') {
+    const binary = expr as Binary;
+    transformed =
+      qualifyAmbiguousInExpression(
+        binary.left as ExpressionValue,
+        defaultQualifier,
+        ambiguousColumns
+      ) || transformed;
+    transformed =
+      qualifyAmbiguousInExpression(
+        binary.right as ExpressionValue,
+        defaultQualifier,
+        ambiguousColumns
+      ) || transformed;
+    return transformed;
+  }
+
+  if ('args' in expr && expr.args) {
+    const args = expr.args as {
+      value?: ExpressionValue[];
+      expr?: ExpressionValue;
+    };
+    if (args.value && Array.isArray(args.value)) {
+      for (const arg of args.value) {
+        transformed =
+          qualifyAmbiguousInExpression(
+            arg,
+            defaultQualifier,
+            ambiguousColumns
+          ) || transformed;
+      }
+    }
+    if (args.expr) {
+      transformed =
+        qualifyAmbiguousInExpression(
+          args.expr,
+          defaultQualifier,
+          ambiguousColumns
+        ) || transformed;
+    }
+  }
+
+  return transformed;
+}
+
+function walkSelect(select: Select): boolean {
+  let transformed = false;
+  const ambiguousColumns = new Set<string>();
+
+  if (Array.isArray(select.from) && select.from.length >= 2) {
+    const firstSource = getTableSource(select.from[0]);
+    const defaultQualifier = firstSource ? getQualifier(firstSource) : '';
+    let prevSource = firstSource;
+
+    for (const from of select.from) {
+      if ('join' in from) {
+        const join = from as Join;
+        const currentSource = getTableSource(join);
+
+        if (join.on && prevSource && currentSource) {
+          const leftQualifier = getQualifier(prevSource);
+          const rightQualifier = getQualifier(currentSource);
+
+          transformed =
+            walkOnClause(
+              join.on,
+              leftQualifier,
+              rightQualifier,
+              ambiguousColumns
+            ) || transformed;
+        }
+
+        prevSource = currentSource;
+      } else {
+        const source = getTableSource(from);
+        if (source) {
+          prevSource = source;
+        }
+      }
+
+      if ('expr' in from && from.expr && 'ast' in from.expr) {
+        transformed = walkSelect(from.expr.ast) || transformed;
+      }
+    }
+
+    if (ambiguousColumns.size > 0 && defaultQualifier) {
+      if (Array.isArray(select.columns)) {
+        for (const col of select.columns as Column[]) {
+          if ('expr' in col) {
+            transformed =
+              qualifyAmbiguousInExpression(
+                col.expr,
+                defaultQualifier,
+                ambiguousColumns
+              ) || transformed;
+          }
+        }
+      }
+
+      transformed =
+        qualifyAmbiguousInExpression(
+          select.where,
+          defaultQualifier,
+          ambiguousColumns
+        ) || transformed;
+
+      if (Array.isArray(select.orderby)) {
+        for (const order of select.orderby as OrderBy[]) {
+          if (order.expr) {
+            transformed =
+              qualifyAmbiguousInExpression(
+                order.expr,
+                defaultQualifier,
+                ambiguousColumns
+              ) || transformed;
+          }
+        }
+      }
+    }
+  }
+
+  if (select.with) {
+    for (const cte of select.with) {
+      const cteSelect = cte.stmt?.ast ?? cte.stmt;
+      if (cteSelect && cteSelect.type === 'select') {
+        transformed = walkSelect(cteSelect as Select) || transformed;
+      }
+    }
+  }
+
+  if (select._next) {
+    transformed = walkSelect(select._next) || transformed;
+  }
+
+  return transformed;
+}
+
+export function qualifyJoinColumns(ast: AST | AST[]): boolean {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+
+  for (const stmt of statements) {
+    if (stmt.type === 'select') {
+      transformed = walkSelect(stmt as Select) || transformed;
+    }
+  }
+
+  return transformed;
+}

package/src/utils.ts

@@ -1,3 +1,2 @@
 export { aliasFields } from './sql/selection.ts';
-export { adaptArrayOperators } from './sql/query-rewriters.ts';
 export { mapResultRow } from './sql/result-mapper.ts';

package/dist/sql/query-rewriters.d.ts

@@ -1,14 +0,0 @@
-export declare function scrubForRewrite(query: string): string;
-export declare function adaptArrayOperators(query: string): string;
-/**
- * Qualifies unqualified column references in JOIN ON clauses.
- *
- * Transforms patterns like:
- *   `left join "b" on "col" = "col"`
- * To:
- *   `left join "b" on "a"."col" = "b"."col"`
- *
- * This fixes the issue where drizzle-orm generates unqualified column
- * references when joining CTEs with eq().
- */
-export declare function qualifyJoinColumns(query: string): string;