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

package/dist/index.mjs

@@ -175,6 +175,604 @@ function adaptArrayOperators(query) {
   }
   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 {
@@ -815,8 +1413,19 @@ function rewriteQuery(mode, query) {
   if (mode === "never") {
     return { sql: query, rewritten: false };
   }
-  const rewritten = adaptArrayOperators(query);
-  return { sql: rewritten, rewritten: rewritten !== query };
+  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 {
@@ -1729,6 +2338,9 @@ var duckDbMap = (name, valueType) => customType({
     return `MAP (STRING, ${valueType})`;
   },
   toDriver(value) {
+    if (Object.keys(value).length === 0) {
+      return buildMapLiteral(value, valueType);
+    }
     return wrapMap(value, valueType);
   },
   fromDriver(value) {

package/dist/sql/query-rewriters.d.ts

@@ -1,2 +1,15 @@
 export declare function scrubForRewrite(query: string): string;
 export declare function adaptArrayOperators(query: string): string;
+/**
+ * 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 declare function qualifyJoinColumns(query: string): string;

package/package.json

@@ -3,7 +3,7 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "A drizzle ORM client for use with DuckDB. Based on drizzle's Postgres client.",
   "type": "module",
   "scripts": {
@@ -77,5 +77,8 @@
     "src/**/*.ts",
     "dist/*.mjs",
     "dist/**/*.d.ts"
-  ]
+  ],
+  "dependencies": {
+    "@duckdb/node-bindings-darwin-arm64": "^1.4.2-r.1"
+  }
 }

package/src/columns.ts

@@ -237,7 +237,12 @@ export const duckDbMap = <TData extends Record<string, any>>(
     dataType() {
       return `MAP (STRING, ${valueType})`;
     },
-    toDriver(value: TData): MapValueWrapper {
+    toDriver(value: TData) {
+      // Use SQL literals for empty maps due to DuckDB type inference issues
+      // with mapValue() when there are no entries to infer types from
+      if (Object.keys(value).length === 0) {
+        return buildMapLiteral(value, valueType);
+      }
       return wrapMap(value, valueType);
     },
     fromDriver(value: TData | MapValueWrapper): TData {