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

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,80 @@ 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;
+    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;
   }
   return transformed;
 }
@@ -1124,12 +1183,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 +1205,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 +1340,323 @@ 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;
+}
+
+// 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;
@@ -1220,29 +1665,73 @@ 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");
-  if (!needsArrayTransform && !needsJoinTransform) {
+  const needsJoinTransform = hasJoin(query) || /\bupdate\b/i.test(query) || /\bdelete\b/i.test(query);
+  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 };
   }
-  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 (needsGenerateSeriesTransform) {
+        transformed = rewriteGenerateSeriesAliases(ast) || transformed;
+      }
+      if (needsUnionTransform) {
+        transformed = hoistUnionWith(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