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

package/dist/index.mjs

@@ -1065,22 +1065,30 @@ function getTableSource(from) {
   if ("table" in from && from.table) {
     return {
       name: from.table,
-      alias: from.as ?? null
+      alias: from.as ?? null,
+      schema: "db" in from ? from.db ?? null : null
     };
   }
   if ("expr" in from && from.as) {
     return {
       name: from.as,
-      alias: from.as
+      alias: from.as,
+      schema: null
     };
   }
   return null;
 }
 function getQualifier(source) {
-  return source.alias ?? source.name;
+  return {
+    table: source.alias ?? source.name,
+    schema: source.schema
+  };
 }
 function isUnqualifiedColumnRef(expr) {
-  return typeof expr === "object" && expr !== null && "type" in expr && expr.type === "column_ref" && !(("table" in expr) && expr.table);
+  return typeof expr === "object" && expr !== null && "type" in expr && expr.type === "column_ref" && (!("table" in expr) || !expr.table);
+}
+function isQualifiedColumnRef(expr) {
+  return typeof expr === "object" && expr !== null && "type" in expr && expr.type === "column_ref" && "table" in expr && !!expr.table;
 }
 function getColumnName(col) {
   if (typeof col.column === "string") {
@@ -1091,29 +1099,71 @@ function getColumnName(col) {
   }
   return null;
 }
-function walkOnClause(expr, leftSource, rightSource, ambiguousColumns) {
+function applyQualifier(col, qualifier) {
+  col.table = qualifier.table;
+  if (!("schema" in col) || !col.schema) {
+    col.schema = qualifier.schema;
+  }
+}
+function unwrapColumnRef(expr) {
+  if (!expr || typeof expr !== "object")
+    return null;
+  if ("type" in expr && expr.type === "column_ref") {
+    return expr;
+  }
+  if ("expr" in expr && expr.expr) {
+    return unwrapColumnRef(expr.expr);
+  }
+  if ("ast" in expr && expr.ast && typeof expr.ast === "object") {
+    return null;
+  }
+  if ("args" in expr && expr.args) {
+    const args = expr.args;
+    if (args.expr) {
+      return unwrapColumnRef(args.expr);
+    }
+    if (args.value && args.value.length === 1) {
+      return unwrapColumnRef(args.value[0]);
+    }
+  }
+  return null;
+}
+function isBinaryExpr(expr) {
+  return !!expr && typeof expr === "object" && "type" in expr && expr.type === "binary_expr";
+}
+function walkOnClause(expr, leftQualifier, rightQualifier, ambiguousColumns) {
   if (!expr || typeof expr !== "object")
     return false;
   let transformed = false;
-  if (expr.type === "binary_expr") {
-    if (expr.operator === "=") {
-      const left = expr.left;
-      const right = expr.right;
-      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 (isBinaryExpr(expr)) {
+    const left = expr.left;
+    const right = expr.right;
+    const leftCol = unwrapColumnRef(left);
+    const rightCol = unwrapColumnRef(right);
+    const leftUnqualified = leftCol ? isUnqualifiedColumnRef(leftCol) : false;
+    const rightUnqualified = rightCol ? isUnqualifiedColumnRef(rightCol) : false;
+    const leftQualified = leftCol ? isQualifiedColumnRef(leftCol) : false;
+    const rightQualified = rightCol ? isQualifiedColumnRef(rightCol) : false;
+    const leftColName = leftCol ? getColumnName(leftCol) : null;
+    const rightColName = rightCol ? getColumnName(rightCol) : null;
+    if (expr.operator === "=" && leftColName && rightColName && leftColName === rightColName) {
+      if (leftUnqualified && rightUnqualified) {
+        applyQualifier(leftCol, leftQualifier);
+        applyQualifier(rightCol, rightQualifier);
+        ambiguousColumns.add(leftColName);
+        transformed = true;
+      } else if (leftQualified && rightUnqualified) {
+        applyQualifier(rightCol, rightQualifier);
+        ambiguousColumns.add(rightColName);
+        transformed = true;
+      } else if (leftUnqualified && rightQualified) {
+        applyQualifier(leftCol, leftQualifier);
+        ambiguousColumns.add(leftColName);
+        transformed = true;
       }
     }
-    if (expr.operator === "AND" || expr.operator === "OR") {
-      transformed = walkOnClause(expr.left, leftSource, rightSource, ambiguousColumns) || transformed;
-      transformed = walkOnClause(expr.right, leftSource, rightSource, ambiguousColumns) || transformed;
-    }
+    transformed = walkOnClause(isBinaryExpr(expr.left) ? expr.left : expr.left, leftQualifier, rightQualifier, ambiguousColumns) || transformed;
+    transformed = walkOnClause(isBinaryExpr(expr.right) ? expr.right : expr.right, leftQualifier, rightQualifier, ambiguousColumns) || transformed;
   }
   return transformed;
 }
@@ -1124,12 +1174,12 @@ function qualifyAmbiguousInExpression(expr, defaultQualifier, ambiguousColumns)
   if (isUnqualifiedColumnRef(expr)) {
     const colName = getColumnName(expr);
     if (colName && ambiguousColumns.has(colName)) {
-      expr.table = defaultQualifier;
+      applyQualifier(expr, defaultQualifier);
       transformed = true;
     }
     return transformed;
   }
-  if ("type" in expr && expr.type === "binary_expr") {
+  if (isBinaryExpr(expr)) {
     const binary = expr;
     transformed = qualifyAmbiguousInExpression(binary.left, defaultQualifier, ambiguousColumns) || transformed;
     transformed = qualifyAmbiguousInExpression(binary.right, defaultQualifier, ambiguousColumns) || transformed;
@@ -1146,48 +1196,117 @@ function qualifyAmbiguousInExpression(expr, defaultQualifier, ambiguousColumns)
       transformed = qualifyAmbiguousInExpression(args.expr, defaultQualifier, ambiguousColumns) || transformed;
     }
   }
+  if ("over" in expr && expr.over && typeof expr.over === "object") {
+    const over = expr.over;
+    if (Array.isArray(over.partition)) {
+      for (const part of over.partition) {
+        transformed = qualifyAmbiguousInExpression(part, defaultQualifier, ambiguousColumns) || transformed;
+      }
+    }
+    if (Array.isArray(over.orderby)) {
+      for (const order of over.orderby) {
+        transformed = qualifyAmbiguousInExpression(order, defaultQualifier, ambiguousColumns) || transformed;
+      }
+    }
+  }
   return transformed;
 }
+function hasUnqualifiedColumns(expr) {
+  if (!expr || typeof expr !== "object")
+    return false;
+  if ("type" in expr && expr.type === "binary_expr") {
+    const left = expr.left;
+    const right = expr.right;
+    const leftCol = unwrapColumnRef(left);
+    const rightCol = unwrapColumnRef(right);
+    if (isUnqualifiedColumnRef(left) || isUnqualifiedColumnRef(right) || leftCol && isUnqualifiedColumnRef(leftCol) || rightCol && isUnqualifiedColumnRef(rightCol)) {
+      return true;
+    }
+    if (isBinaryExpr(expr.left) && hasUnqualifiedColumns(expr.left))
+      return true;
+    if (isBinaryExpr(expr.right) && hasUnqualifiedColumns(expr.right))
+      return true;
+  }
+  if ("args" in expr && expr.args) {
+    const args = expr.args;
+    if (args.expr && isUnqualifiedColumnRef(args.expr))
+      return true;
+    if (args.value) {
+      for (const arg of args.value) {
+        if (isUnqualifiedColumnRef(arg))
+          return true;
+      }
+    }
+  }
+  return false;
+}
 function walkSelect(select) {
   let transformed = false;
   const ambiguousColumns = new Set;
   if (Array.isArray(select.from) && select.from.length >= 2) {
     const firstSource = getTableSource(select.from[0]);
-    const defaultQualifier = firstSource ? getQualifier(firstSource) : "";
+    const defaultQualifier = firstSource ? getQualifier(firstSource) : null;
     let prevSource = firstSource;
+    let hasAnyUnqualified = false;
     for (const from of select.from) {
       if ("join" in from) {
         const join = from;
-        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 (join.on && hasUnqualifiedColumns(join.on)) {
+          hasAnyUnqualified = true;
+          break;
         }
       }
-      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) {
-          if ("expr" in col) {
-            transformed = qualifyAmbiguousInExpression(col.expr, defaultQualifier, ambiguousColumns) || transformed;
+    if (!hasAnyUnqualified) {
+      for (const from of select.from) {
+        if ("expr" in from && from.expr && "ast" in from.expr) {
+          transformed = walkSelect(from.expr.ast) || transformed;
+        }
+      }
+    } else {
+      for (const from of select.from) {
+        if ("join" in from) {
+          const join = from;
+          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;
+          }
+          if (join.using && prevSource && currentSource) {
+            for (const usingCol of join.using) {
+              if (typeof usingCol === "string") {
+                ambiguousColumns.add(usingCol);
+              } else if ("value" in usingCol) {
+                ambiguousColumns.add(String(usingCol.value));
+              }
+            }
           }
+          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;
         }
       }
-      transformed = qualifyAmbiguousInExpression(select.where, defaultQualifier, ambiguousColumns) || transformed;
-      if (Array.isArray(select.orderby)) {
-        for (const order of select.orderby) {
-          if (order.expr) {
-            transformed = qualifyAmbiguousInExpression(order.expr, defaultQualifier, ambiguousColumns) || transformed;
+      if (ambiguousColumns.size > 0 && defaultQualifier) {
+        if (Array.isArray(select.columns)) {
+          for (const col of select.columns) {
+            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) {
+            if (order.expr) {
+              transformed = qualifyAmbiguousInExpression(order.expr, defaultQualifier, ambiguousColumns) || transformed;
+            }
           }
         }
       }
@@ -1212,6 +1331,40 @@ function qualifyJoinColumns(ast) {
   for (const stmt of statements) {
     if (stmt.type === "select") {
       transformed = walkSelect(stmt) || transformed;
+    } else if (stmt.type === "insert") {
+      const insert = stmt;
+      if (insert.values && typeof insert.values === "object" && "type" in insert.values && insert.values.type === "select") {
+        transformed = walkSelect(insert.values) || transformed;
+      }
+    } else if (stmt.type === "update") {
+      const update = stmt;
+      const mainSource = update.table?.[0] ? getTableSource(update.table[0]) : null;
+      const defaultQualifier = mainSource ? getQualifier(mainSource) : null;
+      const fromSources = update.from ?? [];
+      const firstFrom = fromSources[0] ? getTableSource(fromSources[0]) : null;
+      if (update.where && defaultQualifier && firstFrom) {
+        const ambiguous = new Set;
+        transformed = walkOnClause(update.where, defaultQualifier, getQualifier(firstFrom), ambiguous) || transformed;
+        transformed = qualifyAmbiguousInExpression(update.where, defaultQualifier, ambiguous) || transformed;
+      }
+      if (Array.isArray(update.returning) && defaultQualifier) {
+        for (const ret of update.returning) {
+          transformed = qualifyAmbiguousInExpression(ret, defaultQualifier, new Set) || transformed;
+        }
+      }
+    } else if (stmt.type === "delete") {
+      const del = stmt;
+      const mainSource = del.table?.[0] ? getTableSource(del.table[0]) : null;
+      const defaultQualifier = mainSource ? getQualifier(mainSource) : null;
+      const fromSources = del.from ?? [];
+      const firstFrom = fromSources[0] ? getTableSource(fromSources[0]) : null;
+      if (del.where && defaultQualifier && firstFrom) {
+        const ambiguous = new Set;
+        transformed = walkOnClause(del.where, defaultQualifier, getQualifier(firstFrom), ambiguous) || transformed;
+        transformed = qualifyAmbiguousInExpression(del.where, defaultQualifier, ambiguous) || transformed;
+      } else if (del.where && defaultQualifier) {
+        transformed = qualifyAmbiguousInExpression(del.where, defaultQualifier, new Set) || transformed;
+      }
     }
   }
   return transformed;
@@ -1220,29 +1373,65 @@ function qualifyJoinColumns(ast) {
 // src/sql/ast-transformer.ts
 var { Parser } = nodeSqlParser;
 var parser = new Parser;
+var CACHE_SIZE = 500;
+var transformCache = new Map;
+function getCachedOrTransform(query, transform) {
+  const cached = transformCache.get(query);
+  if (cached) {
+    transformCache.delete(query);
+    transformCache.set(query, cached);
+    return cached;
+  }
+  const result = transform();
+  if (transformCache.size >= CACHE_SIZE) {
+    const oldestKey = transformCache.keys().next().value;
+    if (oldestKey) {
+      transformCache.delete(oldestKey);
+    }
+  }
+  transformCache.set(query, result);
+  return result;
+}
+var DEBUG_ENV = "DRIZZLE_DUCKDB_DEBUG_AST";
+function hasJoin(query) {
+  return /\bjoin\b/i.test(query);
+}
+function debugLog(message, payload) {
+  if (process?.env?.[DEBUG_ENV]) {
+    console.debug("[duckdb-ast]", message, payload ?? "");
+  }
+}
 function transformSQL(query) {
   const needsArrayTransform = query.includes("@>") || query.includes("<@") || query.includes("&&");
-  const needsJoinTransform = query.toLowerCase().includes("join");
+  const needsJoinTransform = hasJoin(query) || /\bupdate\b/i.test(query) || /\bdelete\b/i.test(query);
   if (!needsArrayTransform && !needsJoinTransform) {
     return { sql: query, transformed: false };
   }
-  try {
-    const ast = parser.astify(query, { database: "PostgreSQL" });
-    let transformed = false;
-    if (needsArrayTransform) {
-      transformed = transformArrayOperators(ast) || transformed;
-    }
-    if (needsJoinTransform) {
-      transformed = qualifyJoinColumns(ast) || transformed;
-    }
-    if (!transformed) {
+  return getCachedOrTransform(query, () => {
+    try {
+      const ast = parser.astify(query, { database: "PostgreSQL" });
+      let transformed = false;
+      if (needsArrayTransform) {
+        transformed = transformArrayOperators(ast) || transformed;
+      }
+      if (needsJoinTransform) {
+        transformed = qualifyJoinColumns(ast) || transformed;
+      }
+      if (!transformed) {
+        debugLog("AST parsed but no transformation applied", {
+          join: needsJoinTransform
+        });
+        return { sql: query, transformed: false };
+      }
+      const transformedSql = parser.sqlify(ast, { database: "PostgreSQL" });
+      return { sql: transformedSql, transformed: true };
+    } catch (err) {
+      debugLog("AST transform failed; returning original SQL", {
+        error: err.message
+      });
       return { sql: query, transformed: false };
     }
-    const transformedSql = parser.sqlify(ast, { database: "PostgreSQL" });
-    return { sql: transformedSql, transformed: true };
-  } catch {
-    return { sql: query, transformed: false };
-  }
+  });
 }
 
 // src/dialect.ts

package/dist/sql/ast-transformer.d.ts

@@ -4,12 +4,28 @@
  * Transforms:
  * - Array operators: @>, <@, && -> array_has_all(), array_has_any()
  * - JOIN column qualification: "col" = "col" -> "left"."col" = "right"."col"
+ *
+ * Performance optimizations:
+ * - LRU cache for transformed queries (avoids re-parsing identical queries)
+ * - Smart heuristics to skip JOIN qualification when not needed
+ * - Early exit when no transformation is required
  */
 export type TransformResult = {
     sql: string;
     transformed: boolean;
 };
 export declare function transformSQL(query: string): TransformResult;
+/**
+ * Clear the transformation cache. Useful for testing or memory management.
+ */
+export declare function clearTransformCache(): void;
+/**
+ * Get current cache statistics for monitoring.
+ */
+export declare function getTransformCacheStats(): {
+    size: number;
+    maxSize: number;
+};
 export declare function needsTransformation(query: string): boolean;
 export { transformArrayOperators } from './visitors/array-operators.ts';
 export { qualifyJoinColumns } from './visitors/column-qualifier.ts';

package/dist/sql/visitors/column-qualifier.d.ts

@@ -1,5 +1,10 @@
 /**
  * AST visitor to qualify unqualified column references in JOIN ON clauses.
+ *
+ * Performance optimizations:
+ * - Early exit when no unqualified columns found in ON clause
+ * - Skip processing if all columns are already qualified
+ * - Minimal tree traversal when possible
  */
 import type { AST } from 'node-sql-parser';
 export declare function qualifyJoinColumns(ast: AST | AST[]): boolean;

package/package.json

@@ -3,7 +3,7 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "A drizzle ORM client for use with DuckDB. Based on drizzle's Postgres client.",
   "type": "module",
   "scripts": {
@@ -11,7 +11,7 @@
     "build:declarations": "tsc --emitDeclarationOnly --project tsconfig.types.json",
     "test": "vitest",
     "t": "vitest --watch --ui",
-    "bench": "vitest bench --runInBand test/perf",
+    "bench": "vitest bench --run test/perf --pool=threads --poolOptions.threads.singleThread=true --no-file-parallelism",
     "perf:run": "bun run scripts/run-perf.ts",
     "perf:compare": "bun run scripts/compare-perf.ts"
   },

package/src/sql/ast-transformer.ts

@@ -4,6 +4,11 @@
  * Transforms:
  * - Array operators: @>, <@, && -> array_has_all(), array_has_any()
  * - JOIN column qualification: "col" = "col" -> "left"."col" = "right"."col"
+ *
+ * Performance optimizations:
+ * - LRU cache for transformed queries (avoids re-parsing identical queries)
+ * - Smart heuristics to skip JOIN qualification when not needed
+ * - Early exit when no transformation is required
  */
 
 import nodeSqlParser from 'node-sql-parser';
@@ -20,38 +25,107 @@ export type TransformResult = {
   transformed: boolean;
 };
 
+// LRU cache for transformed SQL queries
+// Key: original SQL, Value: transformed result
+const CACHE_SIZE = 500;
+const transformCache = new Map<string, TransformResult>();
+
+function getCachedOrTransform(
+  query: string,
+  transform: () => TransformResult
+): TransformResult {
+  const cached = transformCache.get(query);
+  if (cached) {
+    // Move to end for LRU behavior
+    transformCache.delete(query);
+    transformCache.set(query, cached);
+    return cached;
+  }
+
+  const result = transform();
+
+  // Add to cache with LRU eviction
+  if (transformCache.size >= CACHE_SIZE) {
+    // Delete oldest entry (first key in Map iteration order)
+    const oldestKey = transformCache.keys().next().value;
+    if (oldestKey) {
+      transformCache.delete(oldestKey);
+    }
+  }
+  transformCache.set(query, result);
+
+  return result;
+}
+
+const DEBUG_ENV = 'DRIZZLE_DUCKDB_DEBUG_AST';
+
+function hasJoin(query: string): boolean {
+  return /\bjoin\b/i.test(query);
+}
+
+function debugLog(message: string, payload?: unknown): void {
+  if (process?.env?.[DEBUG_ENV]) {
+    // eslint-disable-next-line no-console
+    console.debug('[duckdb-ast]', message, payload ?? '');
+  }
+}
+
 export function transformSQL(query: string): TransformResult {
   const needsArrayTransform =
     query.includes('@>') || query.includes('<@') || query.includes('&&');
-  const needsJoinTransform = query.toLowerCase().includes('join');
+  const needsJoinTransform =
+    hasJoin(query) || /\bupdate\b/i.test(query) || /\bdelete\b/i.test(query);
 
   if (!needsArrayTransform && !needsJoinTransform) {
     return { sql: query, transformed: false };
   }
 
-  try {
-    const ast = parser.astify(query, { database: 'PostgreSQL' });
+  // Use cache for repeated queries
+  return getCachedOrTransform(query, () => {
+    try {
+      const ast = parser.astify(query, { database: 'PostgreSQL' });
 
-    let transformed = false;
+      let transformed = false;
 
-    if (needsArrayTransform) {
-      transformed = transformArrayOperators(ast) || transformed;
-    }
+      if (needsArrayTransform) {
+        transformed = transformArrayOperators(ast) || transformed;
+      }
 
-    if (needsJoinTransform) {
-      transformed = qualifyJoinColumns(ast) || transformed;
-    }
+      if (needsJoinTransform) {
+        transformed = qualifyJoinColumns(ast) || transformed;
+      }
 
-    if (!transformed) {
+      if (!transformed) {
+        debugLog('AST parsed but no transformation applied', {
+          join: needsJoinTransform,
+        });
+        return { sql: query, transformed: false };
+      }
+
+      const transformedSql = parser.sqlify(ast, { database: 'PostgreSQL' });
+
+      return { sql: transformedSql, transformed: true };
+    } catch (err) {
+      debugLog('AST transform failed; returning original SQL', {
+        error: (err as Error).message,
+      });
       return { sql: query, transformed: false };
     }
+  });
+}
 
-    const transformedSql = parser.sqlify(ast, { database: 'PostgreSQL' });
+/**
+ * Clear the transformation cache. Useful for testing or memory management.
+ */
+export function clearTransformCache(): void {
+  transformCache.clear();
+}
 
-    return { sql: transformedSql, transformed: true };
-  } catch {
-    return { sql: query, transformed: false };
-  }
+/**
+ * Get current cache statistics for monitoring.
+ */
+export function getTransformCacheStats(): { size: number; maxSize: number } {
+  return { size: transformCache.size, maxSize: CACHE_SIZE };
 }
 
 export function needsTransformation(query: string): boolean {
@@ -60,7 +134,9 @@ export function needsTransformation(query: string): boolean {
     query.includes('@>') ||
     query.includes('<@') ||
     query.includes('&&') ||
-    lower.includes('join')
+    lower.includes('join') ||
+    lower.includes('update') ||
+    lower.includes('delete')
   );
 }