@leonardovida-md/drizzle-neo-duckdb 1.1.4 → 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";
@@ -23,765 +23,6 @@ import { PgTransaction } from "drizzle-orm/pg-core";
 import { PgPreparedQuery, PgSession } from "drizzle-orm/pg-core/session";
 import { fillPlaceholders, sql } from "drizzle-orm/sql/sql";
 
-// src/sql/query-rewriters.ts
-var OPERATORS = [
-  { token: "@>", fn: "array_has_all" },
-  { token: "<@", fn: "array_has_all", swap: true },
-  { token: "&&", fn: "array_has_any" }
-];
-var isWhitespace = (char) => char !== undefined && /\s/.test(char);
-function scrubForRewrite(query) {
-  let scrubbed = "";
-  let state = "code";
-  for (let i = 0;i < query.length; i += 1) {
-    const char = query[i];
-    const next = query[i + 1];
-    if (state === "code") {
-      if (char === "'") {
-        scrubbed += "'";
-        state = "single";
-        continue;
-      }
-      if (char === '"') {
-        scrubbed += '"';
-        state = "double";
-        continue;
-      }
-      if (char === "-" && next === "-") {
-        scrubbed += "  ";
-        i += 1;
-        state = "lineComment";
-        continue;
-      }
-      if (char === "/" && next === "*") {
-        scrubbed += "  ";
-        i += 1;
-        state = "blockComment";
-        continue;
-      }
-      scrubbed += char;
-      continue;
-    }
-    if (state === "single") {
-      if (char === "'" && next === "'") {
-        scrubbed += "''";
-        i += 1;
-        continue;
-      }
-      scrubbed += char === "'" ? "'" : ".";
-      if (char === "'") {
-        state = "code";
-      }
-      continue;
-    }
-    if (state === "double") {
-      if (char === '"' && next === '"') {
-        scrubbed += '""';
-        i += 1;
-        continue;
-      }
-      scrubbed += char === '"' ? '"' : ".";
-      if (char === '"') {
-        state = "code";
-      }
-      continue;
-    }
-    if (state === "lineComment") {
-      scrubbed += char === `
-` ? `
-` : " ";
-      if (char === `
-`) {
-        state = "code";
-      }
-      continue;
-    }
-    if (state === "blockComment") {
-      if (char === "*" && next === "/") {
-        scrubbed += "  ";
-        i += 1;
-        state = "code";
-      } else {
-        scrubbed += " ";
-      }
-    }
-  }
-  return scrubbed;
-}
-function findNextOperator(scrubbed, start) {
-  for (let idx = start;idx < scrubbed.length; idx += 1) {
-    for (const operator of OPERATORS) {
-      if (scrubbed.startsWith(operator.token, idx)) {
-        return { index: idx, operator };
-      }
-    }
-  }
-  return null;
-}
-function walkLeft(source, scrubbed, start) {
-  let idx = start;
-  while (idx >= 0 && isWhitespace(scrubbed[idx])) {
-    idx -= 1;
-  }
-  let depth = 0;
-  for (;idx >= 0; idx -= 1) {
-    const ch = scrubbed[idx];
-    if (ch === ")" || ch === "]") {
-      depth += 1;
-    } else if (ch === "(" || ch === "[") {
-      if (depth === 0) {
-        return [idx + 1, source.slice(idx + 1, start + 1)];
-      }
-      depth = Math.max(0, depth - 1);
-    } else if (depth === 0 && isWhitespace(ch)) {
-      return [idx + 1, source.slice(idx + 1, start + 1)];
-    }
-  }
-  return [0, source.slice(0, start + 1)];
-}
-function walkRight(source, scrubbed, start) {
-  let idx = start;
-  while (idx < scrubbed.length && isWhitespace(scrubbed[idx])) {
-    idx += 1;
-  }
-  let depth = 0;
-  for (;idx < scrubbed.length; idx += 1) {
-    const ch = scrubbed[idx];
-    if (ch === "(" || ch === "[") {
-      depth += 1;
-    } else if (ch === ")" || ch === "]") {
-      if (depth === 0) {
-        return [idx, source.slice(start, idx)];
-      }
-      depth = Math.max(0, depth - 1);
-    } else if (depth === 0 && isWhitespace(ch)) {
-      return [idx, source.slice(start, idx)];
-    }
-  }
-  return [scrubbed.length, source.slice(start)];
-}
-function adaptArrayOperators(query) {
-  if (query.indexOf("@>") === -1 && query.indexOf("<@") === -1 && query.indexOf("&&") === -1) {
-    return query;
-  }
-  let rewritten = query;
-  let scrubbed = scrubForRewrite(query);
-  let searchStart = 0;
-  while (true) {
-    const next = findNextOperator(scrubbed, searchStart);
-    if (!next)
-      break;
-    const { index, operator } = next;
-    const [leftStart, leftExpr] = walkLeft(rewritten, scrubbed, index - 1);
-    const [rightEnd, rightExpr] = walkRight(rewritten, scrubbed, index + operator.token.length);
-    const left = leftExpr.trim();
-    const right = rightExpr.trim();
-    const replacement = `${operator.fn}(${operator.swap ? right : left}, ${operator.swap ? left : right})`;
-    rewritten = rewritten.slice(0, leftStart) + replacement + rewritten.slice(rightEnd);
-    scrubbed = scrubForRewrite(rewritten);
-    searchStart = leftStart + replacement.length;
-  }
-  return rewritten;
-}
-function extractQuotedIdentifier(original, start) {
-  if (original[start] !== '"') {
-    return null;
-  }
-  let pos = start + 1;
-  while (pos < original.length) {
-    if (original[pos] === '"') {
-      if (original[pos + 1] === '"') {
-        pos += 2;
-        continue;
-      }
-      break;
-    }
-    pos++;
-  }
-  if (pos >= original.length) {
-    return null;
-  }
-  return {
-    name: original.slice(start + 1, pos),
-    end: pos + 1
-  };
-}
-function findMainFromClause(scrubbed) {
-  const lowerScrubbed = scrubbed.toLowerCase();
-  let searchStart = 0;
-  const withMatch = /\bwith\s+/i.exec(lowerScrubbed);
-  if (withMatch) {
-    let depth = 0;
-    let pos = withMatch.index + withMatch[0].length;
-    while (pos < scrubbed.length) {
-      const char = scrubbed[pos];
-      if (char === "(") {
-        depth++;
-      } else if (char === ")") {
-        depth--;
-      } else if (depth === 0) {
-        const remaining = lowerScrubbed.slice(pos);
-        if (/^\s*select\s+/i.test(remaining)) {
-          searchStart = pos;
-          break;
-        }
-      }
-      pos++;
-    }
-  }
-  const fromPattern = /\bfrom\s+/gi;
-  fromPattern.lastIndex = searchStart;
-  const fromMatch = fromPattern.exec(lowerScrubbed);
-  return fromMatch ? fromMatch.index + fromMatch[0].length : -1;
-}
-function parseTableSources(original, scrubbed) {
-  const sources = [];
-  const lowerScrubbed = scrubbed.toLowerCase();
-  const fromPos = findMainFromClause(scrubbed);
-  if (fromPos < 0) {
-    return sources;
-  }
-  const fromTable = parseTableRef(original, scrubbed, fromPos);
-  if (fromTable) {
-    sources.push(fromTable);
-  }
-  const joinPattern = /\b(left\s+|right\s+|inner\s+|full\s+|cross\s+)?join\s+/gi;
-  joinPattern.lastIndex = fromPos;
-  let joinMatch;
-  while ((joinMatch = joinPattern.exec(lowerScrubbed)) !== null) {
-    const tableStart = joinMatch.index + joinMatch[0].length;
-    const joinTable = parseTableRef(original, scrubbed, tableStart);
-    if (joinTable) {
-      sources.push(joinTable);
-    }
-  }
-  return sources;
-}
-function parseTableRef(original, scrubbed, start) {
-  let pos = start;
-  while (pos < scrubbed.length && isWhitespace(scrubbed[pos])) {
-    pos++;
-  }
-  if (scrubbed[pos] === "(") {
-    const nameStart2 = pos;
-    let depth = 1;
-    pos++;
-    while (pos < scrubbed.length && depth > 0) {
-      if (scrubbed[pos] === "(")
-        depth++;
-      else if (scrubbed[pos] === ")")
-        depth--;
-      pos++;
-    }
-    while (pos < scrubbed.length && isWhitespace(scrubbed[pos])) {
-      pos++;
-    }
-    const afterSubquery = scrubbed.slice(pos).toLowerCase();
-    if (afterSubquery.startsWith("as ")) {
-      pos += 3;
-      while (pos < scrubbed.length && isWhitespace(scrubbed[pos])) {
-        pos++;
-      }
-    }
-    if (original[pos] === '"') {
-      const aliasIdent = extractQuotedIdentifier(original, pos);
-      if (aliasIdent) {
-        return {
-          name: aliasIdent.name,
-          alias: aliasIdent.name,
-          position: nameStart2
-        };
-      }
-    }
-    return null;
-  }
-  if (original[pos] !== '"') {
-    return null;
-  }
-  const nameStart = pos;
-  const firstIdent = extractQuotedIdentifier(original, pos);
-  if (!firstIdent) {
-    return null;
-  }
-  let name = firstIdent.name;
-  pos = firstIdent.end;
-  let afterName = pos;
-  while (afterName < scrubbed.length && isWhitespace(scrubbed[afterName])) {
-    afterName++;
-  }
-  if (scrubbed[afterName] === ".") {
-    afterName++;
-    while (afterName < scrubbed.length && isWhitespace(scrubbed[afterName])) {
-      afterName++;
-    }
-    if (original[afterName] === '"') {
-      const tableIdent = extractQuotedIdentifier(original, afterName);
-      if (tableIdent) {
-        name = tableIdent.name;
-        pos = tableIdent.end;
-      }
-    }
-  }
-  let alias;
-  let aliasPos = pos;
-  while (aliasPos < scrubbed.length && isWhitespace(scrubbed[aliasPos])) {
-    aliasPos++;
-  }
-  const afterTable = scrubbed.slice(aliasPos).toLowerCase();
-  if (afterTable.startsWith("as ")) {
-    aliasPos += 3;
-    while (aliasPos < scrubbed.length && isWhitespace(scrubbed[aliasPos])) {
-      aliasPos++;
-    }
-  }
-  const afterAlias = scrubbed.slice(aliasPos).toLowerCase();
-  if (original[aliasPos] === '"' && !afterAlias.startsWith("on ") && !afterAlias.startsWith("left ") && !afterAlias.startsWith("right ") && !afterAlias.startsWith("inner ") && !afterAlias.startsWith("full ") && !afterAlias.startsWith("cross ") && !afterAlias.startsWith("join ") && !afterAlias.startsWith("where ") && !afterAlias.startsWith("group ") && !afterAlias.startsWith("order ") && !afterAlias.startsWith("limit ")) {
-    const aliasIdent = extractQuotedIdentifier(original, aliasPos);
-    if (aliasIdent) {
-      alias = aliasIdent.name;
-    }
-  }
-  return {
-    name,
-    alias,
-    position: nameStart
-  };
-}
-function findJoinClauses(original, scrubbed, sources, fromPos) {
-  const clauses = [];
-  const lowerScrubbed = scrubbed.toLowerCase();
-  const joinPattern = /\b(left\s+|right\s+|inner\s+|full\s+|cross\s+)?join\s+"[^"]*"(\s*\.\s*"[^"]*")?(\s+as)?(\s+"[^"]*")?\s+on\s+/gi;
-  joinPattern.lastIndex = fromPos;
-  let match;
-  let sourceIndex = 1;
-  while ((match = joinPattern.exec(lowerScrubbed)) !== null) {
-    const joinType = (match[1] || "").trim().toLowerCase();
-    const joinKeywordEnd = match.index + (match[1] || "").length + "join".length;
-    let tableStart = joinKeywordEnd;
-    while (tableStart < original.length && isWhitespace(original[tableStart])) {
-      tableStart++;
-    }
-    const tableIdent = extractQuotedIdentifier(original, tableStart);
-    if (!tableIdent)
-      continue;
-    let tableName = tableIdent.name;
-    let afterTable = tableIdent.end;
-    let checkPos = afterTable;
-    while (checkPos < scrubbed.length && isWhitespace(scrubbed[checkPos])) {
-      checkPos++;
-    }
-    if (scrubbed[checkPos] === ".") {
-      checkPos++;
-      while (checkPos < scrubbed.length && isWhitespace(scrubbed[checkPos])) {
-        checkPos++;
-      }
-      const realTableIdent = extractQuotedIdentifier(original, checkPos);
-      if (realTableIdent) {
-        tableName = realTableIdent.name;
-        afterTable = realTableIdent.end;
-      }
-    }
-    let tableAlias;
-    let aliasPos = afterTable;
-    while (aliasPos < scrubbed.length && isWhitespace(scrubbed[aliasPos])) {
-      aliasPos++;
-    }
-    const afterTableStr = scrubbed.slice(aliasPos).toLowerCase();
-    if (afterTableStr.startsWith("as ")) {
-      aliasPos += 3;
-      while (aliasPos < scrubbed.length && isWhitespace(scrubbed[aliasPos])) {
-        aliasPos++;
-      }
-    }
-    if (original[aliasPos] === '"' && !afterTableStr.startsWith("on ")) {
-      const aliasIdent = extractQuotedIdentifier(original, aliasPos);
-      if (aliasIdent) {
-        tableAlias = aliasIdent.name;
-      }
-    }
-    const onStart = match.index + match[0].length;
-    const endPattern = /\b(left\s+join|right\s+join|inner\s+join|full\s+join|cross\s+join|join|where|group\s+by|order\s+by|limit|$)/i;
-    const remaining = lowerScrubbed.slice(onStart);
-    const endMatch = endPattern.exec(remaining);
-    const onEnd = endMatch ? onStart + endMatch.index : scrubbed.length;
-    let leftSource = "";
-    if (sourceIndex > 0 && sourceIndex <= sources.length) {
-      const prev = sources[sourceIndex - 1];
-      leftSource = prev?.alias || prev?.name || "";
-    }
-    const rightSource = tableAlias || tableName;
-    clauses.push({
-      joinType,
-      tableName,
-      tableAlias,
-      onStart,
-      onEnd,
-      leftSource,
-      rightSource
-    });
-    sourceIndex++;
-  }
-  return clauses;
-}
-function findMainSelectClause(scrubbed) {
-  const lowerScrubbed = scrubbed.toLowerCase();
-  let searchStart = 0;
-  const withMatch = /\bwith\s+/i.exec(lowerScrubbed);
-  if (withMatch) {
-    let depth2 = 0;
-    let pos2 = withMatch.index + withMatch[0].length;
-    while (pos2 < scrubbed.length) {
-      const char = scrubbed[pos2];
-      if (char === "(") {
-        depth2++;
-      } else if (char === ")") {
-        depth2--;
-      } else if (depth2 === 0) {
-        const remaining = lowerScrubbed.slice(pos2);
-        if (/^\s*select\s+/i.test(remaining)) {
-          searchStart = pos2;
-          break;
-        }
-      }
-      pos2++;
-    }
-  }
-  const selectPattern = /\bselect\s+/gi;
-  selectPattern.lastIndex = searchStart;
-  const selectMatch = selectPattern.exec(lowerScrubbed);
-  if (!selectMatch)
-    return null;
-  const selectStart = selectMatch.index + selectMatch[0].length;
-  let depth = 0;
-  let pos = selectStart;
-  while (pos < scrubbed.length) {
-    const char = scrubbed[pos];
-    if (char === "(") {
-      depth++;
-    } else if (char === ")") {
-      depth--;
-    } else if (depth === 0) {
-      const remaining = lowerScrubbed.slice(pos);
-      if (/^\s*from\s+/i.test(remaining)) {
-        return { start: selectStart, end: pos };
-      }
-    }
-    pos++;
-  }
-  return null;
-}
-function findWhereClause(scrubbed, fromPos) {
-  const lowerScrubbed = scrubbed.toLowerCase();
-  let depth = 0;
-  let pos = fromPos;
-  let whereStart = -1;
-  while (pos < scrubbed.length) {
-    const char = scrubbed[pos];
-    if (char === "(") {
-      depth++;
-    } else if (char === ")") {
-      depth--;
-    } else if (depth === 0) {
-      const remaining = lowerScrubbed.slice(pos);
-      if (whereStart === -1 && /^\s*where\s+/i.test(remaining)) {
-        const match = /^\s*where\s+/i.exec(remaining);
-        if (match) {
-          whereStart = pos + match[0].length;
-        }
-      } else if (whereStart !== -1 && /^\s*(group\s+by|order\s+by|limit|having|union|intersect|except|$)/i.test(remaining)) {
-        return { start: whereStart, end: pos };
-      }
-    }
-    pos++;
-  }
-  if (whereStart !== -1) {
-    return { start: whereStart, end: scrubbed.length };
-  }
-  return null;
-}
-function findOrderByClause(scrubbed, fromPos) {
-  const lowerScrubbed = scrubbed.toLowerCase();
-  let depth = 0;
-  let pos = fromPos;
-  let orderStart = -1;
-  while (pos < scrubbed.length) {
-    const char = scrubbed[pos];
-    if (char === "(") {
-      depth++;
-    } else if (char === ")") {
-      depth--;
-    } else if (depth === 0) {
-      const remaining = lowerScrubbed.slice(pos);
-      if (orderStart === -1 && /^\s*order\s+by\s+/i.test(remaining)) {
-        const match = /^\s*order\s+by\s+/i.exec(remaining);
-        if (match) {
-          orderStart = pos + match[0].length;
-        }
-      } else if (orderStart !== -1 && /^\s*(limit|offset|fetch|for\s+update|$)/i.test(remaining)) {
-        return { start: orderStart, end: pos };
-      }
-    }
-    pos++;
-  }
-  if (orderStart !== -1) {
-    return { start: orderStart, end: scrubbed.length };
-  }
-  return null;
-}
-function qualifyClauseColumnsSelective(original, scrubbed, clauseStart, clauseEnd, defaultSource, ambiguousColumns) {
-  const clauseOriginal = original.slice(clauseStart, clauseEnd);
-  const clauseScrubbed = scrubbed.slice(clauseStart, clauseEnd);
-  let result = clauseOriginal;
-  let offset = 0;
-  let pos = 0;
-  while (pos < clauseScrubbed.length) {
-    const quotePos = clauseScrubbed.indexOf('"', pos);
-    if (quotePos === -1)
-      break;
-    if (quotePos > 0 && clauseScrubbed[quotePos - 1] === ".") {
-      const ident2 = extractQuotedIdentifier(clauseOriginal, quotePos);
-      pos = ident2 ? ident2.end : quotePos + 1;
-      continue;
-    }
-    const ident = extractQuotedIdentifier(clauseOriginal, quotePos);
-    if (!ident) {
-      pos = quotePos + 1;
-      continue;
-    }
-    if (ident.end < clauseScrubbed.length && clauseScrubbed[ident.end] === ".") {
-      pos = ident.end + 1;
-      continue;
-    }
-    if (!ambiguousColumns.has(ident.name)) {
-      pos = ident.end;
-      continue;
-    }
-    let afterIdent = ident.end;
-    while (afterIdent < clauseScrubbed.length && isWhitespace(clauseScrubbed[afterIdent])) {
-      afterIdent++;
-    }
-    if (clauseScrubbed[afterIdent] === "(") {
-      pos = ident.end;
-      continue;
-    }
-    const beforeQuote = clauseScrubbed.slice(0, quotePos).toLowerCase();
-    if (/\bas\s*$/i.test(beforeQuote)) {
-      pos = ident.end;
-      continue;
-    }
-    const qualified = `"${defaultSource}"."${ident.name}"`;
-    const oldLength = ident.end - quotePos;
-    result = result.slice(0, quotePos + offset) + qualified + result.slice(quotePos + oldLength + offset);
-    offset += qualified.length - oldLength;
-    pos = ident.end;
-  }
-  return { result, offset };
-}
-function qualifyJoinColumns(query) {
-  const lowerQuery = query.toLowerCase();
-  if (!lowerQuery.includes("join")) {
-    return query;
-  }
-  const scrubbed = scrubForRewrite(query);
-  const fromPos = findMainFromClause(scrubbed);
-  if (fromPos < 0) {
-    return query;
-  }
-  const sources = parseTableSources(query, scrubbed);
-  if (sources.length < 2) {
-    return query;
-  }
-  const joinClauses = findJoinClauses(query, scrubbed, sources, fromPos);
-  if (joinClauses.length === 0) {
-    return query;
-  }
-  const firstSource = sources[0];
-  const defaultQualifier = firstSource.alias || firstSource.name;
-  let result = query;
-  let totalOffset = 0;
-  for (const join of joinClauses) {
-    const scrubbedOnClause = scrubbed.slice(join.onStart, join.onEnd);
-    const originalOnClause = query.slice(join.onStart, join.onEnd);
-    let clauseResult = originalOnClause;
-    let clauseOffset = 0;
-    let eqPos = -1;
-    while ((eqPos = scrubbedOnClause.indexOf("=", eqPos + 1)) !== -1) {
-      let lhsEnd = eqPos - 1;
-      while (lhsEnd >= 0 && isWhitespace(scrubbedOnClause[lhsEnd])) {
-        lhsEnd--;
-      }
-      if (scrubbedOnClause[lhsEnd] !== '"')
-        continue;
-      let lhsStartPos = lhsEnd - 1;
-      while (lhsStartPos >= 0) {
-        if (scrubbedOnClause[lhsStartPos] === '"') {
-          if (lhsStartPos > 0 && scrubbedOnClause[lhsStartPos - 1] === '"') {
-            lhsStartPos -= 2;
-            continue;
-          }
-          break;
-        }
-        lhsStartPos--;
-      }
-      if (lhsStartPos < 0)
-        continue;
-      const lhsIsQualified = lhsStartPos > 0 && scrubbedOnClause[lhsStartPos - 1] === ".";
-      let rhsStartPos = eqPos + 1;
-      while (rhsStartPos < scrubbedOnClause.length && isWhitespace(scrubbedOnClause[rhsStartPos])) {
-        rhsStartPos++;
-      }
-      const rhsChar = originalOnClause[rhsStartPos];
-      const rhsIsParam = rhsChar === "$";
-      const rhsIsStringLiteral = rhsChar === "'";
-      const rhsIsColumn = rhsChar === '"';
-      if (!rhsIsParam && !rhsIsStringLiteral && !rhsIsColumn)
-        continue;
-      const rhsIsQualified = !rhsIsColumn || rhsStartPos > 0 && scrubbedOnClause[rhsStartPos - 1] === ".";
-      if (lhsIsQualified || rhsIsQualified)
-        continue;
-      const lhsIdent = extractQuotedIdentifier(originalOnClause, lhsStartPos);
-      if (!lhsIdent)
-        continue;
-      let rhsIdent = null;
-      let rhsValue = "";
-      let rhsEnd = rhsStartPos;
-      if (rhsIsParam) {
-        let paramEnd = rhsStartPos + 1;
-        while (paramEnd < originalOnClause.length && /\d/.test(originalOnClause[paramEnd])) {
-          paramEnd++;
-        }
-        rhsValue = originalOnClause.slice(rhsStartPos, paramEnd);
-        rhsEnd = paramEnd;
-      } else if (rhsIsStringLiteral) {
-        let literalEnd = rhsStartPos + 1;
-        while (literalEnd < originalOnClause.length) {
-          if (originalOnClause[literalEnd] === "'") {
-            if (originalOnClause[literalEnd + 1] === "'") {
-              literalEnd += 2;
-              continue;
-            }
-            break;
-          }
-          literalEnd++;
-        }
-        rhsValue = originalOnClause.slice(rhsStartPos, literalEnd + 1);
-        rhsEnd = literalEnd + 1;
-      } else if (rhsIsColumn) {
-        rhsIdent = extractQuotedIdentifier(originalOnClause, rhsStartPos);
-        if (rhsIdent) {
-          if (rhsIdent.end < scrubbedOnClause.length && scrubbedOnClause[rhsIdent.end] === ".") {
-            continue;
-          }
-          rhsValue = `"${rhsIdent.name}"`;
-          rhsEnd = rhsIdent.end;
-        }
-      }
-      if (!rhsValue)
-        continue;
-      if (!rhsIsColumn || !rhsIdent || lhsIdent.name !== rhsIdent.name) {
-        continue;
-      }
-      const lhsOriginal = `"${lhsIdent.name}"`;
-      let newLhs = lhsOriginal;
-      let newRhs = rhsValue;
-      if (!lhsIsQualified && join.leftSource) {
-        newLhs = `"${join.leftSource}"."${lhsIdent.name}"`;
-      }
-      if (!rhsIsQualified && rhsIsColumn && rhsIdent && join.rightSource) {
-        newRhs = `"${join.rightSource}"."${rhsIdent.name}"`;
-      }
-      if (newLhs !== lhsOriginal || newRhs !== rhsValue) {
-        const opStart = lhsIdent.end;
-        let opEnd = opStart;
-        while (opEnd < rhsEnd && (isWhitespace(originalOnClause[opEnd]) || originalOnClause[opEnd] === "=")) {
-          opEnd++;
-        }
-        const operator = originalOnClause.slice(opStart, opEnd);
-        const newExpr = `${newLhs}${operator}${newRhs}`;
-        const oldExprLength = rhsEnd - lhsStartPos;
-        clauseResult = clauseResult.slice(0, lhsStartPos + clauseOffset) + newExpr + clauseResult.slice(lhsStartPos + oldExprLength + clauseOffset);
-        clauseOffset += newExpr.length - oldExprLength;
-      }
-    }
-    if (clauseResult !== originalOnClause) {
-      result = result.slice(0, join.onStart + totalOffset) + clauseResult + result.slice(join.onEnd + totalOffset);
-      totalOffset += clauseResult.length - originalOnClause.length;
-    }
-  }
-  const ambiguousColumns = new Set;
-  for (const join of joinClauses) {
-    const scrubbedOnClause = scrubbed.slice(join.onStart, join.onEnd);
-    const originalOnClause = query.slice(join.onStart, join.onEnd);
-    let eqPos = -1;
-    while ((eqPos = scrubbedOnClause.indexOf("=", eqPos + 1)) !== -1) {
-      let lhsEnd = eqPos - 1;
-      while (lhsEnd >= 0 && isWhitespace(scrubbedOnClause[lhsEnd])) {
-        lhsEnd--;
-      }
-      if (scrubbedOnClause[lhsEnd] !== '"')
-        continue;
-      let lhsStartPos = lhsEnd - 1;
-      while (lhsStartPos >= 0) {
-        if (scrubbedOnClause[lhsStartPos] === '"') {
-          if (lhsStartPos > 0 && scrubbedOnClause[lhsStartPos - 1] === '"') {
-            lhsStartPos -= 2;
-            continue;
-          }
-          break;
-        }
-        lhsStartPos--;
-      }
-      if (lhsStartPos < 0)
-        continue;
-      let rhsStartPos = eqPos + 1;
-      while (rhsStartPos < scrubbedOnClause.length && isWhitespace(scrubbedOnClause[rhsStartPos])) {
-        rhsStartPos++;
-      }
-      if (originalOnClause[rhsStartPos] !== '"')
-        continue;
-      const lhsIdent = extractQuotedIdentifier(originalOnClause, lhsStartPos);
-      const rhsIdent = extractQuotedIdentifier(originalOnClause, rhsStartPos);
-      if (lhsIdent && rhsIdent && lhsIdent.name === rhsIdent.name) {
-        ambiguousColumns.add(lhsIdent.name);
-      }
-    }
-  }
-  if (ambiguousColumns.size === 0) {
-    return result;
-  }
-  const updatedScrubbed = scrubForRewrite(result);
-  const selectClause = findMainSelectClause(updatedScrubbed);
-  if (selectClause) {
-    const { result: selectResult, offset: selectOffset } = qualifyClauseColumnsSelective(result, updatedScrubbed, selectClause.start, selectClause.end, defaultQualifier, ambiguousColumns);
-    if (selectOffset !== 0) {
-      result = result.slice(0, selectClause.start) + selectResult + result.slice(selectClause.end);
-    }
-  }
-  const scrubbed2 = scrubForRewrite(result);
-  const fromPos2 = findMainFromClause(scrubbed2);
-  if (fromPos2 >= 0) {
-    const whereClause = findWhereClause(scrubbed2, fromPos2);
-    if (whereClause) {
-      const { result: whereResult, offset: whereOffset } = qualifyClauseColumnsSelective(result, scrubbed2, whereClause.start, whereClause.end, defaultQualifier, ambiguousColumns);
-      if (whereOffset !== 0) {
-        result = result.slice(0, whereClause.start) + whereResult + result.slice(whereClause.end);
-      }
-    }
-  }
-  const scrubbed3 = scrubForRewrite(result);
-  const fromPos3 = findMainFromClause(scrubbed3);
-  if (fromPos3 >= 0) {
-    const orderByClause = findOrderByClause(scrubbed3, fromPos3);
-    if (orderByClause) {
-      const { result: orderResult, offset: orderOffset } = qualifyClauseColumnsSelective(result, scrubbed3, orderByClause.start, orderByClause.end, defaultQualifier, ambiguousColumns);
-      if (orderOffset !== 0) {
-        result = result.slice(0, orderByClause.start) + orderResult + result.slice(orderByClause.end);
-      }
-    }
-  }
-  return result;
-}
-
 // src/sql/result-mapper.ts
 import {
   Column,
@@ -1358,24 +599,6 @@ function isSavepointSyntaxError(error) {
   }
   return error.message.toLowerCase().includes("savepoint") && error.message.toLowerCase().includes("syntax error");
 }
-function rewriteQuery(mode, query) {
-  if (mode === "never") {
-    return { sql: query, rewritten: false };
-  }
-  let result = query;
-  let wasRewritten = false;
-  const arrayRewritten = adaptArrayOperators(result);
-  if (arrayRewritten !== result) {
-    result = arrayRewritten;
-    wasRewritten = true;
-  }
-  const joinQualified = qualifyJoinColumns(result);
-  if (joinQualified !== result) {
-    result = joinQualified;
-    wasRewritten = true;
-  }
-  return { sql: result, rewritten: wasRewritten };
-}
 
 class DuckDBPreparedQuery extends PgPreparedQuery {
   client;
@@ -1386,12 +609,11 @@ class DuckDBPreparedQuery extends PgPreparedQuery {
   fields;
   _isResponseInArrayMode;
   customResultMapper;
-  rewriteArraysMode;
   rejectStringArrayLiterals;
   prepareCache;
   warnOnStringArrayLiteral;
   static [entityKind] = "DuckDBPreparedQuery";
-  constructor(client, dialect, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper, rewriteArraysMode, rejectStringArrayLiterals, prepareCache, warnOnStringArrayLiteral) {
+  constructor(client, dialect, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper, rejectStringArrayLiterals, prepareCache, warnOnStringArrayLiteral) {
     super({ sql: queryString, params });
     this.client = client;
     this.dialect = dialect;
@@ -1401,7 +623,6 @@ class DuckDBPreparedQuery extends PgPreparedQuery {
     this.fields = fields;
     this._isResponseInArrayMode = _isResponseInArrayMode;
     this.customResultMapper = customResultMapper;
-    this.rewriteArraysMode = rewriteArraysMode;
     this.rejectStringArrayLiterals = rejectStringArrayLiterals;
     this.prepareCache = prepareCache;
     this.warnOnStringArrayLiteral = warnOnStringArrayLiteral;
@@ -1412,20 +633,16 @@ class DuckDBPreparedQuery extends PgPreparedQuery {
       rejectStringArrayLiterals: this.rejectStringArrayLiterals,
       warnOnStringArrayLiteral: this.warnOnStringArrayLiteral ? () => this.warnOnStringArrayLiteral?.(this.queryString) : undefined
     });
-    const { sql: rewrittenQuery, rewritten: didRewrite } = rewriteQuery(this.rewriteArraysMode, this.queryString);
-    if (didRewrite) {
-      this.logger.logQuery(`[duckdb] original query before array rewrite: ${this.queryString}`, params);
-    }
-    this.logger.logQuery(rewrittenQuery, params);
+    this.logger.logQuery(this.queryString, params);
     const { fields, joinsNotNullableMap, customResultMapper } = this;
     if (fields) {
-      const { rows: rows2 } = await executeArraysOnClient(this.client, rewrittenQuery, params, { prepareCache: this.prepareCache });
+      const { rows: rows2 } = await executeArraysOnClient(this.client, this.queryString, params, { prepareCache: this.prepareCache });
       if (rows2.length === 0) {
         return [];
       }
       return customResultMapper ? customResultMapper(rows2) : rows2.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
     }
-    const rows = await executeOnClient(this.client, rewrittenQuery, params, {
+    const rows = await executeOnClient(this.client, this.queryString, params, {
       prepareCache: this.prepareCache
     });
     return rows;
@@ -1445,7 +662,6 @@ class DuckDBSession extends PgSession {
   static [entityKind] = "DuckDBSession";
   dialect;
   logger;
-  rewriteArraysMode;
   rejectStringArrayLiterals;
   prepareCache;
   hasWarnedArrayLiteral = false;
@@ -1457,17 +673,15 @@ class DuckDBSession extends PgSession {
     this.options = options;
     this.dialect = dialect;
     this.logger = options.logger ?? new NoopLogger;
-    this.rewriteArraysMode = options.rewriteArrays ?? "auto";
     this.rejectStringArrayLiterals = options.rejectStringArrayLiterals ?? false;
     this.prepareCache = options.prepareCache;
     this.options = {
       ...options,
-      rewriteArrays: this.rewriteArraysMode,
       prepareCache: this.prepareCache
     };
   }
   prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
-    return new DuckDBPreparedQuery(this.client, this.dialect, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, this.rewriteArraysMode, this.rejectStringArrayLiterals, this.prepareCache, this.rejectStringArrayLiterals ? undefined : this.warnOnStringArrayLiteral);
+    return new DuckDBPreparedQuery(this.client, this.dialect, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, this.rejectStringArrayLiterals, this.prepareCache, this.rejectStringArrayLiterals ? undefined : this.warnOnStringArrayLiteral);
   }
   execute(query) {
     this.dialect.resetPgJsonFlag();
@@ -1527,12 +741,8 @@ query: ${query}`, []);
       rejectStringArrayLiterals: this.rejectStringArrayLiterals,
       warnOnStringArrayLiteral: this.rejectStringArrayLiterals ? undefined : () => this.warnOnStringArrayLiteral(builtQuery.sql)
     });
-    const { sql: rewrittenQuery, rewritten: didRewrite } = rewriteQuery(this.rewriteArraysMode, builtQuery.sql);
-    if (didRewrite) {
-      this.logger.logQuery(`[duckdb] original query before array rewrite: ${builtQuery.sql}`, params);
-    }
-    this.logger.logQuery(rewrittenQuery, params);
-    return executeInBatches(this.client, rewrittenQuery, params, options);
+    this.logger.logQuery(builtQuery.sql, params);
+    return executeInBatches(this.client, builtQuery.sql, params, options);
   }
   executeBatchesRaw(query, options = {}) {
     this.dialect.resetPgJsonFlag();
@@ -1542,12 +752,8 @@ query: ${query}`, []);
       rejectStringArrayLiterals: this.rejectStringArrayLiterals,
       warnOnStringArrayLiteral: this.rejectStringArrayLiterals ? undefined : () => this.warnOnStringArrayLiteral(builtQuery.sql)
     });
-    const { sql: rewrittenQuery, rewritten: didRewrite } = rewriteQuery(this.rewriteArraysMode, builtQuery.sql);
-    if (didRewrite) {
-      this.logger.logQuery(`[duckdb] original query before array rewrite: ${builtQuery.sql}`, params);
-    }
-    this.logger.logQuery(rewrittenQuery, params);
-    return executeInBatchesRaw(this.client, rewrittenQuery, params, options);
+    this.logger.logQuery(builtQuery.sql, params);
+    return executeInBatchesRaw(this.client, builtQuery.sql, params, options);
   }
   async executeArrow(query) {
     this.dialect.resetPgJsonFlag();
@@ -1557,12 +763,8 @@ query: ${query}`, []);
       rejectStringArrayLiterals: this.rejectStringArrayLiterals,
       warnOnStringArrayLiteral: this.rejectStringArrayLiterals ? undefined : () => this.warnOnStringArrayLiteral(builtQuery.sql)
     });
-    const { sql: rewrittenQuery, rewritten: didRewrite } = rewriteQuery(this.rewriteArraysMode, builtQuery.sql);
-    if (didRewrite) {
-      this.logger.logQuery(`[duckdb] original query before array rewrite: ${builtQuery.sql}`, params);
-    }
-    this.logger.logQuery(rewrittenQuery, params);
-    return executeArrowOnClient(this.client, rewrittenQuery, params);
+    this.logger.logQuery(builtQuery.sql, params);
+    return executeArrowOnClient(this.client, builtQuery.sql, params);
   }
   markRollbackOnly() {
     this.rollbackOnly = true;
@@ -1664,6 +866,524 @@ import {
 import {
   sql as sql2
 } from "drizzle-orm";
+
+// src/sql/ast-transformer.ts
+import nodeSqlParser from "node-sql-parser";
+
+// src/sql/visitors/array-operators.ts
+var OPERATOR_MAP = {
+  "@>": { fn: "array_has_all" },
+  "<@": { fn: "array_has_all", swap: true },
+  "&&": { fn: "array_has_any" }
+};
+function walkExpression(expr, parent, key) {
+  if (!expr || typeof expr !== "object")
+    return false;
+  let transformed = false;
+  const exprObj = expr;
+  if ("type" in expr && exprObj.type === "binary_expr") {
+    const binary = expr;
+    const mapping = OPERATOR_MAP[binary.operator];
+    if (mapping) {
+      const fnExpr = {
+        type: "function",
+        name: { name: [{ type: "default", value: mapping.fn }] },
+        args: {
+          type: "expr_list",
+          value: mapping.swap ? [binary.right, binary.left] : [binary.left, binary.right]
+        }
+      };
+      if (parent && key) {
+        parent[key] = fnExpr;
+      }
+      transformed = true;
+    } else {
+      transformed = walkExpression(binary.left, binary, "left") || transformed;
+      transformed = walkExpression(binary.right, binary, "right") || transformed;
+    }
+  }
+  if ("type" in expr && exprObj.type === "unary_expr") {
+    if ("expr" in exprObj) {
+      transformed = walkExpression(exprObj.expr, exprObj, "expr") || transformed;
+    }
+  }
+  if ("type" in expr && exprObj.type === "case") {
+    if ("expr" in exprObj && exprObj.expr) {
+      transformed = walkExpression(exprObj.expr, exprObj, "expr") || transformed;
+    }
+    if ("args" in exprObj && Array.isArray(exprObj.args)) {
+      for (let i = 0;i < exprObj.args.length; i++) {
+        const whenClause = exprObj.args[i];
+        if (whenClause.cond) {
+          transformed = walkExpression(whenClause.cond, whenClause, "cond") || transformed;
+        }
+        if (whenClause.result) {
+          transformed = walkExpression(whenClause.result, whenClause, "result") || transformed;
+        }
+      }
+    }
+  }
+  if ("args" in expr && exprObj.args) {
+    const args = exprObj.args;
+    if ("value" in args && Array.isArray(args.value)) {
+      for (let i = 0;i < args.value.length; i++) {
+        transformed = walkExpression(args.value[i], args.value, String(i)) || transformed;
+      }
+    } else if ("expr" in args) {
+      transformed = walkExpression(args.expr, args, "expr") || transformed;
+    }
+  }
+  if ("ast" in exprObj && exprObj.ast) {
+    const subAst = exprObj.ast;
+    if (subAst.type === "select") {
+      transformed = walkSelectImpl(subAst) || transformed;
+    }
+  }
+  if ("type" in expr && exprObj.type === "expr_list") {
+    if ("value" in exprObj && Array.isArray(exprObj.value)) {
+      for (let i = 0;i < exprObj.value.length; i++) {
+        transformed = walkExpression(exprObj.value[i], exprObj.value, String(i)) || transformed;
+      }
+    }
+  }
+  return transformed;
+}
+function walkFrom(from) {
+  if (!from || !Array.isArray(from))
+    return false;
+  let transformed = false;
+  for (const f of from) {
+    if ("join" in f) {
+      const join = f;
+      transformed = walkExpression(join.on, join, "on") || transformed;
+    }
+    if ("expr" in f && f.expr && "ast" in f.expr) {
+      transformed = walkSelectImpl(f.expr.ast) || transformed;
+    }
+  }
+  return transformed;
+}
+function walkSelectImpl(select) {
+  let transformed = false;
+  if (select.with) {
+    for (const cte of select.with) {
+      const cteSelect = cte.stmt?.ast ?? cte.stmt;
+      if (cteSelect && cteSelect.type === "select") {
+        transformed = walkSelectImpl(cteSelect) || transformed;
+      }
+    }
+  }
+  if (Array.isArray(select.from)) {
+    transformed = walkFrom(select.from) || transformed;
+  }
+  transformed = walkExpression(select.where, select, "where") || transformed;
+  if (select.having) {
+    if (Array.isArray(select.having)) {
+      for (let i = 0;i < select.having.length; i++) {
+        transformed = walkExpression(select.having[i], select.having, String(i)) || transformed;
+      }
+    } else {
+      transformed = walkExpression(select.having, select, "having") || transformed;
+    }
+  }
+  if (Array.isArray(select.columns)) {
+    for (const col of select.columns) {
+      if ("expr" in col) {
+        transformed = walkExpression(col.expr, col, "expr") || transformed;
+      }
+    }
+  }
+  if (select._next) {
+    transformed = walkSelectImpl(select._next) || transformed;
+  }
+  return transformed;
+}
+function transformArrayOperators(ast) {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+  for (const stmt of statements) {
+    if (stmt.type === "select") {
+      transformed = walkSelectImpl(stmt) || transformed;
+    }
+  }
+  return transformed;
+}
+
+// src/sql/visitors/column-qualifier.ts
+function getTableSource(from) {
+  if ("table" in from && from.table) {
+    return {
+      name: from.table,
+      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,
+      schema: null
+    };
+  }
+  return null;
+}
+function getQualifier(source) {
+  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);
+}
+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") {
+    return col.column;
+  }
+  if (col.column && "expr" in col.column && col.column.expr?.value) {
+    return String(col.column.expr.value);
+  }
+  return null;
+}
+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 (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;
+      }
+    }
+    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;
+}
+function qualifyAmbiguousInExpression(expr, defaultQualifier, ambiguousColumns) {
+  if (!expr || typeof expr !== "object")
+    return false;
+  let transformed = false;
+  if (isUnqualifiedColumnRef(expr)) {
+    const colName = getColumnName(expr);
+    if (colName && ambiguousColumns.has(colName)) {
+      applyQualifier(expr, defaultQualifier);
+      transformed = true;
+    }
+    return transformed;
+  }
+  if (isBinaryExpr(expr)) {
+    const binary = expr;
+    transformed = qualifyAmbiguousInExpression(binary.left, defaultQualifier, ambiguousColumns) || transformed;
+    transformed = qualifyAmbiguousInExpression(binary.right, defaultQualifier, ambiguousColumns) || transformed;
+    return transformed;
+  }
+  if ("args" in expr && expr.args) {
+    const args = expr.args;
+    if (args.value && Array.isArray(args.value)) {
+      for (const arg of args.value) {
+        transformed = qualifyAmbiguousInExpression(arg, defaultQualifier, ambiguousColumns) || transformed;
+      }
+    }
+    if (args.expr) {
+      transformed = qualifyAmbiguousInExpression(args.expr, defaultQualifier, ambiguousColumns) || transformed;
+    }
+  }
+  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) : null;
+    let prevSource = firstSource;
+    let hasAnyUnqualified = false;
+    for (const from of select.from) {
+      if ("join" in from) {
+        const join = from;
+        if (join.on && hasUnqualifiedColumns(join.on)) {
+          hasAnyUnqualified = true;
+          break;
+        }
+      }
+    }
+    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;
+        }
+      }
+      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;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (select.with) {
+    for (const cte of select.with) {
+      const cteSelect = cte.stmt?.ast ?? cte.stmt;
+      if (cteSelect && cteSelect.type === "select") {
+        transformed = walkSelect(cteSelect) || transformed;
+      }
+    }
+  }
+  if (select._next) {
+    transformed = walkSelect(select._next) || transformed;
+  }
+  return transformed;
+}
+function qualifyJoinColumns(ast) {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+  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/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 = hasJoin(query) || /\bupdate\b/i.test(query) || /\bdelete\b/i.test(query);
+  if (!needsArrayTransform && !needsJoinTransform) {
+    return { sql: query, transformed: false };
+  }
+  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 };
+    }
+  });
+}
+
+// src/dialect.ts
 class DuckDBDialect extends PgDialect {
   static [entityKind2] = "DuckDBPgDialect";
   hasPgJsonColumn = false;
@@ -1740,6 +1460,14 @@ class DuckDBDialect extends PgDialect {
       return "none";
     }
   }
+  sqlToQuery(sqlObj, invokeSource) {
+    const result = super.sqlToQuery(sqlObj, invokeSource);
+    const transformed = transformSQL(result.sql);
+    return {
+      ...result,
+      sql: transformed.sql
+    };
+  }
 }
 
 // src/select-builder.ts
@@ -1750,10 +1478,10 @@ import {
 } from "drizzle-orm/pg-core/query-builders";
 import { Subquery, ViewBaseConfig } from "drizzle-orm";
 import { PgViewBase } from "drizzle-orm/pg-core/view-base";
-import { SQL as SQL4 } from "drizzle-orm/sql/sql";
+import { SQL as SQL5 } from "drizzle-orm/sql/sql";
 
 // src/sql/selection.ts
-import { Column as Column2, SQL as SQL3, getTableName as getTableName2, is as is3, sql as sql3 } from "drizzle-orm";
+import { Column as Column2, SQL as SQL4, getTableName as getTableName2, is as is3, sql as sql3 } from "drizzle-orm";
 function mapEntries(obj, prefix, fullJoin = false) {
   return Object.fromEntries(Object.entries(obj).filter(([key]) => key !== "enableRLS").map(([key, value]) => {
     const qualified = prefix ? `${prefix}.${key}` : key;
@@ -1763,16 +1491,16 @@ function mapEntries(obj, prefix, fullJoin = false) {
         sql3`${value}`.mapWith(value).as(`${getTableName2(value.table)}.${value.name}`)
       ];
     }
-    if (fullJoin && is3(value, SQL3)) {
+    if (fullJoin && is3(value, SQL4)) {
       const col = value.getSQL().queryChunks.find((chunk) => is3(chunk, Column2));
       const tableName = col?.table && getTableName2(col?.table);
       return [key, value.as(tableName ? `${tableName}.${key}` : key)];
     }
-    if (is3(value, SQL3) || is3(value, Column2)) {
-      const aliased = is3(value, SQL3) ? value : sql3`${value}`.mapWith(value);
+    if (is3(value, SQL4) || is3(value, Column2)) {
+      const aliased = is3(value, SQL4) ? value : sql3`${value}`.mapWith(value);
       return [key, aliased.as(qualified)];
     }
-    if (is3(value, SQL3.Aliased)) {
+    if (is3(value, SQL4.Aliased)) {
       return [key, value];
     }
     if (typeof value === "object" && value !== null) {
@@ -1820,7 +1548,7 @@ class DuckDBSelectBuilder extends PgSelectBuilder {
       ]));
     } else if (is4(src, PgViewBase)) {
       fields = src[ViewBaseConfig]?.selectedFields;
-    } else if (is4(src, SQL4)) {
+    } else if (is4(src, SQL5)) {
       fields = {};
     } else {
       fields = aliasFields(getTableColumns(src), !isPartialSelect);
@@ -2011,16 +1739,6 @@ function createDuckDBConnectionPool(instance, options = {}) {
 }
 
 // src/options.ts
-var DEFAULT_REWRITE_ARRAYS_MODE = "auto";
-function resolveRewriteArraysOption(value) {
-  if (value === undefined)
-    return DEFAULT_REWRITE_ARRAYS_MODE;
-  if (value === true)
-    return "auto";
-  if (value === false)
-    return "never";
-  return value;
-}
 var DEFAULT_PREPARED_CACHE_SIZE = 32;
 function resolvePrepareCacheOption(option) {
   if (!option)
@@ -2050,7 +1768,6 @@ class DuckDBDriver {
   createSession(schema) {
     return new DuckDBSession(this.client, this.dialect, schema, {
       logger: this.options.logger,
-      rewriteArrays: this.options.rewriteArrays ?? "auto",
       rejectStringArrayLiterals: this.options.rejectStringArrayLiterals,
       prepareCache: this.options.prepareCache
     });
@@ -2065,7 +1782,6 @@ function isConfigObject(data) {
 }
 function createFromClient(client, config = {}, instance) {
   const dialect = new DuckDBDialect;
-  const rewriteArraysMode = resolveRewriteArraysOption(config.rewriteArrays);
   const prepareCache = resolvePrepareCacheOption(config.prepareCache);
   const logger = config.logger === true ? new DefaultLogger : config.logger || undefined;
   let schema;
@@ -2079,7 +1795,6 @@ function createFromClient(client, config = {}, instance) {
   }
   const driver = new DuckDBDriver(client, dialect, {
     logger,
-    rewriteArrays: rewriteArraysMode,
     rejectStringArrayLiterals: config.rejectStringArrayLiterals,
     prepareCache
   });
@@ -2743,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,
@@ -2768,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":
@@ -2788,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}`);
@@ -2830,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);
@@ -2871,5 +2586,5 @@ async function main() {
 }
 main().catch((err) => {
   console.error(err instanceof Error ? err.message : err);
-  process.exit(1);
+  process2.exit(1);
 });