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

package/README.md

@@ -40,6 +40,7 @@ pnpm add @leonardovida-md/drizzle-neo-duckdb @duckdb/node-api
 ```typescript
 import { DuckDBInstance } from '@duckdb/node-api';
 import { drizzle } from '@leonardovida-md/drizzle-neo-duckdb';
+import { sql } from 'drizzle-orm';
 import { integer, text, pgTable } from 'drizzle-orm/pg-core';
 
 // Connect to DuckDB
@@ -149,7 +150,7 @@ const db = drizzle(pool);
 ## Schema & Types
 
 - Use `drizzle-orm/pg-core` for schemas; DuckDB SQL is largely Postgres-compatible.
-- DuckDB-specific helpers: `duckDbList`, `duckDbArray`, `duckDbStruct`, `duckDbMap`, `duckDbJson`, `duckDbTimestamp`, `duckDbDate`, `duckDbTime`.
+- DuckDB-specific helpers: `duckDbList`, `duckDbArray`, `duckDbStruct`, `duckDbMap`, `duckDbJson`, `duckDbBlob`, `duckDbInet`, `duckDbInterval`, `duckDbTimestamp`, `duckDbDate`, `duckDbTime`.
 - Browser-safe imports live under `@leonardovida-md/drizzle-neo-duckdb/helpers` (introspection emits this path).
 
 See the [column types](https://leonardovida.github.io/drizzle-neo-duckdb/api/columns) docs for full API.

package/dist/duckdb-introspect.mjs

@@ -1111,6 +1111,15 @@ function walkOnClause(expr, leftQualifier, rightQualifier, ambiguousColumns) {
         transformed = true;
       }
     }
+    if (expr.operator === "=" && leftCol && rightCol && leftColName && rightColName && leftColName !== rightColName) {
+      if (leftQualified && rightUnqualified && !rightColName.includes(".")) {
+        applyQualifier(rightCol, rightQualifier);
+        transformed = true;
+      } else if (leftUnqualified && rightQualified && !leftColName.includes(".")) {
+        applyQualifier(leftCol, leftQualifier);
+        transformed = true;
+      }
+    }
     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;
   }
@@ -1319,6 +1328,289 @@ function qualifyJoinColumns(ast) {
   return transformed;
 }
 
+// src/sql/visitors/generate-series-alias.ts
+function getColumnName2(col) {
+  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 isColumnRef(expr) {
+  return typeof expr === "object" && expr !== null && "type" in expr && expr.type === "column_ref";
+}
+function isBinaryExpr2(expr) {
+  return !!expr && typeof expr === "object" && "type" in expr && expr.type === "binary_expr";
+}
+function getGenerateSeriesAliases(from) {
+  const aliases = new Set;
+  if (!from || !Array.isArray(from))
+    return aliases;
+  for (const f of from) {
+    if ("expr" in f && f.expr && typeof f.expr === "object") {
+      const exprObj = f.expr;
+      if (exprObj.type === "function" && "name" in exprObj) {
+        const nameObj = exprObj.name;
+        const nameParts = nameObj?.name;
+        const fnName = nameParts?.[0]?.value;
+        if (typeof fnName === "string" && fnName.toLowerCase() === "generate_series") {
+          const alias = typeof f.as === "string" ? f.as : null;
+          if (alias && !alias.includes("(")) {
+            aliases.add(alias);
+          }
+        }
+      }
+    }
+  }
+  return aliases;
+}
+function rewriteAliasColumnRef(col, alias) {
+  col.table = alias;
+  col.column = { expr: { type: "default", value: "generate_series" } };
+}
+function walkExpression2(expr, aliases) {
+  if (!expr || typeof expr !== "object")
+    return false;
+  let transformed = false;
+  const exprObj = expr;
+  if (isColumnRef(expr)) {
+    if (!("table" in expr) || !expr.table) {
+      const colName = getColumnName2(expr);
+      if (colName && aliases.has(colName)) {
+        rewriteAliasColumnRef(expr, colName);
+        transformed = true;
+      }
+    }
+    return transformed;
+  }
+  if (isBinaryExpr2(expr)) {
+    const binary = expr;
+    transformed = walkExpression2(binary.left, aliases) || transformed;
+    transformed = walkExpression2(binary.right, aliases) || transformed;
+    return transformed;
+  }
+  if (exprObj.type === "unary_expr" && exprObj.expr) {
+    transformed = walkExpression2(exprObj.expr, aliases) || transformed;
+  }
+  if (exprObj.type === "cast" && exprObj.expr) {
+    transformed = walkExpression2(exprObj.expr, aliases) || transformed;
+  }
+  if (exprObj.type === "case") {
+    if (exprObj.expr) {
+      transformed = walkExpression2(exprObj.expr, aliases) || transformed;
+    }
+    if (Array.isArray(exprObj.args)) {
+      for (const whenClause of exprObj.args) {
+        if (whenClause.cond) {
+          transformed = walkExpression2(whenClause.cond, aliases) || transformed;
+        }
+        if (whenClause.result) {
+          transformed = walkExpression2(whenClause.result, aliases) || transformed;
+        }
+      }
+    }
+  }
+  if ("args" in exprObj && exprObj.args) {
+    const args = exprObj.args;
+    if (Array.isArray(args.value)) {
+      for (const arg of args.value) {
+        transformed = walkExpression2(arg, aliases) || transformed;
+      }
+    } else if (args.expr) {
+      transformed = walkExpression2(args.expr, aliases) || transformed;
+    }
+  }
+  if ("over" in exprObj && exprObj.over && typeof exprObj.over === "object") {
+    const over = exprObj.over;
+    if (Array.isArray(over.partition)) {
+      for (const part of over.partition) {
+        transformed = walkExpression2(part, aliases) || transformed;
+      }
+    }
+    if (Array.isArray(over.orderby)) {
+      for (const order of over.orderby) {
+        transformed = walkExpression2(order, aliases) || transformed;
+      }
+    }
+  }
+  if ("ast" in exprObj && exprObj.ast) {
+    const subAst = exprObj.ast;
+    if (subAst.type === "select") {
+      transformed = walkSelect2(subAst) || transformed;
+    }
+  }
+  if (exprObj.type === "expr_list" && Array.isArray(exprObj.value)) {
+    for (const item of exprObj.value) {
+      transformed = walkExpression2(item, aliases) || transformed;
+    }
+  }
+  return transformed;
+}
+function walkFrom2(from, aliases) {
+  if (!from || !Array.isArray(from))
+    return false;
+  let transformed = false;
+  for (const f of from) {
+    if ("join" in f) {
+      const join = f;
+      transformed = walkExpression2(join.on, aliases) || transformed;
+    }
+    if ("expr" in f && f.expr && "ast" in f.expr) {
+      transformed = walkSelect2(f.expr.ast) || transformed;
+    }
+  }
+  return transformed;
+}
+function walkSelect2(select) {
+  let transformed = false;
+  const aliases = getGenerateSeriesAliases(select.from);
+  if (select.with) {
+    for (const cte of select.with) {
+      const cteSelect = cte.stmt?.ast ?? cte.stmt;
+      if (cteSelect && cteSelect.type === "select") {
+        transformed = walkSelect2(cteSelect) || transformed;
+      }
+    }
+  }
+  transformed = walkFrom2(select.from, aliases) || transformed;
+  transformed = walkExpression2(select.where, aliases) || transformed;
+  if (select.having) {
+    if (Array.isArray(select.having)) {
+      for (const h of select.having) {
+        transformed = walkExpression2(h, aliases) || transformed;
+      }
+    } else {
+      transformed = walkExpression2(select.having, aliases) || transformed;
+    }
+  }
+  if (Array.isArray(select.columns)) {
+    for (const col of select.columns) {
+      if ("expr" in col) {
+        transformed = walkExpression2(col.expr, aliases) || transformed;
+      }
+    }
+  }
+  if (Array.isArray(select.groupby)) {
+    for (const g of select.groupby) {
+      transformed = walkExpression2(g, aliases) || transformed;
+    }
+  }
+  if (Array.isArray(select.orderby)) {
+    for (const order of select.orderby) {
+      if (order.expr) {
+        transformed = walkExpression2(order.expr, aliases) || transformed;
+      }
+    }
+  }
+  if (select._orderby) {
+    for (const order of select._orderby) {
+      if (order.expr) {
+        transformed = walkExpression2(order.expr, aliases) || transformed;
+      }
+    }
+  }
+  if (select._next) {
+    transformed = walkSelect2(select._next) || transformed;
+  }
+  return transformed;
+}
+function rewriteGenerateSeriesAliases(ast) {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+  for (const stmt of statements) {
+    if (stmt.type === "select") {
+      transformed = walkSelect2(stmt) || transformed;
+    }
+  }
+  return transformed;
+}
+
+// src/sql/visitors/union-with-hoister.ts
+function getCteName(cte) {
+  const nameObj = cte.name;
+  if (!nameObj)
+    return null;
+  const value = nameObj.value;
+  if (typeof value === "string")
+    return value;
+  return null;
+}
+function hoistWithInSelect(select) {
+  if (!select.set_op || !select._next)
+    return false;
+  const arms = [];
+  let current = select;
+  while (current && current.type === "select") {
+    arms.push(current);
+    current = current._next;
+  }
+  const mergedWith = [];
+  const seen = new Set;
+  let hasWithBeyondFirst = false;
+  for (const arm of arms) {
+    if (arm.with && arm.with.length > 0) {
+      if (arm !== arms[0]) {
+        hasWithBeyondFirst = true;
+      }
+      for (const cte of arm.with) {
+        const cteName = getCteName(cte);
+        if (!cteName)
+          return false;
+        if (seen.has(cteName)) {
+          return false;
+        }
+        seen.add(cteName);
+        mergedWith.push(cte);
+      }
+    }
+  }
+  if (!hasWithBeyondFirst)
+    return false;
+  arms[0].with = mergedWith;
+  if ("parentheses_symbol" in arms[0]) {
+    arms[0].parentheses_symbol = false;
+  }
+  for (let i = 1;i < arms.length; i++) {
+    arms[i].with = null;
+  }
+  return true;
+}
+function walkSelect3(select) {
+  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 = walkSelect3(cteSelect) || transformed;
+      }
+    }
+  }
+  if (Array.isArray(select.from)) {
+    for (const from of select.from) {
+      if ("expr" in from && from.expr && "ast" in from.expr) {
+        transformed = walkSelect3(from.expr.ast) || transformed;
+      }
+    }
+  }
+  transformed = hoistWithInSelect(select) || transformed;
+  if (select._next) {
+    transformed = walkSelect3(select._next) || transformed;
+  }
+  return transformed;
+}
+function hoistUnionWith(ast) {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+  for (const stmt of statements) {
+    if (stmt.type === "select") {
+      transformed = walkSelect3(stmt) || transformed;
+    }
+  }
+  return transformed;
+}
+
 // src/sql/ast-transformer.ts
 var { Parser } = nodeSqlParser;
 var parser = new Parser;
@@ -1353,7 +1645,9 @@ function debugLog(message, payload) {
 function transformSQL(query) {
   const needsArrayTransform = query.includes("@>") || query.includes("<@") || query.includes("&&");
   const needsJoinTransform = hasJoin(query) || /\bupdate\b/i.test(query) || /\bdelete\b/i.test(query);
-  if (!needsArrayTransform && !needsJoinTransform) {
+  const needsUnionTransform = /\bunion\b/i.test(query) || /\bintersect\b/i.test(query) || /\bexcept\b/i.test(query);
+  const needsGenerateSeriesTransform = /\bgenerate_series\b/i.test(query);
+  if (!needsArrayTransform && !needsJoinTransform && !needsUnionTransform && !needsGenerateSeriesTransform) {
     return { sql: query, transformed: false };
   }
   return getCachedOrTransform(query, () => {
@@ -1366,6 +1660,12 @@ function transformSQL(query) {
       if (needsJoinTransform) {
         transformed = qualifyJoinColumns(ast) || transformed;
       }
+      if (needsGenerateSeriesTransform) {
+        transformed = rewriteGenerateSeriesAliases(ast) || transformed;
+      }
+      if (needsUnionTransform) {
+        transformed = hoistUnionWith(ast) || transformed;
+      }
       if (!transformed) {
         debugLog("AST parsed but no transformation applied", {
           join: needsJoinTransform

package/dist/index.mjs

@@ -1162,6 +1162,15 @@ function walkOnClause(expr, leftQualifier, rightQualifier, ambiguousColumns) {
         transformed = true;
       }
     }
+    if (expr.operator === "=" && leftCol && rightCol && leftColName && rightColName && leftColName !== rightColName) {
+      if (leftQualified && rightUnqualified && !rightColName.includes(".")) {
+        applyQualifier(rightCol, rightQualifier);
+        transformed = true;
+      } else if (leftUnqualified && rightQualified && !leftColName.includes(".")) {
+        applyQualifier(leftCol, leftQualifier);
+        transformed = true;
+      }
+    }
     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;
   }
@@ -1370,6 +1379,289 @@ function qualifyJoinColumns(ast) {
   return transformed;
 }
 
+// src/sql/visitors/generate-series-alias.ts
+function getColumnName2(col) {
+  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 isColumnRef(expr) {
+  return typeof expr === "object" && expr !== null && "type" in expr && expr.type === "column_ref";
+}
+function isBinaryExpr2(expr) {
+  return !!expr && typeof expr === "object" && "type" in expr && expr.type === "binary_expr";
+}
+function getGenerateSeriesAliases(from) {
+  const aliases = new Set;
+  if (!from || !Array.isArray(from))
+    return aliases;
+  for (const f of from) {
+    if ("expr" in f && f.expr && typeof f.expr === "object") {
+      const exprObj = f.expr;
+      if (exprObj.type === "function" && "name" in exprObj) {
+        const nameObj = exprObj.name;
+        const nameParts = nameObj?.name;
+        const fnName = nameParts?.[0]?.value;
+        if (typeof fnName === "string" && fnName.toLowerCase() === "generate_series") {
+          const alias = typeof f.as === "string" ? f.as : null;
+          if (alias && !alias.includes("(")) {
+            aliases.add(alias);
+          }
+        }
+      }
+    }
+  }
+  return aliases;
+}
+function rewriteAliasColumnRef(col, alias) {
+  col.table = alias;
+  col.column = { expr: { type: "default", value: "generate_series" } };
+}
+function walkExpression2(expr, aliases) {
+  if (!expr || typeof expr !== "object")
+    return false;
+  let transformed = false;
+  const exprObj = expr;
+  if (isColumnRef(expr)) {
+    if (!("table" in expr) || !expr.table) {
+      const colName = getColumnName2(expr);
+      if (colName && aliases.has(colName)) {
+        rewriteAliasColumnRef(expr, colName);
+        transformed = true;
+      }
+    }
+    return transformed;
+  }
+  if (isBinaryExpr2(expr)) {
+    const binary = expr;
+    transformed = walkExpression2(binary.left, aliases) || transformed;
+    transformed = walkExpression2(binary.right, aliases) || transformed;
+    return transformed;
+  }
+  if (exprObj.type === "unary_expr" && exprObj.expr) {
+    transformed = walkExpression2(exprObj.expr, aliases) || transformed;
+  }
+  if (exprObj.type === "cast" && exprObj.expr) {
+    transformed = walkExpression2(exprObj.expr, aliases) || transformed;
+  }
+  if (exprObj.type === "case") {
+    if (exprObj.expr) {
+      transformed = walkExpression2(exprObj.expr, aliases) || transformed;
+    }
+    if (Array.isArray(exprObj.args)) {
+      for (const whenClause of exprObj.args) {
+        if (whenClause.cond) {
+          transformed = walkExpression2(whenClause.cond, aliases) || transformed;
+        }
+        if (whenClause.result) {
+          transformed = walkExpression2(whenClause.result, aliases) || transformed;
+        }
+      }
+    }
+  }
+  if ("args" in exprObj && exprObj.args) {
+    const args = exprObj.args;
+    if (Array.isArray(args.value)) {
+      for (const arg of args.value) {
+        transformed = walkExpression2(arg, aliases) || transformed;
+      }
+    } else if (args.expr) {
+      transformed = walkExpression2(args.expr, aliases) || transformed;
+    }
+  }
+  if ("over" in exprObj && exprObj.over && typeof exprObj.over === "object") {
+    const over = exprObj.over;
+    if (Array.isArray(over.partition)) {
+      for (const part of over.partition) {
+        transformed = walkExpression2(part, aliases) || transformed;
+      }
+    }
+    if (Array.isArray(over.orderby)) {
+      for (const order of over.orderby) {
+        transformed = walkExpression2(order, aliases) || transformed;
+      }
+    }
+  }
+  if ("ast" in exprObj && exprObj.ast) {
+    const subAst = exprObj.ast;
+    if (subAst.type === "select") {
+      transformed = walkSelect2(subAst) || transformed;
+    }
+  }
+  if (exprObj.type === "expr_list" && Array.isArray(exprObj.value)) {
+    for (const item of exprObj.value) {
+      transformed = walkExpression2(item, aliases) || transformed;
+    }
+  }
+  return transformed;
+}
+function walkFrom2(from, aliases) {
+  if (!from || !Array.isArray(from))
+    return false;
+  let transformed = false;
+  for (const f of from) {
+    if ("join" in f) {
+      const join = f;
+      transformed = walkExpression2(join.on, aliases) || transformed;
+    }
+    if ("expr" in f && f.expr && "ast" in f.expr) {
+      transformed = walkSelect2(f.expr.ast) || transformed;
+    }
+  }
+  return transformed;
+}
+function walkSelect2(select) {
+  let transformed = false;
+  const aliases = getGenerateSeriesAliases(select.from);
+  if (select.with) {
+    for (const cte of select.with) {
+      const cteSelect = cte.stmt?.ast ?? cte.stmt;
+      if (cteSelect && cteSelect.type === "select") {
+        transformed = walkSelect2(cteSelect) || transformed;
+      }
+    }
+  }
+  transformed = walkFrom2(select.from, aliases) || transformed;
+  transformed = walkExpression2(select.where, aliases) || transformed;
+  if (select.having) {
+    if (Array.isArray(select.having)) {
+      for (const h of select.having) {
+        transformed = walkExpression2(h, aliases) || transformed;
+      }
+    } else {
+      transformed = walkExpression2(select.having, aliases) || transformed;
+    }
+  }
+  if (Array.isArray(select.columns)) {
+    for (const col of select.columns) {
+      if ("expr" in col) {
+        transformed = walkExpression2(col.expr, aliases) || transformed;
+      }
+    }
+  }
+  if (Array.isArray(select.groupby)) {
+    for (const g of select.groupby) {
+      transformed = walkExpression2(g, aliases) || transformed;
+    }
+  }
+  if (Array.isArray(select.orderby)) {
+    for (const order of select.orderby) {
+      if (order.expr) {
+        transformed = walkExpression2(order.expr, aliases) || transformed;
+      }
+    }
+  }
+  if (select._orderby) {
+    for (const order of select._orderby) {
+      if (order.expr) {
+        transformed = walkExpression2(order.expr, aliases) || transformed;
+      }
+    }
+  }
+  if (select._next) {
+    transformed = walkSelect2(select._next) || transformed;
+  }
+  return transformed;
+}
+function rewriteGenerateSeriesAliases(ast) {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+  for (const stmt of statements) {
+    if (stmt.type === "select") {
+      transformed = walkSelect2(stmt) || transformed;
+    }
+  }
+  return transformed;
+}
+
+// src/sql/visitors/union-with-hoister.ts
+function getCteName(cte) {
+  const nameObj = cte.name;
+  if (!nameObj)
+    return null;
+  const value = nameObj.value;
+  if (typeof value === "string")
+    return value;
+  return null;
+}
+function hoistWithInSelect(select) {
+  if (!select.set_op || !select._next)
+    return false;
+  const arms = [];
+  let current = select;
+  while (current && current.type === "select") {
+    arms.push(current);
+    current = current._next;
+  }
+  const mergedWith = [];
+  const seen = new Set;
+  let hasWithBeyondFirst = false;
+  for (const arm of arms) {
+    if (arm.with && arm.with.length > 0) {
+      if (arm !== arms[0]) {
+        hasWithBeyondFirst = true;
+      }
+      for (const cte of arm.with) {
+        const cteName = getCteName(cte);
+        if (!cteName)
+          return false;
+        if (seen.has(cteName)) {
+          return false;
+        }
+        seen.add(cteName);
+        mergedWith.push(cte);
+      }
+    }
+  }
+  if (!hasWithBeyondFirst)
+    return false;
+  arms[0].with = mergedWith;
+  if ("parentheses_symbol" in arms[0]) {
+    arms[0].parentheses_symbol = false;
+  }
+  for (let i = 1;i < arms.length; i++) {
+    arms[i].with = null;
+  }
+  return true;
+}
+function walkSelect3(select) {
+  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 = walkSelect3(cteSelect) || transformed;
+      }
+    }
+  }
+  if (Array.isArray(select.from)) {
+    for (const from of select.from) {
+      if ("expr" in from && from.expr && "ast" in from.expr) {
+        transformed = walkSelect3(from.expr.ast) || transformed;
+      }
+    }
+  }
+  transformed = hoistWithInSelect(select) || transformed;
+  if (select._next) {
+    transformed = walkSelect3(select._next) || transformed;
+  }
+  return transformed;
+}
+function hoistUnionWith(ast) {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+  for (const stmt of statements) {
+    if (stmt.type === "select") {
+      transformed = walkSelect3(stmt) || transformed;
+    }
+  }
+  return transformed;
+}
+
 // src/sql/ast-transformer.ts
 var { Parser } = nodeSqlParser;
 var parser = new Parser;
@@ -1404,7 +1696,9 @@ function debugLog(message, payload) {
 function transformSQL(query) {
   const needsArrayTransform = query.includes("@>") || query.includes("<@") || query.includes("&&");
   const needsJoinTransform = hasJoin(query) || /\bupdate\b/i.test(query) || /\bdelete\b/i.test(query);
-  if (!needsArrayTransform && !needsJoinTransform) {
+  const needsUnionTransform = /\bunion\b/i.test(query) || /\bintersect\b/i.test(query) || /\bexcept\b/i.test(query);
+  const needsGenerateSeriesTransform = /\bgenerate_series\b/i.test(query);
+  if (!needsArrayTransform && !needsJoinTransform && !needsUnionTransform && !needsGenerateSeriesTransform) {
     return { sql: query, transformed: false };
   }
   return getCachedOrTransform(query, () => {
@@ -1417,6 +1711,12 @@ function transformSQL(query) {
       if (needsJoinTransform) {
         transformed = qualifyJoinColumns(ast) || transformed;
       }
+      if (needsGenerateSeriesTransform) {
+        transformed = rewriteGenerateSeriesAliases(ast) || transformed;
+      }
+      if (needsUnionTransform) {
+        transformed = hoistUnionWith(ast) || transformed;
+      }
       if (!transformed) {
         debugLog("AST parsed but no transformation applied", {
           join: needsJoinTransform

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

@@ -29,3 +29,5 @@ export declare function getTransformCacheStats(): {
 export declare function needsTransformation(query: string): boolean;
 export { transformArrayOperators } from './visitors/array-operators.ts';
 export { qualifyJoinColumns } from './visitors/column-qualifier.ts';
+export { rewriteGenerateSeriesAliases } from './visitors/generate-series-alias.ts';
+export { hoistUnionWith } from './visitors/union-with-hoister.ts';

package/dist/sql/visitors/generate-series-alias.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AST visitor to rewrite Postgres style generate_series aliases.
+ *
+ * Postgres lets you reference a generate_series alias as a column:
+ *   FROM generate_series(...) AS gs
+ *   SELECT gs::date
+ *
+ * DuckDB treats gs as a table alias, and the column is generate_series.
+ * This visitor rewrites unqualified column refs that match a
+ * generate_series alias to gs.generate_series.
+ */
+import type { AST } from 'node-sql-parser';
+export declare function rewriteGenerateSeriesAliases(ast: AST | AST[]): boolean;

package/dist/sql/visitors/union-with-hoister.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AST visitor to hoist WITH clauses out of UNION and other set operations.
+ *
+ * Drizzle can emit SQL like:
+ *   (with a as (...) select ...) union (with b as (...) select ...)
+ *
+ * DuckDB 1.4.x has an internal binder bug for this pattern.
+ * We merge per arm CTEs into a single top level WITH when names do not collide.
+ */
+import type { AST } from 'node-sql-parser';
+export declare function hoistUnionWith(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.1",
+  "version": "1.2.2",
   "description": "A drizzle ORM client for use with DuckDB. Based on drizzle's Postgres client.",
   "type": "module",
   "scripts": {

package/src/sql/ast-transformer.ts

@@ -17,6 +17,8 @@ import type { AST } from 'node-sql-parser';
 
 import { transformArrayOperators } from './visitors/array-operators.ts';
 import { qualifyJoinColumns } from './visitors/column-qualifier.ts';
+import { rewriteGenerateSeriesAliases } from './visitors/generate-series-alias.ts';
+import { hoistUnionWith } from './visitors/union-with-hoister.ts';
 
 const parser = new Parser();
 
@@ -75,8 +77,18 @@ export function transformSQL(query: string): TransformResult {
     query.includes('@>') || query.includes('<@') || query.includes('&&');
   const needsJoinTransform =
     hasJoin(query) || /\bupdate\b/i.test(query) || /\bdelete\b/i.test(query);
-
-  if (!needsArrayTransform && !needsJoinTransform) {
+  const needsUnionTransform =
+    /\bunion\b/i.test(query) ||
+    /\bintersect\b/i.test(query) ||
+    /\bexcept\b/i.test(query);
+  const needsGenerateSeriesTransform = /\bgenerate_series\b/i.test(query);
+
+  if (
+    !needsArrayTransform &&
+    !needsJoinTransform &&
+    !needsUnionTransform &&
+    !needsGenerateSeriesTransform
+  ) {
     return { sql: query, transformed: false };
   }
 
@@ -95,6 +107,14 @@ export function transformSQL(query: string): TransformResult {
         transformed = qualifyJoinColumns(ast) || transformed;
       }
 
+      if (needsGenerateSeriesTransform) {
+        transformed = rewriteGenerateSeriesAliases(ast) || transformed;
+      }
+
+      if (needsUnionTransform) {
+        transformed = hoistUnionWith(ast) || transformed;
+      }
+
       if (!transformed) {
         debugLog('AST parsed but no transformation applied', {
           join: needsJoinTransform,
@@ -135,6 +155,10 @@ export function needsTransformation(query: string): boolean {
     query.includes('<@') ||
     query.includes('&&') ||
     lower.includes('join') ||
+    lower.includes('union') ||
+    lower.includes('intersect') ||
+    lower.includes('except') ||
+    lower.includes('generate_series') ||
     lower.includes('update') ||
     lower.includes('delete')
   );
@@ -142,3 +166,5 @@ export function needsTransformation(query: string): boolean {
 
 export { transformArrayOperators } from './visitors/array-operators.ts';
 export { qualifyJoinColumns } from './visitors/column-qualifier.ts';
+export { rewriteGenerateSeriesAliases } from './visitors/generate-series-alias.ts';
+export { hoistUnionWith } from './visitors/union-with-hoister.ts';

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

@@ -181,6 +181,27 @@ function walkOnClause(
       }
     }
 
+    if (
+      expr.operator === '=' &&
+      leftCol &&
+      rightCol &&
+      leftColName &&
+      rightColName &&
+      leftColName !== rightColName
+    ) {
+      if (leftQualified && rightUnqualified && !rightColName.includes('.')) {
+        applyQualifier(rightCol, rightQualifier);
+        transformed = true;
+      } else if (
+        leftUnqualified &&
+        rightQualified &&
+        !leftColName.includes('.')
+      ) {
+        applyQualifier(leftCol, leftQualifier);
+        transformed = true;
+      }
+    }
+
     transformed =
       walkOnClause(
         isBinaryExpr(expr.left as Binary)

package/src/sql/visitors/generate-series-alias.ts

@@ -0,0 +1,291 @@
+/**
+ * AST visitor to rewrite Postgres style generate_series aliases.
+ *
+ * Postgres lets you reference a generate_series alias as a column:
+ *   FROM generate_series(...) AS gs
+ *   SELECT gs::date
+ *
+ * DuckDB treats gs as a table alias, and the column is generate_series.
+ * This visitor rewrites unqualified column refs that match a
+ * generate_series alias to gs.generate_series.
+ */
+
+import type {
+  AST,
+  Binary,
+  ColumnRefItem,
+  ExpressionValue,
+  From,
+  Join,
+  Select,
+  OrderBy,
+  Column,
+} from 'node-sql-parser';
+
+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 isColumnRef(expr: ExpressionValue): expr is ColumnRefItem {
+  return (
+    typeof expr === 'object' &&
+    expr !== null &&
+    'type' in expr &&
+    expr.type === 'column_ref'
+  );
+}
+
+function isBinaryExpr(
+  expr: ExpressionValue | Binary | null | undefined
+): expr is Binary {
+  return (
+    !!expr &&
+    typeof expr === 'object' &&
+    'type' in expr &&
+    (expr as { type?: string }).type === 'binary_expr'
+  );
+}
+
+function getGenerateSeriesAliases(from: Select['from']): Set<string> {
+  const aliases = new Set<string>();
+  if (!from || !Array.isArray(from)) return aliases;
+
+  for (const f of from) {
+    if ('expr' in f && f.expr && typeof f.expr === 'object') {
+      const exprObj = f.expr as Record<string, unknown>;
+      if (exprObj.type === 'function' && 'name' in exprObj) {
+        const nameObj = exprObj.name as Record<string, unknown> | undefined;
+        const nameParts = nameObj?.name as
+          | Array<Record<string, unknown>>
+          | undefined;
+        const fnName = nameParts?.[0]?.value;
+        if (
+          typeof fnName === 'string' &&
+          fnName.toLowerCase() === 'generate_series'
+        ) {
+          const alias = typeof f.as === 'string' ? f.as : null;
+          if (alias && !alias.includes('(')) {
+            aliases.add(alias);
+          }
+        }
+      }
+    }
+  }
+
+  return aliases;
+}
+
+function rewriteAliasColumnRef(col: ColumnRefItem, alias: string): void {
+  col.table = alias;
+  col.column = { expr: { type: 'default', value: 'generate_series' } };
+}
+
+function walkExpression(
+  expr: ExpressionValue | null | undefined,
+  aliases: Set<string>
+): boolean {
+  if (!expr || typeof expr !== 'object') return false;
+
+  let transformed = false;
+  const exprObj = expr as Record<string, unknown>;
+
+  if (isColumnRef(expr)) {
+    if (!('table' in expr) || !expr.table) {
+      const colName = getColumnName(expr);
+      if (colName && aliases.has(colName)) {
+        rewriteAliasColumnRef(expr, colName);
+        transformed = true;
+      }
+    }
+    return transformed;
+  }
+
+  if (isBinaryExpr(expr)) {
+    const binary = expr as Binary;
+    transformed =
+      walkExpression(binary.left as ExpressionValue, aliases) || transformed;
+    transformed =
+      walkExpression(binary.right as ExpressionValue, aliases) || transformed;
+    return transformed;
+  }
+
+  if (exprObj.type === 'unary_expr' && exprObj.expr) {
+    transformed =
+      walkExpression(exprObj.expr as ExpressionValue, aliases) || transformed;
+  }
+
+  if (exprObj.type === 'cast' && exprObj.expr) {
+    transformed =
+      walkExpression(exprObj.expr as ExpressionValue, aliases) || transformed;
+  }
+
+  if (exprObj.type === 'case') {
+    if (exprObj.expr) {
+      transformed =
+        walkExpression(exprObj.expr as ExpressionValue, aliases) || transformed;
+    }
+    if (Array.isArray(exprObj.args)) {
+      for (const whenClause of exprObj.args as Array<Record<string, unknown>>) {
+        if (whenClause.cond) {
+          transformed =
+            walkExpression(whenClause.cond as ExpressionValue, aliases) ||
+            transformed;
+        }
+        if (whenClause.result) {
+          transformed =
+            walkExpression(whenClause.result as ExpressionValue, aliases) ||
+            transformed;
+        }
+      }
+    }
+  }
+
+  if ('args' in exprObj && exprObj.args) {
+    const args = exprObj.args as Record<string, unknown>;
+    if (Array.isArray(args.value)) {
+      for (const arg of args.value as ExpressionValue[]) {
+        transformed = walkExpression(arg, aliases) || transformed;
+      }
+    } else if (args.expr) {
+      transformed =
+        walkExpression(args.expr as ExpressionValue, aliases) || transformed;
+    }
+  }
+
+  if ('over' in exprObj && exprObj.over && typeof exprObj.over === 'object') {
+    const over = exprObj.over as Record<string, unknown>;
+    if (Array.isArray(over.partition)) {
+      for (const part of over.partition as ExpressionValue[]) {
+        transformed = walkExpression(part, aliases) || transformed;
+      }
+    }
+    if (Array.isArray(over.orderby)) {
+      for (const order of over.orderby as ExpressionValue[]) {
+        transformed = walkExpression(order, aliases) || transformed;
+      }
+    }
+  }
+
+  if ('ast' in exprObj && exprObj.ast) {
+    const subAst = exprObj.ast as Select;
+    if (subAst.type === 'select') {
+      transformed = walkSelect(subAst) || transformed;
+    }
+  }
+
+  if (exprObj.type === 'expr_list' && Array.isArray(exprObj.value)) {
+    for (const item of exprObj.value as ExpressionValue[]) {
+      transformed = walkExpression(item, aliases) || transformed;
+    }
+  }
+
+  return transformed;
+}
+
+function walkFrom(from: Select['from'], aliases: Set<string>): 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 as ExpressionValue, aliases) || transformed;
+    }
+    if ('expr' in f && f.expr && 'ast' in f.expr) {
+      transformed = walkSelect(f.expr.ast as Select) || transformed;
+    }
+  }
+
+  return transformed;
+}
+
+function walkSelect(select: Select): boolean {
+  let transformed = false;
+  const aliases = getGenerateSeriesAliases(select.from);
+
+  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;
+      }
+    }
+  }
+
+  transformed = walkFrom(select.from, aliases) || transformed;
+
+  transformed = walkExpression(select.where, aliases) || transformed;
+
+  if (select.having) {
+    if (Array.isArray(select.having)) {
+      for (const h of select.having) {
+        transformed =
+          walkExpression(h as ExpressionValue, aliases) || transformed;
+      }
+    } else {
+      transformed =
+        walkExpression(select.having as ExpressionValue, aliases) ||
+        transformed;
+    }
+  }
+
+  if (Array.isArray(select.columns)) {
+    for (const col of select.columns as Column[]) {
+      if ('expr' in col) {
+        transformed =
+          walkExpression(col.expr as ExpressionValue, aliases) || transformed;
+      }
+    }
+  }
+
+  if (Array.isArray(select.groupby)) {
+    for (const g of select.groupby as ExpressionValue[]) {
+      transformed = walkExpression(g, aliases) || transformed;
+    }
+  }
+
+  if (Array.isArray(select.orderby)) {
+    for (const order of select.orderby as OrderBy[]) {
+      if (order.expr) {
+        transformed =
+          walkExpression(order.expr as ExpressionValue, aliases) || transformed;
+      }
+    }
+  }
+
+  if (select._orderby) {
+    for (const order of select._orderby as OrderBy[]) {
+      if (order.expr) {
+        transformed =
+          walkExpression(order.expr as ExpressionValue, aliases) || transformed;
+      }
+    }
+  }
+
+  if (select._next) {
+    transformed = walkSelect(select._next) || transformed;
+  }
+
+  return transformed;
+}
+
+export function rewriteGenerateSeriesAliases(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/sql/visitors/union-with-hoister.ts

@@ -0,0 +1,106 @@
+/**
+ * AST visitor to hoist WITH clauses out of UNION and other set operations.
+ *
+ * Drizzle can emit SQL like:
+ *   (with a as (...) select ...) union (with b as (...) select ...)
+ *
+ * DuckDB 1.4.x has an internal binder bug for this pattern.
+ * We merge per arm CTEs into a single top level WITH when names do not collide.
+ */
+
+import type { AST, Select, From } from 'node-sql-parser';
+
+function getCteName(cte: { name?: unknown }): string | null {
+  const nameObj = cte.name as Record<string, unknown> | undefined;
+  if (!nameObj) return null;
+  const value = nameObj.value;
+  if (typeof value === 'string') return value;
+  return null;
+}
+
+function hoistWithInSelect(select: Select): boolean {
+  if (!select.set_op || !select._next) return false;
+
+  const arms: Select[] = [];
+  let current: Select | null = select;
+  while (current && current.type === 'select') {
+    arms.push(current);
+    current = current._next as Select | null;
+  }
+
+  const mergedWith: NonNullable<Select['with']> = [];
+  const seen = new Set<string>();
+  let hasWithBeyondFirst = false;
+
+  for (const arm of arms) {
+    if (arm.with && arm.with.length > 0) {
+      if (arm !== arms[0]) {
+        hasWithBeyondFirst = true;
+      }
+      for (const cte of arm.with) {
+        const cteName = getCteName(cte);
+        if (!cteName) return false;
+        if (seen.has(cteName)) {
+          return false;
+        }
+        seen.add(cteName);
+        mergedWith.push(cte);
+      }
+    }
+  }
+
+  if (!hasWithBeyondFirst) return false;
+
+  arms[0].with = mergedWith;
+  if ('parentheses_symbol' in arms[0]) {
+    (arms[0] as Select & { parentheses_symbol?: boolean }).parentheses_symbol =
+      false;
+  }
+  for (let i = 1; i < arms.length; i++) {
+    arms[i].with = null;
+  }
+
+  return true;
+}
+
+function walkSelect(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 = walkSelect(cteSelect as Select) || transformed;
+      }
+    }
+  }
+
+  if (Array.isArray(select.from)) {
+    for (const from of select.from as From[]) {
+      if ('expr' in from && from.expr && 'ast' in from.expr) {
+        transformed = walkSelect(from.expr.ast as Select) || transformed;
+      }
+    }
+  }
+
+  transformed = hoistWithInSelect(select) || transformed;
+
+  if (select._next) {
+    transformed = walkSelect(select._next) || transformed;
+  }
+
+  return transformed;
+}
+
+export function hoistUnionWith(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;
+}