@leonardovida-md/drizzle-neo-duckdb 1.1.2 → 1.1.4

package/src/sql/query-rewriters.ts

@@ -211,3 +211,951 @@ export function adaptArrayOperators(query: string): string {
 
   return rewritten;
 }
+
+// Join column qualification types and helpers
+
+type TableSource = {
+  name: string; // The table/CTE name (without quotes)
+  alias?: string; // Optional alias
+  position: number; // Position in the query where this source was introduced
+};
+
+type JoinClause = {
+  joinType: string; // 'left', 'right', 'inner', 'full', 'cross', ''
+  tableName: string; // The joined table name
+  tableAlias?: string; // Optional alias
+  onStart: number; // Start of ON clause content (after "on ")
+  onEnd: number; // End of ON clause content
+  leftSource: string; // The table/alias on the left side of this join
+  rightSource: string; // The table/alias for the joined table
+};
+
+/**
+ * Extracts the identifier name from a quoted identifier like "foo" -> foo
+ * Uses the original query string, not the scrubbed one.
+ * Handles escaped quotes: "col""name" -> col""name
+ */
+function extractQuotedIdentifier(
+  original: string,
+  start: number
+): { name: string; end: number } | null {
+  if (original[start] !== '"') {
+    return null;
+  }
+
+  let pos = start + 1;
+  while (pos < original.length) {
+    if (original[pos] === '"') {
+      // Check for escaped quote ""
+      if (original[pos + 1] === '"') {
+        pos += 2;
+        continue;
+      }
+      // End of identifier
+      break;
+    }
+    pos++;
+  }
+
+  if (pos >= original.length) {
+    return null;
+  }
+
+  return {
+    name: original.slice(start + 1, pos),
+    end: pos + 1,
+  };
+}
+
+/**
+ * Finds the main SELECT's FROM clause, skipping any FROM inside CTEs.
+ */
+function findMainFromClause(scrubbed: string): number {
+  const lowerScrubbed = scrubbed.toLowerCase();
+
+  // If there's a WITH clause, find where the CTEs end
+  let searchStart = 0;
+  const withMatch = /\bwith\s+/i.exec(lowerScrubbed);
+  if (withMatch) {
+    // Find the main SELECT after the CTEs
+    // CTEs are separated by commas and end with the main SELECT
+    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) {
+        // Check if we're at "select" keyword (main query)
+        const remaining = lowerScrubbed.slice(pos);
+        if (/^\s*select\s+/i.test(remaining)) {
+          searchStart = pos;
+          break;
+        }
+      }
+      pos++;
+    }
+  }
+
+  // Find FROM after the main SELECT
+  const fromPattern = /\bfrom\s+/gi;
+  fromPattern.lastIndex = searchStart;
+  const fromMatch = fromPattern.exec(lowerScrubbed);
+
+  return fromMatch ? fromMatch.index + fromMatch[0].length : -1;
+}
+
+/**
+ * Parses table sources from FROM and JOIN clauses.
+ * Returns an array of table sources in order of appearance.
+ */
+function parseTableSources(original: string, scrubbed: string): TableSource[] {
+  const sources: TableSource[] = [];
+  const lowerScrubbed = scrubbed.toLowerCase();
+
+  // Find the main FROM clause (after CTEs if present)
+  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;
+}
+
+/**
+ * Parses a table reference (potentially with alias) starting at the given position.
+ * Handles: "table", "table" "alias", "table" as "alias", "schema"."table",
+ * and subqueries: (SELECT ...) AS "alias"
+ */
+function parseTableRef(
+  original: string,
+  scrubbed: string,
+  start: number
+): TableSource | null {
+  let pos = start;
+  while (pos < scrubbed.length && isWhitespace(scrubbed[pos])) {
+    pos++;
+  }
+
+  // Handle subquery: (SELECT ...) AS "alias"
+  if (scrubbed[pos] === '(') {
+    const nameStart = pos;
+    // Find matching closing parenthesis
+    let depth = 1;
+    pos++;
+    while (pos < scrubbed.length && depth > 0) {
+      if (scrubbed[pos] === '(') depth++;
+      else if (scrubbed[pos] === ')') depth--;
+      pos++;
+    }
+
+    // Skip whitespace after subquery
+    while (pos < scrubbed.length && isWhitespace(scrubbed[pos])) {
+      pos++;
+    }
+
+    // Look for AS keyword
+    const afterSubquery = scrubbed.slice(pos).toLowerCase();
+    if (afterSubquery.startsWith('as ')) {
+      pos += 3;
+      while (pos < scrubbed.length && isWhitespace(scrubbed[pos])) {
+        pos++;
+      }
+    }
+
+    // Extract alias
+    if (original[pos] === '"') {
+      const aliasIdent = extractQuotedIdentifier(original, pos);
+      if (aliasIdent) {
+        return {
+          name: aliasIdent.name,
+          alias: aliasIdent.name,
+          position: nameStart,
+        };
+      }
+    }
+
+    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;
+
+  // Check for schema.table pattern
+  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: string | undefined;
+  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++;
+    }
+  }
+
+  // Check what comes after (potentially skipping the AS keyword)
+  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,
+  };
+}
+
+/**
+ * Finds all JOIN clauses with their ON clause boundaries.
+ */
+function findJoinClauses(
+  original: string,
+  scrubbed: string,
+  sources: TableSource[],
+  fromPos: number
+): JoinClause[] {
+  const clauses: JoinClause[] = [];
+  const lowerScrubbed = scrubbed.toLowerCase();
+
+  // Pattern to find JOINs with ON clauses
+  // Use scrubbed for matching, original for extracting values
+  // Handle optional schema prefix: "schema"."table" or just "table"
+  const joinPattern =
+    /\b(left\s+|right\s+|inner\s+|full\s+|cross\s+)?join\s+"[^"]*"(\s*\.\s*"[^"]*")?(\s+as)?(\s+"[^"]*")?\s+on\s+/gi;
+
+  // Start searching from the main FROM clause, skipping JOINs inside CTE definitions
+  joinPattern.lastIndex = fromPos;
+
+  let match;
+  let sourceIndex = 1; // Start at 1 since index 0 is the FROM table
+
+  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: string | undefined;
+    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;
+
+    // Find the end of the ON clause (next JOIN, WHERE, GROUP, ORDER, LIMIT, or end)
+    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;
+
+    // Determine the left source (previous table/CTE)
+    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;
+}
+
+/**
+ * Finds the boundaries of the main query's SELECT clause (after CTEs).
+ * Returns the start position (after "select ") and end position (before "from ").
+ */
+function findMainSelectClause(
+  scrubbed: string
+): { start: number; end: number } | null {
+  const lowerScrubbed = scrubbed.toLowerCase();
+
+  // If there's a WITH clause, find where the CTEs end
+  let searchStart = 0;
+  const withMatch = /\bwith\s+/i.exec(lowerScrubbed);
+  if (withMatch) {
+    // Find the main SELECT after the CTEs
+    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++;
+    }
+  }
+
+  // Find SELECT keyword
+  const selectPattern = /\bselect\s+/gi;
+  selectPattern.lastIndex = searchStart;
+  const selectMatch = selectPattern.exec(lowerScrubbed);
+  if (!selectMatch) return null;
+
+  const selectStart = selectMatch.index + selectMatch[0].length;
+
+  // Find FROM keyword at same depth
+  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;
+}
+
+/**
+ * Finds WHERE clause boundaries in the main query.
+ */
+function findWhereClause(
+  scrubbed: string,
+  fromPos: number
+): { start: number; end: number } | null {
+  const lowerScrubbed = scrubbed.toLowerCase();
+
+  // Find WHERE keyword after FROM, at depth 0
+  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;
+}
+
+/**
+ * Finds ORDER BY clause boundaries in the main query.
+ */
+function findOrderByClause(
+  scrubbed: string,
+  fromPos: number
+): { start: number; end: number } | null {
+  const lowerScrubbed = scrubbed.toLowerCase();
+
+  // Find ORDER BY keyword after FROM, at depth 0
+  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;
+}
+
+/**
+ * Qualifies only specific column references (from the ambiguousColumns set) in a clause.
+ * This handles SELECT, WHERE, and ORDER BY clauses where columns from joined tables
+ * could be ambiguous.
+ */
+function qualifyClauseColumnsSelective(
+  original: string,
+  scrubbed: string,
+  clauseStart: number,
+  clauseEnd: number,
+  defaultSource: string,
+  ambiguousColumns: Set<string>
+): { result: string; offset: number } {
+  const clauseOriginal = original.slice(clauseStart, clauseEnd);
+  const clauseScrubbed = scrubbed.slice(clauseStart, clauseEnd);
+
+  let result = clauseOriginal;
+  let offset = 0;
+
+  // Find all unqualified quoted identifiers
+  let pos = 0;
+  while (pos < clauseScrubbed.length) {
+    // Skip to next quote
+    const quotePos = clauseScrubbed.indexOf('"', pos);
+    if (quotePos === -1) break;
+
+    // Check if this is already qualified (preceded by a dot)
+    if (quotePos > 0 && clauseScrubbed[quotePos - 1] === '.') {
+      // Skip this identifier - it's already qualified
+      const ident = extractQuotedIdentifier(clauseOriginal, quotePos);
+      pos = ident ? ident.end : quotePos + 1;
+      continue;
+    }
+
+    // Extract the identifier
+    const ident = extractQuotedIdentifier(clauseOriginal, quotePos);
+    if (!ident) {
+      pos = quotePos + 1;
+      continue;
+    }
+
+    // Check if this identifier is followed by a dot (it's a table qualifier, not a column)
+    if (
+      ident.end < clauseScrubbed.length &&
+      clauseScrubbed[ident.end] === '.'
+    ) {
+      pos = ident.end + 1;
+      continue;
+    }
+
+    // Only qualify if this column is in the ambiguous set
+    if (!ambiguousColumns.has(ident.name)) {
+      pos = ident.end;
+      continue;
+    }
+
+    // Check if this looks like a column reference (not a function call or alias definition)
+    // Skip if followed by ( which would indicate a function
+    let afterIdent = ident.end;
+    while (
+      afterIdent < clauseScrubbed.length &&
+      isWhitespace(clauseScrubbed[afterIdent])
+    ) {
+      afterIdent++;
+    }
+    if (clauseScrubbed[afterIdent] === '(') {
+      pos = ident.end;
+      continue;
+    }
+
+    // Skip if this is an alias definition (preceded by AS or follows a column expression)
+    // Look for patterns like: "col" as "alias" or just "col", "alias"
+    // We need to be careful here - we only want to qualify column references, not aliases
+    const beforeQuote = clauseScrubbed.slice(0, quotePos).toLowerCase();
+    if (/\bas\s*$/i.test(beforeQuote)) {
+      pos = ident.end;
+      continue;
+    }
+
+    // Qualify this column reference
+    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 };
+}
+
+/**
+ * Qualifies unqualified column references in JOIN ON clauses, SELECT, WHERE,
+ * and ORDER BY clauses.
+ *
+ * Transforms patterns like:
+ *   `select "col" from "a" left join "b" on "col" = "col" where "col" in (...)`
+ * To:
+ *   `select "a"."col" from "a" left join "b" on "a"."col" = "b"."col" where "a"."col" in (...)`
+ *
+ * This fixes the issue where drizzle-orm generates unqualified column
+ * references when joining CTEs with eq().
+ */
+export function qualifyJoinColumns(query: string): string {
+  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;
+  }
+
+  // Get the first source (FROM table) as the default qualifier
+  const firstSource = sources[0]!;
+  const defaultQualifier = firstSource.alias || firstSource.name;
+
+  let result = query;
+  let totalOffset = 0;
+
+  // First, qualify ON clauses (existing logic)
+  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;
+
+      // Find start of identifier, handling escaped quotes ""
+      let lhsStartPos = lhsEnd - 1;
+      while (lhsStartPos >= 0) {
+        if (scrubbedOnClause[lhsStartPos] === '"') {
+          // Check if this is an escaped quote ""
+          if (lhsStartPos > 0 && scrubbedOnClause[lhsStartPos - 1] === '"') {
+            // Skip over the escaped quote pair
+            lhsStartPos -= 2;
+            continue;
+          }
+          // Found the opening quote
+          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: { name: string; end: number } | null = 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) {
+          // Check if this identifier is followed by a dot (meaning it's a table prefix, not the column)
+          if (
+            rhsIdent.end < scrubbedOnClause.length &&
+            scrubbedOnClause[rhsIdent.end] === '.'
+          ) {
+            // This is a qualified reference "table"."column" - skip, it's already qualified
+            continue;
+          }
+          rhsValue = `"${rhsIdent.name}"`;
+          rhsEnd = rhsIdent.end;
+        }
+      }
+
+      if (!rhsValue) continue;
+
+      // Only qualify when both sides are columns with the same name.
+      // Only same-named columns cause "Ambiguous reference" errors in DuckDB.
+      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;
+    }
+  }
+
+  // Collect column names that are known to be ambiguous (appeared in ON clauses with same name on both sides)
+  const ambiguousColumns = new Set<string>();
+  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 no ambiguous columns were found, we're done
+  if (ambiguousColumns.size === 0) {
+    return result;
+  }
+
+  // Now qualify SELECT, WHERE, and ORDER BY clauses - only for ambiguous columns
+  // We need to re-scrub since the query may have changed
+  const updatedScrubbed = scrubForRewrite(result);
+
+  // Qualify SELECT clause
+  const selectClause = findMainSelectClause(updatedScrubbed);
+  if (selectClause) {
+    const { result: selectResult, offset: selectOffset } =
+      qualifyClauseColumnsSelective(
+        result,
+        updatedScrubbed,
+        selectClause.start,
+        selectClause.end,
+        defaultQualifier,
+        ambiguousColumns
+      );
+    if (selectOffset !== 0) {
+      // Splice the modified clause back into the full query
+      result =
+        result.slice(0, selectClause.start) +
+        selectResult +
+        result.slice(selectClause.end);
+    }
+  }
+
+  // Re-scrub after SELECT changes
+  const scrubbed2 = scrubForRewrite(result);
+  const fromPos2 = findMainFromClause(scrubbed2);
+
+  // Qualify WHERE clause
+  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) {
+        // Splice the modified clause back into the full query
+        result =
+          result.slice(0, whereClause.start) +
+          whereResult +
+          result.slice(whereClause.end);
+      }
+    }
+  }
+
+  // Re-scrub after WHERE changes
+  const scrubbed3 = scrubForRewrite(result);
+  const fromPos3 = findMainFromClause(scrubbed3);
+
+  // Qualify ORDER BY clause
+  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) {
+        // Splice the modified clause back into the full query
+        result =
+          result.slice(0, orderByClause.start) +
+          orderResult +
+          result.slice(orderByClause.end);
+      }
+    }
+  }
+
+  return result;
+}