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

package/dist/duckdb-introspect.mjs

@@ -4,7 +4,7 @@
 import { DuckDBInstance as DuckDBInstance3 } from "@duckdb/node-api";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
-import process from "node:process";
+import process2 from "node:process";
 
 // src/driver.ts
 import { DuckDBInstance as DuckDBInstance2 } from "@duckdb/node-api";
@@ -1014,22 +1014,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") {
@@ -1040,29 +1048,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;
 }
@@ -1073,12 +1123,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;
@@ -1095,48 +1145,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;
+            }
           }
         }
       }
@@ -1161,6 +1280,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;
@@ -1169,29 +1322,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
@@ -2269,7 +2458,7 @@ function renderImports(imports, importBasePath) {
 // src/bin/duckdb-introspect.ts
 function parseArgs(argv) {
   const options = {
-    outFile: path.resolve(process.cwd(), "drizzle/schema.ts"),
+    outFile: path.resolve(process2.cwd(), "drizzle/schema.ts"),
     outMeta: undefined,
     allDatabases: false,
     includeViews: false,
@@ -2294,12 +2483,12 @@ function parseArgs(argv) {
         break;
       case "--out":
       case "--outFile":
-        options.outFile = path.resolve(process.cwd(), argv[++i] ?? "drizzle/schema.ts");
+        options.outFile = path.resolve(process2.cwd(), argv[++i] ?? "drizzle/schema.ts");
         break;
       case "--out-json":
       case "--outJson":
       case "--json":
-        options.outMeta = path.resolve(process.cwd(), argv[++i] ?? "drizzle/schema.meta.json");
+        options.outMeta = path.resolve(process2.cwd(), argv[++i] ?? "drizzle/schema.meta.json");
         break;
       case "--include-views":
       case "--includeViews":
@@ -2314,7 +2503,7 @@ function parseArgs(argv) {
       case "--help":
       case "-h":
         printHelp();
-        process.exit(0);
+        process2.exit(0);
       default:
         if (arg.startsWith("-")) {
           console.warn(`Unknown option ${arg}`);
@@ -2356,12 +2545,12 @@ Examples:
 `);
 }
 async function main() {
-  const options = parseArgs(process.argv.slice(2));
+  const options = parseArgs(process2.argv.slice(2));
   if (!options.url) {
     printHelp();
     throw new Error("Missing required --url");
   }
-  const instanceOptions = options.url.startsWith("md:") && process.env.MOTHERDUCK_TOKEN ? { motherduck_token: process.env.MOTHERDUCK_TOKEN } : undefined;
+  const instanceOptions = options.url.startsWith("md:") && process2.env.MOTHERDUCK_TOKEN ? { motherduck_token: process2.env.MOTHERDUCK_TOKEN } : undefined;
   const instance = await DuckDBInstance3.create(options.url, instanceOptions);
   const connection = await instance.connect();
   const db = drizzle(connection);
@@ -2397,5 +2586,5 @@ async function main() {
 }
 main().catch((err) => {
   console.error(err instanceof Error ? err.message : err);
-  process.exit(1);
+  process2.exit(1);
 });